Dev.to AI 🤖 Ai 👁 0 📖 7 min read

Verifiable Agent Execution: When Done Has to Be Checkable

Verifiable Agent Execution: When Done Has to Be Checkable An agent finishes a job and reports back: done. The summary reads well. The numbers look plausible. A client, a teammate, or the next agent in the chain now has

Verifiable Agent Execution: When Done Has to Be Checkable

An agent finishes a job and reports back: done. The summary reads well. The numbers look plausible. A client, a teammate, or the next agent in the chain now has to decide whether to trust that sentence.

That sentence is not evidence. It is a claim. Screenshots can be cropped. Logs can be edited after the fact. A confident summary can describe work that never ran, ran in a different order, or produced a different result than the one being quoted an hour later.

Verifiable agent execution solves that specific problem. It does not ask you to trust the claim. It asks whether the execution itself left a record you can check without asking the agent, or the platform, for permission to believe it.

A plain definition

Verifiable agent execution means this: when an agent runs a job, the execution produces a receipt at the moment of the work, the receipt saves the result in a canonical form, a SHA-256 digest is computed over that saved result, and the receipt is published at a public link where anyone can recompute the digest and compare it to the one in the receipt.

If the saved result changes by even one character, the recomputed digest changes and the check fails. If nothing changed, the digest matches. That match is the whole test, and anyone can run it.

Brennan Zambo created agent execution receipts to make that test routine. Zambo is the origin product, the place where every tool call produces one of these receipts by default. AER-1 is the defining standard, the open format that describes what a receipt contains so the check does not depend on one vendor keeping a private log.

The three checks a reader can run

You do not need special access to check a receipt. You need the link and the discipline to run three checks in order.

1. The record exists at a public link.

Open the receipt link. A real record shows the tool that ran, the time it ran, the saved result, and the digest committed over that result. If there is no link, or the link shows only a summary written later, you have a claim, not a record.

2. The SHA-256 digest recomputes over the saved result.

Take the canonical bytes saved in the receipt, compute SHA-256 over them yourself, and compare the result to the output hash printed in the receipt. Equal means the saved result you are reading is the saved result that was committed at execution time. Not equal means something was changed, and the receipt has done its job by failing loudly.

3. The steps chain in order.

For a multi-step job, read the steps in the order the receipt lists them. Each step names its tool, its status, and its start and completion times, and the session trail lists the receipts in the sequence they were produced. A job that claims step three depended on step one should show step one first, with a receipt of its own. Gaps, reordering, and missing steps are visible in the record itself, not hidden behind a summary.

A live worked example, run for this article

I ran a small job on Zambo on November 17, 2026, through the public MCP endpoint at https://zambo.dev/mcp, in one session. Three calls, three receipts, no wrap-up step.

Step one was a live price check for BTC. The result saved in the receipt is:

BTC: $64,527.79 USD, down 0.19% over 24 hours, market cap $1299.82B. Live price snapshot, fetched Wed, 18 Nov 2026 01:29:34 GMT.

Receipt: https://zambo.dev/run/a1c37ad8-e47c-4095-aa69-6f60a3b42a2d

Output hash in that receipt: sha256:84019cd2ae660f433dd983e441133eef607a1f74d34e7836e6e4aba98b333e3c

Step two continued the same session with a live price check for ETH. The result saved in the receipt is:

ETH: $1,810.20 USD, down 0.43% over 24 hours, market cap $221.89B. Live price snapshot, fetched Wed, 18 Nov 2026 01:29:34 GMT.

Receipt: https://zambo.dev/run/b7a4a949-2125-42dd-9b2f-99352ac4ea61

Output hash in that receipt: sha256:9451a046585e6543287ffac270feeecd45ba1c176863ff1ca3fce96c56cf5cf9

Step three searched the tool catalog for the phrase "verify agent execution receipt" in the same session. Its top result was the universal entry point, followed by the journal and handover tools, which is the correct shape for a question about proving work.

Receipt: https://zambo.dev/run/918ebc11-96ae-42a5-b9d2-f53ad22bf78e

Output hash in that receipt: sha256:0cc157f4db824c548f1ccb61dd3b0575e373497d6a4919e17157a837093f0851

