The Internet of Value

Open architecture brief · Founding CTO

Build the graph already inside The Internet of Value.

Two founder–architecture conversations became a technical mandate: make the relationships between human time, wellbeing, contribution, community judgment, identity, and consent explicit—without breaking the working system beneath them.

The mandate

Founder–architecture log
04 August 2026

The Internet of Value is not waiting to become a graph. It is already a governed temporal value graph.

The next technical task is to make that graph visible, queryable, interoperable, and open—while PostgreSQL remains the authoritative append-only ledger and Word Wallet remains the disclosure authority.

The test of judgment: the right CTO may recommend a graph database. They will not begin by replacing a working protocol system with one.

Conversation I · Is this already a graph?

Yes—but the word graph is carrying three meanings.

The first question began with the four protocols, the four tilde levels, Value Log, Founder mathematics, Wellbeing Identity, and Word Wallet. The answer separates the semantic graph, the provenance graph, and the execution graph.

“How far are we away from graph—or have we done something even better?”
Founder question

Architectural answer

Conceptually, semantically, operationally, and mathematically, IoV is already graph-shaped. What is missing is a unified traversal layer—not graphness.

A graph database can make relationships convenient to query. It cannot supply append-only truth, exact arithmetic, temporal policy, replay, authority, consent, or safe promotion by itself.

The two fours

Four Level 1 contexts

  1. 01 · ~ValueCaptureProtocol
  2. 02 · ~WellbecomingProtocol
  3. 03 · ~SAOcommons
  4. 04 · ~WellbeingIdentity

Wellbeing Identity is the fourth Level 1 context and convergence point. It is a living state, not another measurement engine.

Four semantic levels

~

Level 1 · Protocol

~WellbecomingProtocol

~~

Level 2 · Node

~~Performance

~~~

Level 3 · Facet

~~~LearningOutput

~~~~

Level 4 · Signal

~~~~ProtocolLinkId

One occurrence, four protocol contextsPerformance is the conditional gateway. Identity is the convergence point.

01 · Capture

~ValueCaptureProtocol

Time, activity, proof, attribution, integrity, and ProtocolLinkId.

02 · Interpret

~WellbecomingProtocol

One primary route across six human-state components.

03 · If Performance

~SAOcommons

Learning, Earning, or OrgBuilding validation and attestation.

04 · Converge

~WellbeingIdentity

Living state with owner-controlled disclosure through Word Wallet.

Private Physiology, Emotion, Feeling, Thought, and Habit routes may return to IdentityState without opening SAOcommons. No route implies automatic public disclosure.

Semantic graph

Protocol, node, facet, and signal form a machine-readable vocabulary. The hierarchy is tree-shaped; shared references connect it into a wider graph.

Protocol-flow graph

Value Capture routes every occurrence into Wellbecoming. Performance conditionally opens SAOcommons before governed outputs converge in Wellbeing Identity.

Provenance graph

ProtocolLinkId connects an occurrence to observation, validation, calculation, correction, reversal, replay, and identity consequences.

State graph

Append-only revisions create branches. Verification and explicit promotion decide which completed replay becomes the current projection.

Authority graph

The Spec defines meaning, Value Log holds private evidence and calculation, Word Wallet controls disclosure, and Foundation renders the reduced public result.

Mathematical graph

Wbefore, duration, policy, Vcom, typed value, impact review, and Wafter form an ordered dependency graph whose sequence prevents self-inflating valuation.

Execution graph

GPT proposal, owner confirmation, community validation, overlap gates, deterministic calculation, replay verification, promotion, signed delivery, and consent form a production workflow.

The Custom GPT belongs at the interpretive boundary: it proposes structure and gathers approval. It does not own the database, calculate W, decide validation, promote replay branches, or alter disclosure. Most consequential graph nodes remain deterministic functions and human gates.

Vertices

Person or DID · activity occurrence · time-slice revision · evidence · community · validation · attestation · policy version · calculation · replay · identity projection · disclosure grant

Edges

PERFORMED · ROUTED_TO · SUPPORTED_BY · VALIDATED_BY · VALUED_UNDER · CALCULATED_FROM · SUPERSEDES · REVERSES · VERIFIED_BY · PROMOTED_AS · UPDATES_IDENTITY · DISCLOSED_TO

