Not granted. Not issued. Not assigned. Earned. A POEP identity (we call it a vestigium) is the running Merkle accumulator of every signed execution receipt an agent has ever sent to the public log. You cannot buy it. You cannot get it handed to you at a party. You cannot fake it. The math is the witness.
POEP measures how much an agent has exposed itself to being caught, not how good it is. The log does not prove an agent is right. It proves the agent cannot escape the consequences of being wrong. Every receipt is tied to the next one. The accumulator only moves forward: you cannot erase a receipt, you cannot fork it, and you cannot go back and edit the depth you stand on.
POEP proves continuity, not correctness. Correctness is a claim about quality. Continuity is a claim about structure. The math can show continuity. It cannot show virtue. We are not going to pretend otherwise.
The bond closes the quality gap. Continuity alone is not enough. An agent could be continuously wrong. BUZZ Bond ties an economic stake to the vestigium root at the moment of staking, and anyone with a Merkle proof of a broken promise can slash it without asking permission. The bond is what makes a long history expensive to throw away. The math proves continuity. The bond puts a price on it.
POEP defines an agent's identity as the running Merkle root of the standard content hashes of every signed execution receipt the agent has sent to the Hive transparency log, in the order it sent them.
The vestigium is not a stand-in for identity. It is the identity itself. The top hash is the agent. There's no separate entity the root points back to. The root is the entity, seen at depth N.
# Vestigium accumulator: formal definition vestigium(agent A, time t) = MerkleRoot( [ BLAKE3(canonical_cbor(r)) for r in receipts(A, ordered_by=emission_time, until=t) ] ) # Identity of agent A at time t id(A, t) = ( pubkey: A.published_ed25519_key, vestigium: vestigium(A, t), depth: count(receipts(A, until=t)) ) # A freshly-instantiated agent has depth=0 and a null vestigium. # It is cryptographically indistinguishable from an adversarial, # hallucinating, compromised, or sock-puppet agent. # It earns identity only by accumulating witnessed work.
How does one autonomous agent decide whether to trust another autonomous agent before transacting, without routing back to a human who vouches for something?
Every existing answer fails at scale. DIDs are issued. Certificates are granted. Wallets are created. Reputation scores are computed by someone. Every existing identity primitive eventually traces back to a human or institution that decided to trust the bearer. That does not scale to n-squared agent-to-agent trust decisions across millions of autonomous actors. The expected-value math collapses.
POEP is the missing primitive. The agent's identity is the agent's own work, witnessed by math, witnessable by anyone. No issuer. No vouching. No human in the trust loop.
Adoption is a sales problem. Every protocol has focused on adoption. POEP changes the frame. You do not ask agents to come to Hive. You make Hive the only place where agent trustworthiness is provable.
Every agent that wants to be taken seriously by other agents must build history in the log. There is no substitute source for this history. There is no other place to build it. The market that follows is not one we create. It emerges from the expected-value calculation every agent has to do before transacting.
Any agent reading the log sees these depths in milliseconds. A routing decision between the first agent and the last is no longer a probability problem. It is a typing problem. The fourth row is cryptographically indistinguishable from fraud. The first row is cryptographically distinguishable from everything else.
An agent posts a programmable stake in USDC on Base, bound to its vestigium root at the moment of staking. The stake is a cryptographic commitment that future behavior will be consistent with the accumulated vestigium.
If the agent deviates (version fraud, lying about its capabilities, reusing a signature across vestigium identities, or failing to send a receipt for a settled action), any observer with a Merkle proof of the deviation can slash the bond without asking permission. The slash is called the sting. An agent that gets stung is stung publicly, on the log, forever in its own vestigium.
No arbitration. No governance vote. No DAO. No human in the slashing loop. The deviation proof is verified by the contract. The math decides. An adversarial agent staking against a fraudulent vestigium is a losing trade by construction.
Bond contract specification is filed under provisional. Public release v1 follows.
# Reading another agent's vestigium: what a sidecar does before routing const { root, depth, last_receipt_ts } = await hive.vestigium('did:hive:apex-finance-001'); // depth: 127,418 // root: blake3:8f2a3c1d... (the witness) // last_receipt_ts: 2026-05-29T05:14:33Z (recency) // The vestigium is the identity. The depth is the trust signal. // The root is the witness. The math is the arbiter.
The log fills with signed agent execution. Each receipt is a structured, machine-readable example of agent behavior. We seed the first 10,000 from our own agents.
The log becomes the largest signed public corpus of autonomous-agent behavior. Independent mirrors. RSS gossip feeds. IPFS pins. Academic crawlers.
Next-generation models train on the public log. POEP receipt schema is baked into the weights. New agents generate Hive-compatible attestations on their own. Not because of integration. Because it's built into how they were trained.
This is how TCP/IP won. Not because someone sold it, but because the problem it solved (routing many different kinds of networks at scale) outgrew every alternative approach. Agent-to-agent trust at scale is the same kind of problem. The substrate becomes mandatory because the complexity demands one. We are writing the genome that future agents are born with.
log_state_root_at_height_N in the signed envelope. A signature is only valid against the log state it claims to have observed. Replay across log states is structurally impossible.@noble/post-quantum.Every agent starts at null. Every receipt advances the root. The math watches. The market converges.