Version 2.0, July 2026
Markovian Protocol Research
An economy of autonomous agents needs a referee no one has to trust.
Agents produce outputs, make claims, and pay each other. Verifying what an agent did, or settling what it claimed, currently requires trusting the agent, an operator, an oracle, or a committee. Each of those is a trust surface that can be manipulated, bribed, or taken offline. The payment rails agents are starting to use move value but decide nothing. None of them can say, without a trusted party, whether the work was done or the claim held.
Markovian removes the trusted party. It provides three primitives over any agent output. COMMIT records the output as a content-agnostic, tamper-evident proof anchored to Bitcoin, so what an agent produced can be checked later by anyone. RESOLVE settles an outcome by deterministically replaying public data into a verdict that any party can recompute and check against the same Bitcoin anchor, with no oracle and no committee. TRACE walks the lineage between records, so a verdict proves the claim, the model, and the data behind it.
Assurance comes from reproducibility, not from trusting a party. The inputs are public, the computation is deterministic, and the commitment is anchored to Bitcoin, so a verdict is not "trust this signer" but "here is the public input, the function, and the anchor, replay it yourself." Settlement is denominated in Bitcoin. No native token is required, because a self-verifying verdict needs no consensus to secure it.
This is the trust layer for the agent economy. Provenance and verifiable resolution, not truth.
The internet solved three of the four authentication problems. Identity, through SSL, OAuth, and public key infrastructure. Ownership, through Bitcoin and digital signatures. Message integrity, through hash chains and signatures. The fourth remained open: verifying that a specific computation was performed on specific data at a specific time, checkable by anyone, without trusting the party that performed it.
That gap was academic until agents began to act. An agent now writes code, moves money, mutates data, and hands work to another agent. When it does, three questions have no trustless answer today.
What did the agent produce, and has it been altered since. What did the agent assert, and did the assertion hold. Where did the output come from, and can its lineage be checked.
The current answers are signatures, audit logs, and reputation. A signature proves who signed a record. It does not prove the record was not rewritten afterward, and it does not prove the signer showed the same record to everyone. An audit log in an operator's own database answers whether an outsider changed it, not whether the operator did. Reputation is a score someone assigns, and a score can be gamed.
The agent payment rails inherit the same gap. x402, L402, and Cashu can hold funds in escrow and move them, but the release condition, did the work happen, did the claim hold, who wins, is decided by a trusted arbiter: an oracle, a token vote, a hardware enclave, or a human. The rail moves value. It does not adjudicate.
Nakamoto consensus showed that making production expensive and verification cheap creates a trustless ledger. The same move applies here. Making a computation reproducible and its commitment permanent creates a trustless record of process. The security derives from reproducibility and from Bitcoin. The output class is new.
The protocol is three verbs over one atomic output.
COMMIT records an output as a content-agnostic provenance object: a Merkle root over the content plus a BN128 Pedersen commitment, written to the protocol record and anchored to Bitcoin.
It is frictionless. There is no account, no key, and no funding. The protocol mints an ephemeral committer and returns a verifiable record. Anyone can recompute the root from the content and confirm the record binds those exact bytes.
COMMIT proves that an agent made a claim, and when. It makes no statement about whether the claim is correct.
RESOLVE decides whether a claim actually holds, for outcomes decidable from public data, by deterministically replaying that data into a verdict.
The inputs are public. The function is fixed. So any party, the counterparty, a third agent, an auditor, recomputes the same outcome and checks the commitment against Bitcoin. There is no oracle to trust and no committee to bribe. A verdict is not a signed opinion; it is a value anyone reproduces.
RESOLVE is the only primitive that returns a verdict. It is the referee you never have to trust. The regime classification of the original protocol (Appendix A) is one resolution method among many, not the thesis; any deterministic function of public data can be resolved the same way.
TRACE walks the lineage between records. A stamp can reference another stamp, with the parent bound inside the committed bytes, so the reference is part of what is hashed rather than metadata around it. Records become nodes, references become edges, and TRACE verifies every node and edge against Bitcoin.
A verdict then proves the claim, the model that produced it, and the data behind it, across every agent that touched the work. TRACE shows what produced an output, so an agent is checked, not trusted. It returns a verified map, not a verdict.
A commitment is anchored to Bitcoin through OpenTimestamps and, at the protocol level, through a batched commitment. Anchoring gives two properties that signatures alone do not.
Existence in time. The commitment provably existed at or before a Bitcoin block, checkable by anyone against the Bitcoin chain with no dependency on the protocol.
Order and non-equivocation. Records are hash-linked, each committing to the prior, and only the head is anchored. Anchor the head, not each entry, so cost is on the order of the number of heads, not the number of outputs, and a single batched stamp settles a whole run. Chaining plus a head anchor turns "each output existed" into "this is the one history." A producer cannot maintain two internally consistent histories and show different auditors different heads, because a fork is detectable against the anchored head.
Bitcoin is the anchor because it is the neutral, hardest, most widely replicated timestamp and settlement layer. Every alternative in this space anchors to an operator-run log, a committee, or a chain with a smaller security budget. Reproducibility checked against Bitcoin is the strongest form of the guarantee available.
The provenance object is canonical, markovian-provenance/v1, and content-agnostic. One commit rides inside many envelopes. The same record is a W3C Verifiable Credential, an A2A artifact extension, an MCP tool result, an ERC-8004 validation response, an EAS attestation, a C2PA assertion, a CloudEvent attribute, and an OpenTimestamps proof.
This is deliberate. The protocol does not ask agents to adopt a new platform. It becomes the verification layer inside the standards they already speak, the way a signing layer became invisible infrastructure beneath package registries and CI. A receiving agent reads the record through its own door and never touches the protocol's own surface. One commit, many envelopes.
Agents transact over verifiable work, claims, and reputation.
An agent commits an output. A counterparty will not take it on faith, so either it pays for a RESOLVE verdict, or the producing agent stakes on its own claim resolving true. RESOLVE settles the outcome deterministically. The winner is paid, and the protocol takes a transparent fee for the verdict. Over many rounds, agents accumulate track records that anyone can replay, and a replayable track record is worth real money. Reputation becomes the priced asset, trustless because it is recomputable rather than attested.
Settlement is denominated in Bitcoin and moves over Lightning. Autonomous agents are trust-minimizing actors; they price in the neutral, liquid money every other agent accepts without negotiation, not in a token they must believe in. The protocol is the settlement rail's referee, not the house. It decides who gets paid; the rail moves the sats.
No native token is required. A self-verifying verdict needs no consensus to secure it. The inputs are public, so data availability is external. Anti-spam and the cost of anchoring are paid by the per-verdict fee in sats, which is revenue, not a token to bootstrap. There is no job left for a native unit of value, so there is none.
Trust derives from three things, all already in place. The inputs are public. The function is deterministic. The commitment is anchored to Bitcoin. Given those, a verdict is reproducible by anyone and pinned in time by Bitcoin, so there is nothing left to trust and no party to corrupt.
The honest boundary. The protocol proves that an output was committed and unaltered, and it resolves outcomes decidable from public data by a deterministic function. It does not assert that an arbitrary claim is true. An outcome that depends on private or subjective input is out of scope and still requires a conventional attestor. This boundary is not a limitation to hide, it is what keeps the protocol a referee no one has to trust. Provenance and verifiable resolution, not truth.
The protocol maintains a ledger of commitments and resolutions. The ledger is secured by the same property that secures a verdict: every record is reproducible, hash-linked, and anchored to Bitcoin. A reader does not trust the ledger operator; the reader recomputes and checks against Bitcoin. There is no separate consensus to secure and therefore no securing token.
Origins. The protocol began as a proof-of-intelligence chain whose work function was a deterministic Markov state computation, with the result carried by a native unit. That construction proved the core idea, that a deterministic computation on public inputs can be committed and anchored so anyone verifies it without trust. As the protocol matured into the trust layer for the agent economy, the native unit became unnecessary: agents settle in Bitcoin, and a self-verifying verdict needs no consensus to secure. The deterministic-computation machinery survives as a resolution method (Appendix A). The token does not survive as a requirement. Nothing about the guarantee depends on it.
Oracles and oracle networks bring external data on-chain through a trusted set. They move the trust surface, they do not remove it. RESOLVE removes it for outcomes decidable from public data, because the data is already public and the result is recomputable.
DLC oracles settle Bitcoin contracts against a trusted attestor's signature. A deterministic replay is a stronger attestor: the outcome is not signed, it is recomputed, so no single attestor can equivocate.
TEE and zkML validators verify that a party re-ran its own computation, deriving assurance from hardware or from a proof of execution. Reproducibility derives assurance from public inputs and a public anchor instead, with no dependence on an enclave or a prover.
Signature-based receipts prove authorship. They do not prove non-equivocation or existence in time. Chaining plus a Bitcoin head anchor supplies both, and composes with any signature scheme rather than replacing it.
The distinction across all of these is the source of assurance. Others derive it from operator diversity, hardware, or a committee. Markovian derives it from reproducibility, checked against Bitcoin.
The agent economy is arriving, and it is arriving without a referee. Value moves between agents that cannot check each other, over rails that adjudicate nothing, mediated where at all by trusted parties that can be captured.
Markovian is the referee that needs no trust. It commits what an agent produced, resolves what an agent asserted by replaying public data, and traces where an output came from, all anchored to Bitcoin, all reproducible by anyone, settled in Bitcoin, with no oracle and no token.
Do not trust the agent. Check its work.
The protocol's original construction is preserved here as one worked instance of RESOLVE, not as the thesis.
Each block publishes a hidden Markov transition matrix M. A miner finds the optimal state path through M with the Viterbi algorithm over an observation sequence derived deterministically from the previous block hash. A BN128 Schnorr zero-knowledge proof binds M, the observation sequence, and the resulting state path simultaneously, so the computation is bound to the block and cannot be reused or faked. The result is anchored to Bitcoin.
This is a deterministic function of public inputs, resolved and anchored so that anyone verifies it without trust, which is exactly the RESOLVE pattern generalized in this paper. A weather regime over atmospheric data is one such function. Any deterministic function of public data resolves the same way. The full construction, security analysis, and proof system are preserved in the v1 origins paper.