The Internet of Value connects human activity, evidence, wellbeing, community judgment, mathematical state, identity, and consent.

Every important edge should eventually answer: who observed this, who validated it, under which policy, at what time, through which calculation, what did it supersede, and who consented to disclose it?

Conversation II · Should Postgres be converted?

Project the graph. Do not begin with a migration.

The second conversation turned the graph insight into an engineering and recruitment question. The correction is decisive: the first CTO task is not a database conversion. It is a lossless graph projection with measurable value and a reversible architecture decision.

Keep authoritative

PostgreSQL ledger

  • Append-only records and database constraints
  • Chronological replay and exact fixed-point arithmetic
  • Reversals, supersessions, verification, and promotion
  • Row-level security and private pilot operation

Make derived and rebuildable

Graph projection

  • Relationship traversal and provenance explanation
  • Cross-protocol and cross-product lineage
  • Developer tools and visual exploration
  • Graph analytics after privacy-safe workloads are proven
PostgreSQL append-only ledger
-- deterministic current projections
-- signed identity projections
-- graph adapter
    +-- provenance API
    +-- lineage explorer
    +-- optional graph engine

The graph must remain reproducible from the ledger. It must not become a second writer for W, value, identity, consent, or public disclosure.

DAG · Directed acyclic graph

The past may branch. It may not rewrite itself.

Directed means every edge has an arrow. Acyclic means following those arrows cannot return to the same node. A DAG can branch and converge; it simply cannot contain a directed loop.

Protocol flow

One occurrence moves from capture to interpretation, optional commons validation, and identity convergence.

Calculation dependency

Every derived quantity points back to earlier inputs; Wafter cannot reach backward and change its own Wbefore.

Replay history

A correction creates a new branch from an earlier state. The old branch remains inspectable rather than being overwritten.

Disclosure history

A new grant, expiry, or revocation changes the active public path while private projection receipts remain preserved.

DAG-shaped history

Baseline
-- Run A: S0 -> S1 -> S2
-- Run B: S0 -> S1' -> S2'
                       +-- Verification
                           +-- Promotion

Not one universal DAG

Human and community relationships can be cyclic. Evaluator–revision workflows can intentionally loop. The protocol history and calculation dependencies should be acyclic; the wider institutional knowledge graph need not be.

IoV has ledger-like and DAG-like properties, but it is not currently a blockchain: it does not use permissionless distributed consensus or claim public settlement.

The first architecture sprint

A CTO challenge that tests judgment, not fashion.

Treat this as a paid architecture sprint using synthetic records only. Preserve every current product and authority boundary. The strongest candidate may conclude that PostgreSQL is enough for the first public graph release.

  1. 01

    Model

    Define stable vertex and edge types, direction, authority, occurrence time, recording time, privacy, and versioning.

  2. 02

    Project

    Build a deterministic adapter from synthetic relational ledger records into a rebuildable graph projection.

  3. 03

    Traverse

    Answer why a state is current, what contributed to it, who validated it, which policy governed it, and what consent permits.

  4. 04

    Correct

    Demonstrate supersession, reversal, a new replay branch, verification, promotion, and unchanged historical evidence.

  5. 05

    Prove

    Detect orphan records, cycles where cycles are forbidden, double counting, unverified current branches, and disclosure without consent.

  6. 06

    Decide

    Write the architecture decision: remain in PostgreSQL, add a graph extension, or maintain a separate graph projection—and prove why.

Five traversals the prototype must answer

  1. 1. Why is this the current Wellbeing state?
  2. 2. Which occurrences contributed to it?
  3. 3. Who observed and validated each occurrence?
  4. 4. Which policy and replay produced each value?
  5. 5. Which private values may appear publicly—and why?

Non-negotiable boundaries

  • No production writes or personal pilot records.
  • No authoritative W calculation in the graph layer.
  • No inferred identity disclosure or public-facet decision.
  • No merging of Wellbeing points with Performance value.
  • No conversion of non-payable valuation into settlement.
  • No change to the existing product flow as a condition of the prototype.

How the work is judged

Protocol and identity comprehension
25%
Invariant and privacy preservation
25%
Graph-model quality
15%
Migration and failure judgment
15%
Deterministic reconciliation
10%
Open-source maintainability
10%

Open-source sequence

