You are writing a verifier for an open standard, alone, from the draft text. The conformance corpus is public: 143 vectors, 146 checks, one pinned digest. How hard can it be?
Hard in three specific places, if the public record is any guide. The AER-1 conformance challenge asks implementers to post their runs in the open, failures included, and the first-run stories cluster on the same three mistakes. Each one below is documented with scores attached, and each one has a fix you can apply before your first run instead of after it.
The short background: AER-1 is the open standard for agent execution receipts, published as IETF Internet-Draft draft-zambo-aer1, currently at revision 26. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. A receipt keeps the exact saved bytes of one agent tool call together with their SHA-256 digest. Verifying it means recomputing the digest and checking the structure around it. The corpus lives at zambo.dev/aer1/corpus.json and the reference kit at github.com/zambodotdev/aer1-kit.
Mistake 1: Treating a structural failure as a soft state
The epistemic-guard bridge connects AER-1 receipts to a neighboring evidence system. Its first full-corpus run, posted publicly on the challenge, scored 27 of 146. The valuable part of that run is the failure breakdown the author published alongside it.
A receipt with no output_hash was treated as "uncommitted" rather than as a hard error. Strict calendar checks were skipped: a created_at of February 29, 1900 passed, as did a leap second and a timestamp with no timezone. Nil and uppercase UUIDs passed. And a file carrying a duplicate JSON member name survived, because a plain JSON parse collapses duplicate keys before any verifier sees them. The follow-up report measured that parsing trap precisely: fed raw, the file is rejected (36 of 36 invalid vectors rejected); pre-parsed with a standard JSON loader, the score drops to 35 of 36, because the duplicate never reaches the verifier.
None of these are exotic attacks. They are the draft's Sections 3.3 and 6 read as suggestions instead of requirements.
The fix shipped in epistemic-guard v0.4.1, hours later: structural and calendar checks fail closed, unconditionally, with the reference failure strings. A missing output_hash raises "missing required member: output_hash". February 29, 1900 raises "created_at is not a valid calendar date/time". The score moved to 64 of 146, with 58 of 58 on base/test-vectors and 6 of 6 on the id-binding vectors, and the remaining 82 set-level checks honestly reported as out of scope for a single-receipt bridge. The lesson is not "write more checks". It is that in a receipt format, structural validity is never opt-in. If your verifier has a mode where a malformed receipt is probably fine, the corpus has a vector with your name on it.
Both runs, with the full failure lists, are on the conformance challenge. The bridge itself is at github.com/AlienatedAliens/epistemic-guard.
Mistake 2: Letting the digest vouch for the label
An AER-1 receipt id is a label. It sits outside the committed payload (Sections 6 and 13): the SHA-256 commitment covers the saved bytes, and the id is how you refer to the record, not part of what the digest proves. Implementers keep getting this wrong in the same direction, by letting a passing digest stand in for identity.
It happened at the very start. Genesis built a verifier cold, from the draft text alone, following the draft's quickstart rules. His first build wrongly passed 4 invalid cases, and the first gap he filed was exactly this one: the label binding was not explicit enough. That finding became a core rule in the kit (Rule 9) and an explicit binding requirement in draft -20, and Genesis is credited by name in the draft for it.
It happened again in CoreGuard, a neighboring system that took up the corpus fixtures. Its verifier checked a receipt's chain evidence and returned VERIFIED without asking which receipt the evidence belonged to, so a genuine record relabeled with a different receipt's identity passed every check. The fix was a separate identity axis that can fail while the digest passes, proven with a mutation control: delete the new branch at runtime and the pre-fix laundering comes back; restore it and the same bytes are refused. CoreGuard then implemented the draft's Section 9 shape for resolution, where the record an id resolves to must agree on the committed digest, and exercised it against the vendored id-binding vectors: 18 of 18 targeted tests passing, CI green. The exchange is public at github.com/coreguard-global/CoreGuard/issues/56.
Write this rule on your wall: a digest pass proves the bytes. It says nothing about the label. Bind the id separately, resolve it separately, and report the two verdicts separately, because a swapped label on honest bytes is exactly the fraud this format exists to catch.
Mistake 3: Reporting checks you never ran
The third mistake is about the score itself.
ColonistOne built a Perl verifier from the draft -09 text and ran it on October 22 against the vectors as they stood then: 94 of 104 checks. Read quickly, that looks like ten bugs. Read properly, all ten failures sat on vectors added after draft -09. The implementation was fine; the corpus had moved. The current published set is the one pinned at the corpus manifest, 143 vectors and 146 checks, and the only score that means anything is a score against a set whose digest you verified before you ran: sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2.
The same discipline applies inside a run. When glitchfox recomputed the full corpus and matched all 72 file hashes and the evaluated-set digest byte for byte, the record states plainly what that is: a file-hash and digest record, not a per-check conformance pass. AER-1 has named outcomes for exactly this: a check or an anchor that was not evaluated is "not checked" or "absent", never a quiet pass.
And the bar for a full claim is documented, not vibes. Laurent Lemonnier wrote a verifier from the text of draft -26 alone, without reading the kit's runners, ran the complete published corpus at kit v1.5.7, and published a per-vector report next to the code: 143 of 143 vectors agreed. His report is at github.com/Laurent-Lemonnier/dps-scitt-decision-layer. He remains the only documented pass of the full published corpus, because he is the one who ran all of it and showed the work.
Run it yourself
Clone the kit and run the corpus before you write a line of verifier code:
git clone https://github.com/zambodotdev/aer1-kit
cd aer1-kit
python3 conformance.py
The final line should read:
CONFORMANCE OK: 143 vectors, 146 checks, sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2
Node prints the same line (node conformance.mjs). The base set alone, 135 vectors and 138 checks, runs with python3 base/conformance.py, and it is labeled as the base set wherever it appears, so a base score is never mistaken for a full-corpus score.
Then write your verifier, pin the digest, report per family, and post your score on the conformance challenge. Post the failures too. Every story above got better in public, and the draft got tighter from the findings: Genesis's three filed gaps were adopted into draft -20, and ColonistOne's findings were adopted into draft -10. That is the deal the challenge offers: your first-try mistakes, fixed in the open, credited by name.
If you want to see what the receipts look like in production before you implement, any live receipt recomputes in the open: zambo.dev/run/76e0f74f-76dc-4e42-8bdc-13d16b3bf8ac, checkable at zambo.dev/verify. Zambo is the origin product: one MCP endpoint where every tool call returns an AER-1 receipt, at zambo.dev/mcp.
Keep going: why the definition of an execution receipt matters more than the format, in the piece that started this series, and the standard end to end in AER-1: the open standard for agent execution receipts.
Top comments (0)