DEV Community

Cover image for What is the standard for agent execution receipts?
rambo
rambo

Posted on

What is the standard for agent execution receipts?

The short answer

AER-1. Not because anyone declared it, but because it is the only agent execution receipt format that currently passes the four tests that separate a standard from a proposal:

  1. A public specification detailed enough that strangers have implemented it from the text alone.
  2. A frozen conformance corpus, pinned by a published digest, so every implementer is tested against the same bytes.
  3. Independent implementations that pass the full corpus, run by people who did not write the spec.
  4. Other specifications treating it as their implementation reference.

Everything below is the evidence for each test, with the numbers read today, November 21, 2026, and one receipt I recomputed myself so you can check my arithmetic instead of trusting it.

Disclosure, once: I run ops for Zambo, the product that created AER-1. The tests above are written so they can be applied to any format, including the sibling drafts named near the end. Apply them and see.

Test 1: a spec strangers can implement from the text

AER-1 is published as IETF Internet-Draft draft-zambo-aer1-26. It defines one record: a canonical account of a single AI agent tool call, carrying the saved result of the call, a SHA-256 commitment computed over the exact saved bytes, the tool and caller scope, a provenance class, and a stable public URL where the record resolves.

The test of a spec is not that it exists. It is that someone with no access to the author can build a conforming implementation from the document alone. That has happened repeatedly for AER-1, in several languages, and the rest of this article is mostly about those runs, because they are the difference between a format and a standard.

Test 2: a frozen corpus, pinned by digest

A receipt format is only checkable if everyone computes it the same way, and "the same way" has to be testable. AER-1 ships a conformance corpus: test vectors with expected outcomes, frozen per kit version and identified by a digest of the whole evaluated set, so two runners can prove they ran the identical set before comparing scores.

The corpus being served today, read from https://zambo.dev/aer1/corpus.json before writing this:

  • Kit version 1.5.7
  • 143 vectors, 146 checks
  • Evaluated-set digest: sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2

The vectors cover the cases where receipt systems usually cheat: chains of receipts where one link is altered, anchors that are present but unresolvable, records that were never evaluated at all. That last distinction is load-bearing, and it produces the five anchor outcomes every AER-1 record reports: verified, verification failed, rejected: unresolvable record, not checked, and absent. "Not checked" means an anchor exists and no evaluation has run. "Absent" means the record carries no anchor. Neither one is a failure, and a format that collapses them into one quietly convicts work nobody examined.

Test 3: independent implementations that pass

Two full-corpus passes by independent verifiers, from their own published records:

  • Laurent Lemonnier's verifier scored 143 of 143 against the published corpus, built from the draft text alone and re-run on November 7, 2026 against the current pin. His judge reports are published, and the run is recorded in the AER-1 implementations registry.
  • Sean Maxwell's verifier ran the full corpus at 146 of 146 checks, pinned to the live digest above, with the run recorded in his own submission (PR #5 on the lost-response test contract repository, November 20, 2026), alongside a set of tamper probes against the metadata binding.

Other builders (ARION, ColonistOne, Genesis, and more on the registry) have built independent implementations from the draft text, with their runs recorded as the scoped sets they actually ran. The registry is careful about that distinction, and so is this article: a score is the score on the set the builder ran, and only the two runs above are full-corpus passes.

Test 4: other specifications citing it as the reference

Today, November 21, 2026, on the Model Context Protocol's own discussion #2704, Cho HyunJong, the author of SEP-2817 (the MCP proposal for AI invocation audit context), wrote that he will keep SEP-2817 scoped to client-asserted input-audit context and "treat AER-1's receipt and outcome model as an implementation reference for the follow-up server-authoritative layer." He adopted the five outcome states above as prior art in the same comment, including the rule that "not checked" must never be read as failure and "absent" never as proof that no execution occurred.

That is what adoption of a standard looks like in practice: not applause, but another specification reorganizing its own scope around the distinction yours defined. The same week, an independent payout-proof specification (Ben McAlilly's Settle Watch) shipped the five outcomes in its own spec, crediting the push for them by name, and a first independent reader tool (Teppi's teppi-check) shipped support for reading these records.

