One Protocol for Every Pool
The share-pool standard is the interoperability layer of the pool economy: the shared schema, protocol, and semantics that let pools from different operators transact with each other. Without a standard, every pool is an island — its credits spend only inside its walls, its reputation means nothing outside, its ledger cannot be read by other systems. The standard is what turns the collection of pools into a network.
This article covers the share-pool standard: the schema, the protocol, the identity bridge, and the standard as the pool economy’s public good.
The Schema
The standard’s first layer is the schema: the shared data model for the pool’s core records — the ledger events, the contributions, the split computations, the escrow states, the reputation scores, the bills of lading. Every pool that conforms to the schema produces records that any conforming system can read, which is the precondition for interop.
The schema’s design is a governance decision disguised as a technical one: the schema defines what can be recorded, and what can be recorded defines what can be known. The schema must be expressive enough for the pool types in this series (the human co-op’s contributions, the fleet’s cost pools, the marketplace’s escrows) and extensible enough for the pool types that do not exist yet. The schema is the pool economy’s language, and the language’s design is the economy’s constitution.
The Protocol
The standard’s second layer is the protocol: the rules for how pools exchange value — the transfer instructions, the escrow handoffs, the settlement messages, the reputation queries. The protocol defines the message formats, the sequence rules, and the error handling: a payment request, an escrow confirmation, a settlement receipt, a dispute notification.
The protocol must be machine-executable: the messages are structured, the sequences are deterministic, the failures are defined. The protocol’s quality is measured by its edge cases — the payment that times out, the escrow that never confirms, the settlement that conflicts — and the protocol that handles its edge cases is the protocol that the agents can rely on. The agent economy runs on the protocol’s invariants, the same way the payment rails ran on theirs.
The Identity Bridge
The standard’s hardest layer is identity: how does a pool’s member — a human or an agent — prove who they are to another pool? The identity bridge maps the pool-local identities to the standard’s identity model: a human’s verified identity, an agent’s registered identity (with its operator’s attestation), and the reputation that travels with each.
The identity bridge is where the privacy and the trust meet: the standard must let a pool verify a member’s reputation without exposing the member’s full history, prove an agent’s registration without exposing its operator’s entire fleet, and attest an identity without creating a global surveillance database. The bridge’s design — the verifiable claims, the selective disclosure, the attestation chains — is the standard’s most delicate piece, because it is the piece where the pool economy’s ethics are decided.
The Standard as Public Good
The share-pool standard is a public good: its value grows as more pools adopt it, and its benefit accrues to the whole network, not just to its creator. The standard’s governance must therefore be open — the schema and protocol evolve through a visible process, the conformance testing is public, and the standard’s maintenance is funded by the network (the way the product line’s subscription funds the infrastructure).
The standard is also the product line’s strategic asset: the operator that defines and hosts the standard becomes the network’s reference point — the conforming implementation, the conformance test suite, the reference ledger. The standard is the product line’s moat, and it is a moat that grows with adoption: every pool that conforms to the standard is a pool that can transact with every other conforming pool, and the value of conforming compounds.
The Standard as the Series’ Capstone
The share-pool standard is the capstone of the architecture this series has built: it is the layer that makes the human-to-human, human-to-agent, and agent-to-agent pools one network. The standard is the answer to the question the series has been circling since the first article: how do the pools compose, interconnect, and scale? The answer: a shared schema, a machine protocol, an identity bridge, and an open governance — the standard that lets every pool speak the same language.
The standard is also the series’ promise to the future: the pool economy should not be a collection of proprietary islands, each holding its members’ value hostage. It should be a network where value flows freely between pools, where reputation is portable, where the audit trails are readable, and where the humans and the agents transact on equal rails. The standard is how that future becomes a protocol instead of a hope.
Grounded in wiki concepts share-pool-standard, interop, schema, protocol, identity, and the Sovereign-stack business series. Design notes on a running system.