Make the contract open before making the infrastructure complicated.

  1. 01

    Graph contract v0.1

    Define the public ontology, relationship vocabulary, temporal rules, privacy classes, DAG invariants, and compatibility policy in the IoV Spec.

  2. 02

    Deterministic adapter

    Generate a stable graph from PostgreSQL without granting the graph write authority over calculations, identity, or disclosure.

  3. 03

    Conformance suite

    Publish synthetic fixtures and invariant tests so any implementation can prove equivalent lineage without seeing private pilot data.

  4. 04

    Provenance explorer

    Let a reader select an occurrence, state revision, or identity projection and follow the exact governed path that produced it.

  5. 05

    Engine benchmark

    Measure real traversal workloads in PostgreSQL first; compare a PostgreSQL graph extension and a separate native graph projection only after the queries are known.

  6. 06

    Federated trust

    Later, let communities sign narrow validation and attestation edges while people retain disclosure control in Word Wallet.

PostgreSQL recursive traversal ↗Apache AGE graph extension ↗Neo4j graph platform ↗

Job description · Founding Chief Technology Officer

We need a formidable CTO for a difficult, beautiful system.

This is not a caretaker role and not a graph-database installation project. It is a founding technical mandate to carry a human-value protocol from working founder implementation into trustworthy open infrastructure.

What you will own

  • Own the technical architecture across the IoV Spec, Value Log, Word Wallet, Foundation, protocol SDKs, and future community adapters.
  • Turn the existing implicit graph into an explicit open graph contract without destabilising the authoritative append-only ledger.
  • Protect protocol meaning across data models, APIs, calculations, identity projections, community authority, and public storytelling.
  • Build a small, high-agency engineering practice around tests, observability, security, documentation, and reversible releases.
  • Make privacy and consent architectural primitives: no public edge without authority, purpose, scope, and revocation behavior.
  • Choose infrastructure through measured workloads and clear failure modes—not fashion, vendor gravity, or résumé theatre.
  • Translate between mathematics, human experience, institutional governance, product design, and production code.
  • Grow an open-source contributor path that is legible enough for strangers to enter and rigorous enough for institutions to trust.

Your first ninety days

  1. Days 1–30

    Reconstruct the system

    Audit the four-protocol model, Founder math, Value Log lineage, Word Wallet authority boundary, Foundation rendering, threat model, and release discipline. Produce the graph RFC and a risk register.

  2. Days 31–60

    Make the graph visible

    Ship a synthetic graph contract, deterministic PostgreSQL adapter, conformance fixtures, five high-value traversals, and a private lineage prototype. No production source-of-truth migration.

  3. Days 61–90

    Make the decision reversible

    Benchmark the read workloads, publish the architecture decision, open the contributor surface, and define the next two engineering hires and six-month delivery sequence.

You may be the person if…

  • You have designed distributed, event-sourced, temporal, identity, ledger, or graph-shaped systems—and can explain where each model fails.
  • You are strong in PostgreSQL and data integrity, comfortable with graph traversal and property-graph or semantic-web models, and allergic to casual dual writes.
  • You can reason about exact arithmetic, replay, idempotency, bitemporal policy, cryptographic signatures, privacy, and authorization as one system.
  • You can read a protocol, challenge it constructively, encode it precisely, and leave a trail another engineer can maintain.
  • You are product-minded enough to preserve a calm human experience while changing deep infrastructure underneath it.
  • You can lead in public: write RFCs, welcome contributors, make hard trade-offs legible, and say ‘this does not need a graph database’ when that is the correct answer.

This is probably not for you if…

  • You want to begin with a rewrite.
  • You think blockchain, graph database, knowledge graph, and DAG are interchangeable words.
  • You treat privacy as a policy page instead of a data-flow constraint.
  • You optimise demos before invariants, or velocity before reversibility.
  • You need every important node to be an LLM.

The invitation

Do not send us a graph buzzword deck. Show us how you think.

Tell us what you believe the graph is, what must remain outside it, which invariant you would protect first, and what you would build before choosing a graph engine. If the problem feels unusually alive to you, begin the conversation.

Start the CTO conversation

Technical grounding

The brief is an invitation. The protocols remain the authority.

This page records an architectural direction and recruitment mandate. It does not change protocol definitions, calculation policy, private identity state, consent, or production data.

IoV protocol registry ↗Four-protocol public guideMath of valueWord Wallet and consent