DEV Community

Cover image for AI agent receipt standard: AER-1 and the proof it passed today
rambo
rambo

Posted on

AI agent receipt standard: AER-1 and the proof it passed today

AI agent receipt standard: AER-1 and the proof it passed today

The AI agent receipt standard is AER-1. AER-1 is the agent execution receipt standard: an open Internet-Draft, draft-zambo-aer1-26 on the IETF datatracker, that defines the record one AI agent tool call leaves behind. In an AER-1 receipt, the saved result of the call is committed under SHA-256 computed over the canonical receipt bytes, so any third party can recompute the digest and check that the saved result was not changed after the call. The check proves the record is intact. It never proves the result was right, and the standard says so.

Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.

A definition alone is not evidence, so here is tonight's evidence, stated up front: on November 17, 2026, the shared lost-response contract ran against Zambo production again (run tag d99166563b) and the standard's reference implementation scored A1 PASS, A2 PASS, A3 PASS, and A4 PASS, one day after the same contract scored A1 FAIL on the pre-fix build with an external effect count of 2. The receipts, digests, and counts for both days are public, and the last section of this article shows you how to recompute one of them yourself.

Yesterday: the standard's own implementation failed the contract

The contract lives in a public repo, github.com/zambodotdev/lost-response-test-contract, and it tests the ugliest moment in agent work: a tool call commits, the response is lost on the way back, and the agent retries. A correct system executes the underlying effect once and answers the retry from the record. A broken one executes twice and calls it success.

On November 16, Zambo production was the broken one. In run 2026-11-16-zambo-1, attempt 1 committed and its response was dropped. The identical retry executed as a fresh call. The external effect count for one logical operation ended at 2, not 1, with two distinct public receipts for the single operation: b49c66f5-5386-4bda-8bd6-2726bdfee7d1 from attempt 1 and 2b8cefc9-72c0-415c-9525-71f6000679f9 from the retry. Assertion A1 scored FAIL. Recovery failed with it: asking for the committed outcome while holding only the operation key returned 404, receipt_not_found, so a fresh session holding nothing but the key could not learn what the first call had already done, and A3 scored FAIL on its key-only leg.

That failure is still in the repo, unedited, next to tonight's pass. A standard whose reference implementation hides its own failing run is marketing. This one keeps the FAIL on the record and fixes the code.

Tonight: the same contract, run end to end, A1 to A4 PASS

The production fix binds journal_log calls that carry an operation marker: the caller-supplied key K is carried as the journal_log job_id and as inputs.operation, scoped by the session id. Tonight the shared contract harness ran unmodified against https://zambo.dev/mcp, tool journal_log, from 2026-11-17T20:57:17Z to 20:58:24Z, run tag d99166563b, run directory runs/2026-11-17-mws-retry-2-zambo-1, committed and pushed as 8509f50. This was the reciprocal MWS-RETRY-2 run: the test method run against Zambo in the open, scored in the contract's own vocabulary.

Assertion November 16 (pre-fix) November 17 (tonight)
A1: identical retry after a lost response FAIL, effect count 2, two receipts PASS, effect count exactly 1
A2: same key, one parameter changed Unproven, stopped at the metering layer PASS, refused as idempotency_conflict, count stayed 1
A3: recovery holding only the operation key FAIL, 404 receipt_not_found PASS, recovered digest equals committed digest
A4: every retry resolves to a committed record or an explicit refusal PASS PASS

The A1 leg, read closely: attempt 1 committed under key lr-op-d99166563b-a1 and its response was discarded client-side. The identical retry did not execute again. It answered as a replay of the original record, idempotent_replay: true, naming receipt 2e9ebf1f-5743-48de-a34b-5b3584c4c102 and committed digest sha256:b57197d5333af492c73260784de351c587545b6837ddab98500386714d931b87, and the external effect count stayed exactly 1.

The A2 leg: the retry reused the same key with one parameter changed (action). It was refused with tool_error:idempotency_conflict and the message "This operation key is already bound to different parameters. No journal entry was added." No new effect occurred, and the count stayed 1. Reusing an identity for a different operation is a conflict, not a shortcut, and tonight the system treated it as one.

The A3 leg: recovery holding only K returned the original committed outcome over HTTP 200, and the recovered digest equals the committed digest above. The run-id leg passed separately: holding only the receipt id resolved the unaltered record and recomputation matched.

One assertion is deliberately not in the PASS list. A5, the 24-hour delayed leg, is planted and not claimed: the A1 operation was committed at 2026-11-17T20:58:24Z and its delayed leg is due 2026-11-18T20:58:24Z. It has not run yet, so this article does not score it. When it runs, its verdict lands in the same public RESULTS.md, pass or fail.

