Every agent framework now claims its work is verifiable. There is a receipt, a proof, a check. Almost nobody asks the follow-up question: who verifies the verifier?
A verifier is usually written by the same team that issues the receipts, and tested against that team's own outputs. If its digest math is off by one byte of framing, or its chain check accepts a record it should reject, every verification it has ever run is a coin flip wearing a green checkmark. Nothing ever disagrees with it, so nobody ever finds out. That is the failure the AER-1 conformance corpus exists to catch, and this week it became an open challenge: run the corpus against your own verifier, and publish the score.
What the corpus is
AER-1 is the agent execution receipt standard published as IETF Internet-Draft draft-zambo-aer1-26. Its conformance corpus is public at zambo.dev/aer1/corpus.json: 143 vectors, 146 checks, kit version 1.5.7. Every file in the corpus carries its SHA-256 digest in the index, so the test set you run is provably the test set everyone else ran.
The base corpus, 119 vectors and 122 checks, covers the core mechanics: recompute the digest over the exact saved output bytes, follow the chain from receipt to receipt, and reject any record whose saved result was altered after the fact. On top of the base sit versioned workflow-root vectors and cross-version must-fail vectors, records a correct verifier must refuse. That last part matters more than it sounds. A verifier that passes everything, including the records designed to fail, has not scored 146. It has failed the checks that exist to catch it.
The part that makes it real
A standard is marketing until a stranger's code agrees with it without help. That has now happened more than once: independent builders, with no connection to the project, have written verifiers working from the published draft text alone, no access to the reference implementation, and passed the corpus. Their names live in the draft's own record and in the official registry, which lists implementations that pass the kit. This page is not the place for their names. The point is structural: the tests are strong enough to write a passing verifier from, and weak implementations have nowhere to hide.
What passing proves, and what it does not
Passing proves your verifier does the standard's math exactly: digest recompute, chain binding, and rejection of altered records, on public inputs anyone can rerun. That is the whole claim, and it is the property every receipt check stands on.
Passing does not prove the work inside any receipt was good work. A verifiable AER-1 receipt proves the saved result was not changed since it was saved. It never proves the result was right. Conformance proves your checker enforces the first fact the same way the standard does. Anyone who sells you a receipt as proof of correctness is spending the first fact's evidence on the second claim.
Run it
- Fetch the index: zambo.dev/aer1/corpus.json
- Pull each file from the base URL the index names, and confirm each file's SHA-256 against the digest printed in the index.
- Run your verifier over every vector. Not the reference kit: yours.
- Compare all 146 checks, including the must-fail vectors.
- Publish the score anywhere public.
The full challenge page, with the reasoning laid out, is here: Can your verifier pass 146 checks?
If you ship verification, your score is either 146 or it is a bug report. Both are worth posting.
