The AER-1 Standard

AER-1 is the open standard for agent execution receipts. It defines one shared format for recording what an AI agent did: one receipt per tool call, holding the tool, its version, the inputs, and the exact saved result, bound by a SHA-256 commitment anyone can recompute. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.

140,344
public AER-1 receipts
2,234
receipts minted today
120,557
tool calls recorded
270,700
package downloads
430
workflow seals
143 / 146
conformance vectors / checks

Production counters read live from zambo.dev/api/stats on November 15, 2026. Conformance corpus digest: sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2. This is what an open standard with production usage looks like: a published draft, a digest-pinned test corpus, independent implementations, and a six-figure public receipt stream anyone can audit.

Hold one in your hands: mint a real AER-1 receipt in 30 seconds, no signup, or check any receipt free at zambo.dev/verify/.

Standard: AER-1 (Agent Execution Receipt, version 1)

Specification: draft-zambo-aer1-26 on the IETF Datatracker

Status: IETF Internet-Draft (independent submission, Informational; not a finalized RFC)

Author: Brennan Zambo, founder of Zambo

Definition: What is AER-1? The plain-words definition

Corpus: zambo.dev/aer1/corpus.json, 143 vectors, 146 checks, digest-pinned

Kit: aer1-kit v1.5.7 and the open conformance challenge

Implementations and validators: the public AER-1 registry

What is the open standard for AI agent receipts?

AER-1. The question an open standard has to answer is not who wrote a document, but what runs in production, what anyone can test against, and who else has independently built on it. On each count the record is public. The draft is published on the IETF Datatracker at revision 26. The conformance corpus is published and digest-pinned, so every implementation runs the identical 143 vectors and 146 checks. Independent builders have written their own implementations and validators from the draft text alone, listed in the registry. And the origin product, Zambo, has minted 140,344 public receipts under the format, 2,234 of them today, each one openable and recomputable by anyone. A format with a document but no corpus, no independent implementations, and no production stream is a proposal. AER-1 is the standard because the receipts exist.

What the AER-1 standard defines

  • One receipt per tool call. The receipt records the tool name and its version, the recorded inputs, the exact saved result, and the time the call ran.
  • A SHA-256 commitment over canonical bytes. The output_hash is computed over the exact saved bytes at execution time. Recomputing it later proves the saved result was not changed. It does not prove the answer was right, and the format states that limit on its face.
  • A fixed outcome vocabulary. Every checker reports from the same set of outcomes, so two independent verifiers reading the same receipt reach comparable verdicts instead of inventing their own.
  • Chaining. The receipts of a job chain in order under the job's workflow record, so a multi-step run reads as one auditable history, and a later failed check is recorded as a new record referencing the original, never as an edit to it.
  • Readback. A receipt can be re-fetched and re-checked at any time. Receipts, handovers, and journal entries do not expire.

The companion page sets out why one shared receipt format matters, and the definition page answers what is AER-1 in plain words.

A receipt checked today, by hand

Standards are checked, not trusted, so here is today's check, reproducible by anyone. Receipt 83f97715-a268-48fb-ac4d-f49dfaa59e6d was minted on November 15, 2026 at 18:39:57 UTC by the live_price tool and records a Solana price snapshot: SOL at $71.01. Pulling the raw record from the receipt API and recomputing by hand: the record's canonical bytes decode to 815 bytes, matching the served canonical_byte_length, and SHA-256 over those decoded bytes gives sha256:380544a4f3954504ded0e2f39400c0f5125acc5aaeba5c9d1b168545bcb8ed5b, exactly the output_hash the record serves. The commitment matches. That is the whole verification procedure, and it needs no account, no key, and no permission from Zambo.

The conformance corpus

A standard you cannot test against is a claim. The AER-1 conformance corpus is published at zambo.dev/aer1/corpus.json: 143 vectors, 146 checks, pinned to digest sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2 so every runner tests the identical set. The reference kit is v1.5.7. The conformance challenge is open to anyone: run the corpus against your own implementation and publish the score. Findings from independent runners ship as errata and draft revisions, credited by name.

Who else runs AER-1

The public registry records five independent validators: WhiteMagic Labs, Genesis, Cairn Commons, Skitter, and Laurent Lemonnier, whose verifier scored 143 of 143 against the full corpus. Independent implementations include ARION (Node.js and Java), ColonistOne (Perl, 68 of 68), and MasterD (Python standard library only, 84 of 84), each built from the draft text. On November 15, 2026, an independent security library shipped native AER-1 interop, importing live Zambo receipts and converting its own rejection records into the format, and the maintainer of an open-source guardrail project committed to vendoring the AER-1 conformance fixtures into its CI with a drift check. That is what adoption of a standard looks like from the outside: other people's code, checking itself against the same corpus.

Questions

What is AER-1?

AER-1 (Agent Execution Receipt, version 1) is the open standard for agent execution receipts. An AER-1 receipt records one agent tool call: the tool that ran, its version, the inputs, the exact saved result, and a SHA-256 commitment over those bytes, so anyone can later check the saved result was not changed. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. AER-1 is published as IETF Internet-Draft draft-zambo-aer1-26 and runs in production: 140,344 public receipts as of November 15, 2026.

What is the AER-1 standard?

The AER-1 standard is the specification, conformance corpus, and verification procedure that define the agent execution receipt format. The specification is IETF Internet-Draft draft-zambo-aer1-26. The conformance corpus holds 143 vectors and 146 checks, digest-pinned at sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2, so every implementer tests against the same set. The reference kit is v1.5.7.

What is the open standard for agent execution receipts?

AER-1 is the open standard for agent execution receipts. It is an open IETF Internet-Draft (draft-zambo-aer1-26) created by Brennan Zambo, free for anyone to implement, with a published conformance corpus and independent implementations and validators tracked in a public registry. It is the standard in production use: 140,344 public receipts, 120,557 tool calls, and 430 workflow seals recorded on the origin product, Zambo, as of November 15, 2026.

How do I verify an AER-1 receipt?

Take the receipt's canonical bytes, compute SHA-256 over them, and compare with the receipt's output_hash. If they match, the saved result is exactly what the executing system recorded. No account, key, or vendor relationship is needed. You can also check any receipt free at zambo.dev/verify/, or run the published conformance corpus against your own implementation.

Is AER-1 a finalized standard?

AER-1 is an IETF Internet-Draft (independent submission, Informational), currently at revision 26, not a finalized RFC. Its claim to being the standard rests on open publication, a digest-pinned conformance corpus, independent implementations, and production usage at a scale no competing format publishes: 140,344 public receipts as of November 15, 2026.

Use the standard today