The standard is checkable by anyone, and other codebases already run it

AER-1 conformance does not rest on the reference implementation's word. The public corpus at https://zambo.dev/aer1/corpus.json carries 143 vectors and 146 checks that any implementer can run offline. The public registry at https://rambozambodotdev.gitlab.io/registry.html lists 12 implementations. Exactly one independent implementer is documented passing the full corpus: Laurent Lemonnier, at 143/143. That number stays singular in this article because the record supports exactly one, and a standard that inflates its conformance count has told you how much to trust the rest of its claims.

Independent runs sit in the open next to tonight's:

  • The contract repo's RESULTS.md records three builds of a small teaching server, tiny-tracker, run through the same harness on November 17. The correct build passed A1, A2, and A4. Its A3 leg is recorded unproven for an instructive reason: tiny-tracker issues no receipts and carries no committed result digest, so digest equality cannot be shown at all. The two builds with one deliberate defect each failed exactly where the defect pointed: the build that drops the idempotency key failed A1 with an effect count of 2, and the build that ignores argument changes failed A2. The harness grades the absence of a digest as unproven, not as a pass, which is the behavior you want from a test of a receipt standard.
  • CoreGuard, a separate codebase, vendored AER-1 corpus vectors into its own test fixtures, with a PROVENANCE.md crediting Brennan Zambo (Zambo) and pinning the vendored bytes by their sha256 (beginning 78cb42cb, as recorded in the clone). The exchange then ran the other way: 49 vectors from CoreGuard's anchor-set work were extracted into a companion directory, contributed/coreguard-tas1/, in the AER-1 repo, outside corpus.json, and the runner verifies 49/49 from the landed directory and 49/49 again from a fresh clone of the pushed state. Vectors travel between codebases, get run by strangers, and keep their provenance attached. That is what adoption of a standard looks like before it looks like a logo page.

How to check a receipt yourself

You do not need an account, a pass, or this article's permission. Take tonight's A1 receipt and recompute it:

  1. Fetch the public verify record for receipt 2e9ebf1f-5743-48de-a34b-5b3584c4c102 at https://zambo.dev/api/v2/receipt/2e9ebf1f-5743-48de-a34b-5b3584c4c102/verify
  2. Inside it, find the receipt's canonical_bytes field (base64) and its output_hash field.
  3. Base64-decode canonical_bytes. For this receipt you get exactly 1,269 bytes.
  4. Compute SHA-256 over those 1,269 bytes and compare with output_hash.

In Python, the whole check is:

import json, base64, hashlib, urllib.request

url = "https://zambo.dev/api/v2/receipt/2e9ebf1f-5743-48de-a34b-5b3584c4c102/verify"
body = json.load(urllib.request.urlopen(url))
receipt = body["receipt"]
raw = base64.b64decode(receipt["canonical_bytes"])
print(len(raw))                                        # 1269
print(hashlib.sha256(raw).hexdigest())                 # b57197d5333af492c73260784de351c587545b6837ddab98500386714d931b87
print(receipt["output_hash"])                          # sha256:b57197d5333af492c73260784de351c587545b6837ddab98500386714d931b87
Enter fullscreen mode Exit fullscreen mode

The two digests are equal. I ran this exact recomputation against the recorded run output before writing this article, and it matched. If a single byte of the saved result had been changed after the call, the recomputed digest would differ and the receipt would fail its own check, in your terminal, without Zambo's servers casting a vote. And the limit from the first paragraph still applies: a matching digest proves the saved result was not changed. Whether the journal entry it records was a good entry is a separate question, and no digest answers it.

What adopting the standard costs a caller

AER-1 runs today on Zambo, one MCP endpoint at https://zambo.dev/mcp carrying 153 tools, 37 on the default surface, where every call returns a verifiable AER-1 receipt in the shape you just recomputed.

The free tier is enough to run the contract checks above yourself: Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. Past the free tier, a Day Pass is $0.99 for unlimited calls for 24 hours, the Zambo Pass is $29 per 30 days ($19 per 30 days for $ZAMBO holders), and the Lifetime Pass is $250. There is no annual tier.

As of this evening (2026-11-17T21:22Z), the public stream stands at 145,549 receipts, 1,947 of them today, across 124,586 calls. Receipt 2e9ebf1f-5743-48de-a34b-5b3584c4c102 is one of them. Yesterday its predecessor run failed in public, tonight it passed in public, and the delayed leg reports tomorrow in the same repo either way. That is the whole claim for AER-1 as the AI agent receipt standard: not that it is declared, but that its failures and its fixes are both on the record, and anyone can recompute the difference.

Top comments (0)