This morning, in an agent framework's discussion board, the failure case on the table was an agent narrating work it never did: "I saved your backup and deleted the old staging DB." Fluent, confident, and unverifiable, because the only evidence offered was the agent's own sentence.

So we ran that exact claim through Zambo today, next to a real call, and kept both receipts.

Call one ran. A live BTC price fetch at 12:30 UTC today: $65,430.68, snapshot via Coinbase. Receipt: https://zambo.dev/run/8869c25f-a500-4502-ac54-6b208f052a33, status success, and an output hash anyone can recompute over the saved result. It either matches or it doesn't.

Call two never ran. One second later, the agent tried to store the sentence "the old staging database was deleted" as a memory. The call was missing a required argument, so it was refused before execution. That refusal is a public receipt too: https://zambo.dev/run/9e5d5513-bcd0-4f0f-b6cd-8bebf9cd7f77, status rejected_before_execution, the refused arguments printed on the record, the reason attached.

Nothing was deleted. Nothing was saved. And that is not my summary of what happened: it is what the second receipt shows, in the open, for anyone who wants to check it.

The pattern

The staging DB sentence at the top was written in that same confident voice, but neither the 12:30:09 UTC success receipt nor the 12:30:10 UTC refusal receipt backs a deletion. A receipt is minted at execution time, over the exact bytes of the saved result, which is what separates the two outcomes the prose cannot:

  • Executed: a receipt with status success and a hash that recomputes.
  • Refused: a receipt that says rejected_before_execution, with the reason on it.

The refused call is the one worth staring at. Receipt 9e5d5513-bcd0-4f0f-b6cd-8bebf9cd7f77 does the opposite of burying a failure at 12:30:10 UTC today: it records the refused memory call and the arguments it tried to use. That is what makes "I deleted the old staging DB" checkable instead of plausible.

The one move

Open the two links above and compare them: 8869c25f says success, 9e5d5513 says rejected_before_execution. When the job is bigger than one call, ask for the wrap: a handover binds a whole job's receipts into one record the next person, human or AI, can pick up for free and check line by line. That is the delivery shape Zambo is built around: the handover carries the work, and every receipt in it proves its saved result was not changed after the fact.

One boundary, stated plainly: a receipt does not prove the answer was right. The BTC figure above could have come from a bad feed and its receipt would still verify, because verification settles a narrower question: did this call run, and is this the output it produced, unchanged? Correctness is still on you. "Did it happen at all" no longer has to be.

Check it without trusting us

The receipt format is AER-1, an open standard (IETF draft-zambo-aer1-26, with a public conformance corpus of 143 vectors and 146 checks), so verification never requires trusting Zambo: recompute the hash yourself, or run the open kit against the corpus. Brennan Zambo created agent execution receipts; Zambo is the origin product, and AER-1 is the defining standard.

Add Zambo to your AI at https://zambo.dev/add/. Every tool free once a day, plus 3 continue calls, one free wrap-up handover per day, and pickup is always free. Then ask your agent for a receipt for the next thing it claims it did, and see which state you get.