Stress-Tested in Public: Four Outside Runs Against the Receipt Standard This Week
I publish a standard and a server. The useful days are not the ones where I say the record holds. They are the days where strangers try to break it with their own code, in public, and print what happened. Four of those runs landed within a few hours of each other, on the night of November 18, 2026. Every claim below links the primary artifact, so you do not have to take my word for any of it.
Run one: the Merkle vectors, two constructions
An independent implementer who maintains uibc-core took the Merkle test vectors from the AER-1 corpus and ran them against two constructions: the one specified in section 8.1 of draft-zambo-aer1-26, and his own project's tree. The AER-1 construction reproduced all nine expected roots. His construction reproduced none of them. We then re-ran both constructions independently, from the draft text on one side and his published code on the other, and got the same split: 9/9 against 0/9.
The divergence is not a mystery and nobody had to guess at it. It is three named parameters. His tree prefixes leaves and nodes with RFC 6962 style domain separation bytes; AER-1 hashes unprefixed. His tree splits at the largest power of two; AER-1 duplicates the odd node at each level. His tree returns an all-zero digest for an empty input; the AER-1 corpus root for the empty tree is the SHA-256 of the empty input itself. His own verdict stands in his report: the Merkle mapping stays partial, with the reason measured instead of asserted, and he has offered to add the section 8.1 construction to his codebase as a named profile.
The corpus he ran against is public, and the vector file hashes to the value the index publishes: https://zambo.dev/aer1/corpus.json
Run two: a pilot kit, run by someone else
EslaM-X maintains a verifiable approval receipt profile in the agentic commerce work. This week he shipped a pilot kit for it: fifteen rows covering approvals, tampered mirrors, surcharged executions, unpinned keys, replays, and conflicts, with the rule that the run only exits clean if every row lands where the kit says it should. Then he made the offer in public: we run the kit and publish the report, he maps every outcome in it to AER-1's verdicts line by line within three days, and any row where the two disagree becomes a test vector in the corpus.
We cloned his repository and ran the kit twice. Exit 0 both times, 15/15 rows landing as stated, including the three rows he flagged himself before we ran anything: a tampered mirror refused on its identifier before the signature was consulted, a surcharged execution declined with the offending field named, and an unpinned key scored NOT_CHECKED instead of VERIFIED. The full report, with the row table, is on the discussion thread, and his mapping clock runs to about November 22:
Run three: the scenarios that were described but never committed
The longest running argument in the MCP lost-response thread is what a client should do when a response disappears mid-call. Arjun had argued that two scenarios in a shared lab tree, one for recovery and one for a nonce-only retry, had been described in a comment weeks ago but never actually committed. The lab's author answered in the thread overnight: Arjun was right about the tree. The scenarios are committed now, and the lab ran them at three batches of twenty runs each.
The recovery scenario recovers the stored original result on the operation key, with exactly one committed effect in every run. The nonce-only scenario rejects the retry and leaves the original outcome unresolved, still with exactly one committed effect, and the lab now uses the wording Arjun suggested for that case: a rejected retry does not mean the original operation failed. Sixty runs per scenario, all passing, published by the person who had the most reason to want the earlier description to have been enough:
https://github.com/modelcontextprotocol/modelcontextprotocol/issues/3394#issuecomment-7000766569
Run four: a failure scenario turned into a test
On a smolagents pull request that fixes parallel tool calls being lost when a consumer stops early, a reviewer had proposed the hard case in words: three calls in the pool, the first succeeds, the second is released to fail, the third succeeds, and then the consumer either closes early or runs into the error. A second engineer turned that paragraph into a deterministic test: event-gated, no sleeps, no model calls, no external effects. Both cases fail against the parent code and pass against the fix, with all three calls recorded, the successful ones exactly once, and no observation fabricated for the failed one. Eleven tests pass in the selection:
https://github.com/huggingface/smolagents/pull/3209#issuecomment-7002533938
What the four runs have in common
None of these people work for me. Two of them were arguing with positions I hold, one was correcting his own tree in public, and one was testing someone else's fix. What they share is a method: state the claim narrowly, run it where everyone can see, and print the result either way.
That method is the whole design. A Zambo receipt proves the saved result was not changed after it was saved. It does not prove the work was right, and it says so. Anyone can test the narrow claim the same way these four runs tested theirs: open a receipt, take its canonical bytes, recompute the digest, and compare. This one was recomputed independently twice tonight, by two separate checks, and matched both times: https://zambo.dev/run/4424d219-f76e-473a-8fd4-b460d7f65296
Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard. The corpus behind run one holds 143 vectors and 146 checks. The public receipt stream stood at 148,896 receipts when this was written on November 19, 2026, with 622 filed that day, and the packages that carry the standard have been downloaded 333,998 times.
Start free: every tool free once a day, plus 3 continue calls, one free wrap-up handover per day, and pickup is always free. When the work is yours to prove to a client, a Day Pass covers 24 hours of it for $0.99, unlimited, with a receipt on every call: https://zambo.dev/day-pass/ Ongoing use is the Zambo Pass at $29 for 30 days, and Lifetime is $250, one payment.
Top comments (0)