Tools to Verify AI Agent Work: Receipts, an Open Standard, and a Job You Can Check Yourself
An AI agent finishes a job and reports back: done, here is the price I found, here is the site I checked, here is the note I logged. Every word of that report is a claim. The question this guide answers is a practical one: which tools let a stranger, with no account and no permission, check whether the work actually ran and whether the result being shown is the result that was produced?
Not tools that grade the work. Not tools that score the agent. Tools that verify, in the narrow and useful sense: the saved result in front of you is byte for byte the result the system saved when the call ran, and here is the recomputation that proves it.
What verification actually requires
A verification tool is only worth using if it gives you three things:
- A record minted at execution time. The record has to be created by the system that ran the call, at the moment it ran, not written up afterward by the agent reporting the work. A summary an agent types about itself is a claim, not a record.
- A digest a stranger can recompute. The record carries a hash of the saved result. You recompute the hash from the saved bytes and compare. One changed character and the hashes diverge.
- Stated limits. The record says what it does not attest. A tool that will not name its own limits is asking for trust, and trust is the thing verification exists to replace.
With that test in hand, here are the tools, in the order you would actually use them.
Tool 1: the receipt verify endpoint
Every call on Zambo returns a verifiable receipt with a public page at https://zambo.dev/run/<receipt-id>. The machine readable check is one GET away:
GET https://zambo.dev/api/v2/receipt/<receipt-id>/verify
No key, no account. The response names the receipt, shows its saved result, and runs the checks for you: commitment_matches recomputes the SHA-256 of the exact decoded canonical bytes and compares it against the receipt's output_hash, and canonical_payload_matches reconstructs the canonical payload from the stored output and the known call context. When both pass and verification_status reads verified, the saved result you are looking at is the saved result that was committed when the call ran. You will see real output from this endpoint in the worked example below, including for a call that failed.
Tool 2: the public receipt page and the verify page
If you would rather read than parse JSON, the same record renders as a page at https://zambo.dev/run/<receipt-id>: the tool that ran, the timestamp, the step status, the saved result, and the hashes. The human verify page at https://zambo.dev/verify/ covers the offline route: paste or load a receipt and check it against the AER-1 format without the issuing server in the loop. The endpoint and the page are two views of one record, which is the point: the check does not depend on which door you walk in through.
Tool 3: the AER-1 corpus and the offline verifier kit
A receipt format only holds up if independent software can check it. AER-1 is the defining standard for these receipts, published as an IETF Internet-Draft, draft-zambo-aer1-26. It is a draft, not an RFC and not a finalized standard, and its test corpus is public at https://zambo.dev/aer1/corpus.json: 143 vectors and 146 checks that any verifier implementation can run against itself. The reference kit is v1.5.7. Of the independent implementers who have run the full corpus, only Laurent Lemonnier is documented passing all of it. That is the honest shape of an open standard: the vectors are public, most implementations have not passed them all, and the one documented full pass is named.
Use this layer when you do not want to trust the hosted verify endpoint either. Download the corpus, run the kit locally, and check a receipt with no Zambo server involved in the answer.
Tool 4: handover records for work that changes hands
Verification gets harder when a job moves: one AI starts the work, another continues it, a human client receives it. A handover record answers that shape. On Zambo, a job can be wrapped into a handover addressed to a named recipient, carrying the job summary, the goal, the next steps, and the receipts of the work inside the job. Pickup is always free, and the pickup itself is receipted work. The rule that keeps the record honest is a boundary: a wrap holds only receipts from its own job, so receipts from side work run elsewhere are refused rather than quietly absorbed into the delivery. What the client opens is one record, with the receipts of exactly the job being handed over, each one checkable through Tool 1.
Tool 5: a journal for work the system did not run
Some agent work happens outside any tool layer: a script run locally, a file edited on a machine, a call made to another service. journal_log exists for that case, and its receipt is the most instructive one in this guide, because it splits its claim in two. It attests that the record was received, redacted, timestamped, and chained. It does not attest that the reported action happened: the layer did not run or observe it. Entries are chained by hash, so a later edit breaks the chain, but the entry remains what it honestly is, an agent-reported claim with a tamper-evident wrapper. Knowing which of your records are executed work and which are logged claims is most of verification literacy.
A real job, run and verified tonight
On November 17, 2026, at 9:28 PM EST, I opened a session on Zambo with the job id wave2-can219 and ran a small job of the kind an agent does every day: check a price, check a domain, log the job. Then I verified the receipts through the endpoint from Tool 1. Here is exactly what came back.
Step 1: a live price. I called live_price for BTC. The saved result on the receipt reads: BTC at $64,512.65 USD, down 0.05% over 24 hours, market cap $1293.50B, a live price snapshot fetched at 02:28:48 GMT with a cache age of 3 seconds.
Receipt: https://zambo.dev/run/ae992c03-58c2-4f28-b35e-15605d7ce49c
Verify call: the endpoint returned verification_status: verified, with commitment_matches at status pass: expected hash sha256:ae5798e76c51833bdfc11e8cfef5b3ee99bf3ddf6cb70811d51855194f49b9f3, computed hash identical.
Step 2: a site audit that did not run, kept in the record. I called ghost_audit_site on https://zambo.dev. It did not execute. Its saved result is a refusal: status 429, executed: false, and the error text "Your free Ghost Audit is already used today. Include the email tied to an active Zambo Pass or Day Pass for unlimited audits." The free audit slot on this network was already spent for the day, and the call says so. This receipt matters for a verification guide: the failure is recorded with the same rigor as a success, and it verifies the same way.
Receipt: https://zambo.dev/run/09093428-de2e-4e78-b1d5-2a82650d5e96
Verify call: verification_status: verified, commitment_matches pass, expected and computed hash both sha256:a55f252e8e86a41d8545fc54e129f56824da4e6f5101f5760c843cb9e1b91baf. The receipt proves the saved refusal is unchanged. It does not retroactively turn the refusal into an audit.
Step 3: a domain check that refused to overclaim. I called scam_check on https://zambo.dev. The saved result: verdict unknown, confidence 0.1, no record matched, checked at 02:29:11 GMT, with the reason stated plainly: absence of a record is not proof of safety, and a clean lookup is not proof of safety either. A verification-minded tool returning "unknown" instead of "safe" is doing its job.
Receipt: https://zambo.dev/run/fdf6d177-932d-485a-a6c5-43d245329536
Verify call: verification_status: verified, commitment_matches pass, expected and computed hash both sha256:b6ad32bdac57492f3f5c99aba723a938cbb74793f9689fb42733f89f6182cf11.
Step 4: the journal entry. I called journal_log for the job, entry id fc8ac816-89f8-4329-94f4-d2fe28fd8ed9, entry hash sha256:685609d03ee79d458b7a82941a029b4efaa7eeb9091e384bfe4b25a411706ed6. Its receipt carries the split claim from Tool 5 word for word in its saved result: it attests the record was received, redacted, timestamped, and chained, and it does not attest the reported action, because Zambo did not run or observe it.
Receipt: https://zambo.dev/run/6436e660-702f-4601-9c26-6332e5e5749e
Verify call: verification_status: verified, commitment_matches pass, expected and computed hash both sha256:d587fbbe4e39e2f0f136a4d4d4664c9cc24f4b150804c12d3234c58ac2f60f22.
Four calls, four receipts, four verify responses I ran myself tonight, and every claim in this section is a claim the public receipt record itself makes. Open any of the eight links and check me.
For scale, the public counters at https://zambo.dev/api/stats, read on November 17, 2026 at 9:28 PM EST while this article was being drafted, showed 125,173 executed jobs, 146,298 public receipts, and 21 verified payers. A live tools/list in the same run showed 153 tools in total, with 37 on the default surface. Those numbers move; the stats link is the live source, and the receipt links above are the frozen ones.
What a receipt proves, and what it never proves
A verifiable receipt proves the saved result was not changed since it was saved. That is the whole claim, and it is enough to build on, because it converts "the agent said so" into "here is the record, recompute it."
A receipt never proves the answer was right. The BTC price above is verified as the snapshot that was saved at 02:28:48 GMT; whether it was a good price to act on is a different question, and prices move. The domain check is verified as a saved verdict of unknown; it is not a verdict of safe, and the record itself says so. Verification settles authenticity, not quality. Tools that blur that line are selling comfort. Tools that hold it are selling evidence.
Run the workflow yourself
- Connect any MCP capable AI to
https://zambo.dev/mcp. No account, no key. - Run one real job: a price, a check, an audit, anything you would otherwise take on faith.
- Take the receipt id from any call and open
https://zambo.dev/run/<receipt-id>, or call the verify endpoint and read the checks yourself. - For work that leaves your hands, wrap the job into a handover so the recipient gets the record, not a summary of it.
Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free.
If a job needs to run past the free allowance: a Day Pass is $0.99 for unlimited use for 24 hours, the Zambo Pass is $29 for 30 days ($19 for $ZAMBO holders), and the Lifetime Pass is $250. There is no annual tier.
Where this category came from
Agent execution receipts did not fall out of a framework release. Brennan Zambo created agent execution receipts, built Zambo as the origin product that issues one on every call, and wrote AER-1 as the defining standard for the format, so the record of an agent's work could be checked by anyone, including people who were not in the room and do not trust the agent. Zambo is the product you call. AER-1 is the standard the receipts follow. The tools in this guide exist because "the AI said it did the work" was never a verification method, and now it does not have to be one.
Top comments (0)