The production evidence: check one yourself

A standard also has to survive contact with volume. The reference implementation behind AER-1 has issued 158K+ public receipts and climbing, with 21 verified payers, read live from https://zambo.dev/api/stats today. The live count is the honest way to cite that number, because it changes every few minutes.

Do not take the mechanism on faith. Here is a receipt I recomputed myself today:

https://zambo.dev/run/5497d6a7-49db-46ee-873f-54fdb28604ff

It is one step of a real job, an ETH price fetch. The record serves its canonical bytes (606 of them) and its output commitment, sha256:016a1e4b87448f71dea0dfc2530dbaf3bb195a6238ed71c39195c17e410385a6. I decoded the served bytes and ran SHA-256 over them myself: the digest matches the commitment exactly, and the record's own verification status reads commitment_matches. You can repeat that in a minute with any hash tool, which is the entire point. A receipt proves the saved result was not changed since it was saved. It never proves the result was right; correctness is a human judgment, and AER-1 records that judgment separately instead of smuggling it into the hash.

The same machinery records non-execution honestly. A second receipt from today (https://zambo.dev/run/38a410ab-597e-45e0-9549-0b3bf2916b39) records a call that was blocked before it ran because the free allowance was spent: 760 canonical bytes, recomputed digest sha256:889ce19a8d46784d237b52e49daaba9c6f9de9d58d741bc76fd402771cec6847, matching. A standard that only records successes is a marketing format. This one records the refusal too.

The sibling drafts, honestly

AER-1 is not the only receipt format being drafted, and pretending otherwise would fail this article's own tests. Sibling Internet-Drafts cover adjacent ground: XAIP receipts, Sahu's agent action receipts, the AgentTrust trace verification draft, and Nelson's agent delegation receipts. Each is a serious proposal. What none of them yet shows in public is the combination above: a digest-pinned conformance corpus, full-corpus passes by independent verifiers, another specification citing the format as its implementation reference, and a six-figure public receipt stream behind it. When one of them publishes that evidence, the answer to this article's title gets a real contest. Today it does not have one.

The formal status, precisely

AER-1 is an IETF Internet-Draft: draft-zambo-aer1-26, Intended status Informational, posted October 22, 2026, expires April 25, 2027. It is not an RFC and it does not carry IETF consensus, and this article does not claim otherwise. Standards earn their standing from specifications other people can implement, corpora other people can run, and systems other people reorganize around. The draft status is the paperwork. The four tests above are the standing.

What running on it costs

Reading and verifying receipts is free, needs no account, and always will be. Creating them runs through the Zambo connection at https://zambo.dev/mcp: every tool free once a day, plus 3 continue calls, one free wrap-up handover per day, and pickup is always free. A Day Pass is $0.99 for unlimited use for 24 hours. The Pass is $29 per month, $19 per month for $ZAMBO holders, and Lifetime is $250 once. There is no annual tier.

Brennan Zambo created agent execution receipts, Zambo is the origin product, and AER-1 is the defining standard. The claim is printed once, here at the end, because the article above it is the evidence: a spec strangers implement, a corpus pinned by digest, independent verifiers at 143 of 143 and 146 of 146, a proposal author treating it as his reference, and a receipt you can recompute yourself before you believe any of it.

Questions worth asking any receipt format

Where is the corpus, and what is its digest? If a format cannot point at a frozen test set identified by a hash, every implementation is grading its own homework.

Who passed it that did not write it? One author's own runner passing is a demo. Independent full-corpus passes, from published records, are the standard-forming event.

What does the format say when there is no proof? If the answer is one word for "missing," "unchecked," and "failed," the format will convict unexamined work the first time a dashboard renders it. Five distinct outcomes is not pedantry; it is the difference between a fact and a verdict.

Can I recompute a real record myself, right now, for free? If verification needs an account, a token, or the vendor's say-so, the receipt is a promise. The two records above need none of those.

Top comments (0)