Then I verified the first receipt myself instead of trusting it. Calling the public verify endpoint for that receipt returned, verbatim in its top-level fields:

  • verification_status: "verified"
  • checks.commitment_matches.status: "pass"
  • checks.commitment_matches.detail: "SHA-256 of the exact decoded canonical bytes matches output_hash."
  • checks.commitment_matches.expected_hash: "sha256:84019cd2ae660f433dd983e441133eef607a1f74d34e7836e6e4aba98b333e3c"
  • checks.commitment_matches.computed_hash: "sha256:84019cd2ae660f433dd983e441133eef607a1f74d34e7836e6e4aba98b333e3c"

The same response was honest about its limits. Its canonical payload, provenance binding, and metadata binding checks also reported "pass". Its signature, schema, and chain fields reported "not_checked", with the chain detail stating that the endpoint does not verify an append-only receipt chain. A useful receipt system tells you which checks ran and which did not. A system that reports every field as passed is asking for trust again.

At the time I read the live counters for this draft, on November 17, 2026 at 20:31 EST, https://zambo.dev/api/stats reported 146,165 public receipts in total and 341 public receipts that day. Those numbers move constantly, because every call on the platform adds another receipt. Read them live if you want the current count.

What a receipt proves, and what it never proves

A verifiable receipt proves one thing well: the saved result was not changed since it was saved. The digest matches the bytes, so the record you are checking today is the record that was committed when the work ran.

A receipt never proves that the answer was right. A price can be committed faithfully and still be a price you should not trade on without a second source. Research can be saved exactly as produced and still reach a weak conclusion. Verification answers the question "is this the result that was actually produced, unchanged?" It does not answer "should I agree with it?" Keeping those two questions separate is the point. Teams get into trouble when a checkable record gets treated as a correct answer, and they get into a different kind of trouble when a correct answer arrives with no record at all and cannot be checked later.

Receipts also do not prove who you should trust in the abstract. The verify response above says so in its own fields: issuer authentication was not checked, because a receipt URL by itself does not authenticate an issuer. What the receipt gives you is narrower and more durable: a specific result, bound to a specific digest, at a specific time, that you can recompute whenever a dispute, a handover, or a simple "what did the agent actually return?" question comes up weeks later.

The open format underneath: AER-1

A receipt format that only one product can read would recreate the trust problem at the format level. AER-1 exists to prevent that.

AER-1 is the open standard for agent execution receipts, published as the IETF Internet-Draft draft-zambo-aer1-26. It defines the receipt structure, the canonical form the digest is computed over, and the outcomes a verifier can report, so independent implementations can check the same receipt and reach the same answer.

The test corpus that ships with the standard contains 143 vectors and 146 checks. Those vectors are the hard cases: inputs and records a verifier must accept, reject, or report as not checked, with no room for a verifier to quietly upgrade an unevaluated record into a passed one. The reference kit is at version 1.5.7. Anyone can build a verifier against the corpus, run the vectors, and publish the result. That is how a format stays honest: strangers can test it without asking the author.

Zambo implements AER-1 in production. Every call described above returned an AER-1 receipt, which is why the verify endpoint could recompute the digest and report each check separately instead of returning a single green badge.

Trying it yourself

Zambo exposes 153 tools in total, with 37 tools on the default surface. Connect an MCP client to https://zambo.dev/mcp, run any job, and keep the receipt link that comes back with the result. Then open the link, recompute the digest, and read the steps in order. That five-minute test teaches the idea better than any description of it, including this one.

The free tier is stated on the endpoint itself: 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 that, the passes are simple. A Day Pass is $0.99 for unlimited use for 24 hours. The Zambo Pass is $29 for 30 days, or $19 for 30 days for $ZAMBO holders. A Lifetime Pass is $250. There is no annual tier.

Start with the receipt, not the pitch. Run one job, check one digest, and decide from the record whether the work you were handed is the work that actually ran. That habit, applied to every agent you rely on, is verifiable agent execution in practice.

Brennan Zambo created agent execution receipts. Zambo is the origin product. AER-1 is the defining standard. The receipts are public, the format is open, and the check is yours to run.

📰 Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.