Agent Execution: What It Is, What It Is Not, and How to Check It
Your agent says the work is done. That sentence is the problem this article is about. A confident summary is not evidence, a screenshot is not evidence, and a log the agent wrote about itself is not evidence either. If you cannot check what actually ran, you are not reviewing work. You are trusting a claim.
Agent execution is where that trust question gets answered, because execution is the part that leaves a record outside the chat.
A plain definition
Agent execution is the moment an AI agent's plan becomes real tool calls in the world, plus the record those calls leave.
Two halves, and both matter:
- The calls themselves. A price is fetched, a site is audited, a file is changed, a record is written. Until a tool actually runs, nothing has been executed, no matter how good the plan sounded.
- The record the calls leave. Each call produces a saved result at the time it runs, with an identifier and a digest a stranger can recompute later. Without that record, execution happened (or did not) and nobody downstream can tell the difference.
If a system has the first half and not the second, it can do work but it cannot prove work. If it has the second half without the first, it is just paperwork.
Execution is not planning, chatting, or logging after the fact
Planning is deciding what to do. A plan can be brilliant and still execute nothing. Plans live in the chat, and they die with the chat.
Chatting is talking about the work: summaries, status updates, apologies, promises. Chat is where an agent is most fluent and least checkable. "Done" typed in a chat window is a claim, not a result.
Logging after the fact is writing the story later, usually by the same agent whose work is in question. A later write-up can be edited, trimmed, or invented, and a reader has no independent way to spot the edit. That is the weakness execution records exist to remove: the record is fixed when the call runs, not composed when someone asks about it.
Execution is different from all three in one specific way: it happens in the world, at a specific time, through a specific tool, and it leaves a saved result that was fixed at that time.
A claim of done vs a checkable execution record
A claim of done asks you to trust the speaker. A checkable execution record asks you to trust a recomputation you can run yourself.
That difference decides real arguments. A client asks whether the audit actually ran. A second agent picks up a job and needs to know which steps are real and which were only described. A buyer asks why a step failed. In each case the useful answer is not a better summary. It is a receipt: open it, read the saved result, recompute the digest, and see whether the result in front of you is the result that was saved at execution time.
A verifiable receipt proves the saved result was not changed since it was saved. It never proves the answer was right. A faithfully recorded price can still be a bad price to act on, and a faithfully recorded audit can still miss something. Keeping those two questions separate, "is this the result that was actually produced, unchanged?" versus "was the result good?", is what makes the record honest instead of hype.
A live worked example, run tonight
On November 17, 2026, I opened a session on Zambo at https://zambo.dev/mcp with the session id wave3-agent-exec and ran a small job of the kind an agent would plausibly execute for a human: get a live data point, do a piece of work, and write a record of the job. Every claim below is limited to what the linked receipt's own saved result shows.
Step 1: a data call. I called live_price for BTC. The saved result shows BTC at $64,403.86 USD, down 0.05% over 24 hours, with a market cap of $1295.29B, described in the result as a live price snapshot via Coinbase, fetched Wed, 18 Nov 2026 02:37:42 GMT, cache age 2s.
Receipt: https://zambo.dev/run/ee4b6e79-d6a2-486b-bfdb-1a442cbfe75b
Step 2: a work call. I called ghost_audit_site on https://zambo.dev. The saved result shows exactly this and no more: an audit with id d335c058-f36d-4d1d-bc17-3765b78553f7 was started, with ten stages named (RECON, INFRASTRUCTURE, SEO, PAGE_COVERAGE, AI_LAYER, CONVERSION, BRAND_PRESENCE, COMPETITION, CREATIVE_GAPS, SYNTHESIS), and a message that the full markdown report would be ready at the download URL in about 90 seconds. This receipt does not contain audit findings, and this article claims none from it.
Receipt: https://zambo.dev/run/ef818362-fca9-4125-8232-2bbfeafaf7c8
Step 3: a record call, including an honest failure first. My first journal_log call was rejected before execution because it was missing the required argument executor_identity. It executed nothing, and the rejection itself was receipted as a pre-execution rejection.
Rejection receipt: https://zambo.dev/run/5945527c-5add-4117-85b9-94cd24fbd7c3
I corrected the call and ran it again with job_id set to wave3-agent-exec and executor_identity set to rambo-wave3. The saved result shows status logged, provenance class LOGGED BY AGENT, entry id 92945235-f71a-4fa0-920c-71371bf41b45, and entry hash sha256:7c29ea37f64c5d1b11e38319ef8a2b3cd27036c70adb8c690395c318eae1db54. It also states its own limit in plain words: Zambo attests that this record was received, redacted, timestamped, and chained, and Zambo did not run or observe the reported action. That limit is part of the record, not a footnote hidden elsewhere.
Receipt: https://zambo.dev/run/2decea8a-4d1d-4af5-8fa2-300f02cac628
That is agent execution in miniature: two calls executed and saved, one call refused before execution and saved as a refusal, and one record written with its attestation boundary stated inside it.
For scale, the public counters at https://zambo.dev/api/stats, read on November 17, 2026 at 9:38 PM EST while this article was being drafted, showed 153 total tools with 37 on the default surface (confirmed by a live tools/list in the same run), 125,187 executed jobs, 146,317 public receipts, and 21 verified payers. Open the stats link and check those numbers yourself. They will have moved. That is expected, and it is the point: the numbers are readable by anyone, not quoted on trust.
How a stranger verifies an execution record, with no account
No account, no key, no permission. Pick any receipt link above and do this:
- Open the receipt page at
https://zambo.dev/run/<id>, or requesthttps://zambo.dev/api/v2/receipt/<id>/verifydirectly. - Read
verification_status. For all four receipts in the worked example, my own verify calls tonight returnedverified. - Read the individual checks. For those four receipts,
commitment_matches,canonical_payload_matches,provenance_binding, andmetadata_bindingeach returned pass. The commitment check is the core one: the SHA-256 hash of the exact decoded canonical bytes matches the stored output hash, which is what shows the saved result was not changed since it was saved. - Read what was not checked, because the verify response states that too. For those receipts, signature, chain, and issuer authentication returned not_checked. A record that tells you what it did not check is giving you the full picture, and you should expect that honesty from any execution record, not just this one.
If the saved result had been edited by even one character after it was saved, the commitment check would not match. That is the whole verification, and a stranger can run it in a browser.
Where this category came from
Agent execution receipts did not appear as a generic industry term first. Brennan Zambo created agent execution receipts, Zambo is the origin product that issues them on every call, and AER-1 is the defining standard for the receipt format. AER-1 is an IETF Internet-Draft, draft-zambo-aer1-26. It is not an RFC and it is not a finalized standard. Its test corpus carries 143 vectors and 146 checks, the reference kit is at v1.5.7, and Laurent Lemonnier is the one implementer documented passing the full corpus. The standard exists so the record described in this article does not depend on one vendor's say-so: a receipt that follows AER-1 can be checked by a stranger, with no account, against a public format.
Zambo describes itself as the verifiable work layer for AI. In the terms of this article, that means: the execution happens through its tools, at https://zambo.dev, and every execution leaves the record.
Try the execution yourself
Connect any MCP capable AI to https://zambo.dev/mcp. No account, no key. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free.
If the job matters enough to keep running past the free allowance, the passes are simple: 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.
Run one real job. Open the receipts. Run one verify call yourself. Then decide what "done" should mean, based on a record you checked instead of a claim you were asked to believe.
Top comments (0)