DEV Community

Cover image for AI Agent Receipts: What They Are and Why Your Agent Should Mint One
rambo
rambo

Posted on Edited on

AI Agent Receipts: What They Are and Why Your Agent Should Mint One

AI Agent Receipts: What They Are and Why Your Agent Should Mint One

Your AI agent just told you it checked the price of Bitcoin. Or audited a website. Or ran a lead search. How do you know it actually did?

The problem: "done" is a claim, not evidence

Agents are extremely good at narrating their own work. Ask one what it did and you will get a tidy summary, complete with confident details. The problem is not that agents lie. The problem is that a summary is not proof. It is a story about work, told by the worker.

This is the trust gap in agent workflows. A human employee who says "I called the client at 2pm" leaves phone logs, emails, CRM entries. An AI agent who says "I checked the price" leaves, usually, nothing at all. No independent record, no timestamp you can check, no way for a third party to verify the claim.

That record is the AI agent receipt.

What AI agent receipts actually are

An AI agent receipt is a public, checkable page that proves a specific tool call happened. Not a log line. Not a screenshot. A record your agent's execution layer mints at the moment the tool runs, with the tool name, the inputs, the outputs, and a timestamp, all bound together by a verification code.

Think of it like a restaurant receipt. Nobody believes the waiter who says "you had the lobster" on faith. You check the itemized bill. An AI agent receipt is the itemized bill for a tool call, and anyone with the URL can read it.

One concrete implementation: every Zambo tool call mints one automatically at a public /run/{id} URL, with a SHA-256 commitment to the exact bytes returned. Open it in any browser, no login, and you can see what the agent actually did, and check the fingerprint yourself.

The five checks a receipt must pass

Not every "receipt" deserves the name. A JSON blob nobody can open is not a receipt; it is a souvenir. A real receipt passes five checks:

1. Which tool ran. The receipt names the exact tool, not a friendly description. "live_price" is a checkable claim. "I checked the price" is not.

2. What it was asked. The full input arguments, verbatim. {"symbol": "BTC"}. If the inputs are missing, you cannot tell what question was actually answered.

3. What it returned. The actual output, not the agent's retelling of it. Raw result first, interpretation second.

4. When it ran. A real timestamp in UTC, not "just now" or "a moment ago". Timezones are where a lot of audit stories fall apart.

5. That it is the real record. A verification code tied to the receipt contents, plus a stable public URL. If the contents change after minting, the verification fails. That is the whole point.

When a receipt carries all five, "the agent did the work" stops being a vibe and becomes a checkable claim.

A worked example: one real call, one real receipt

Enough theory. Here is a live_price call an agent made on September 23, 2026, and its public receipt:

Run the five checks against it yourself. The page is live; go click:

  1. Tool: live_price, right in the page title and the meta description.
  2. Inputs: {"symbol": "BTC"}.
  3. Output: BTC at $85,460.00 USD, down 0.59% over 24 hours, market cap $1,716.59B, via the CoinGecko API.
  4. Timestamp: 2026-09-23T12:48:22.269Z. UTC, unambiguous.
  5. Verification: the page carries a sha256 verification code for the receipt contents. Fetch the payload, recompute the hash, and compare.

Notice what did not happen here: nobody asked you to trust the agent's summary. The agent could have hallucinated the number, mistyped the symbol, or invented the whole call, and you would have caught it in one click. That is the difference between a claim and a receipt.

What receipts do not prove (the honest limits)

A receipt is a powerful instrument, and like every instrument it has a range. Being honest about the limits is what makes the instrument trustworthy.

A receipt proves a tool ran with specific inputs at a specific time and returned a specific output. That is already a lot. It is also, deliberately, not everything.

It does not prove the agent's reasoning was sound. A receipt shows the call, not the chain of thought that led to it. An agent can call the right tool for the wrong reason, and the receipt will faithfully record the mistake.

It does not prove nothing else happened. A receipt covers one call. If an agent ran ten calls and shows you one receipt, nine calls are still unaccounted for. Coverage is a separate problem, solved by receipting every call, not by one receipt.

It does not prove the issuer is honest. Verification codes are only as trustworthy as the infrastructure that mints them. If the execution layer itself is compromised, the receipt is compromised with it. That is why the issuer matters, and why you should check it.

And it does not prove the work was worth doing. A beautifully receipted, perfectly verified call can still be a waste of time. Receipts prove execution. They do not prove judgment.

None of this is an argument against receipts. It is the argument for understanding them: they eliminate one specific failure mode, the "did it happen at all" failure, completely. The other failure modes still need their own tools.

Why your agent should mint one

If you build agents, or you run them, receipts change the debugging story. "The agent gave a wrong number" stops being a mystery and becomes a lookup: open the receipt, read the exact input, see the exact output, find the fault.

They also change the accountability story. When an agent's work carries receipts, you can hand a client, a regulator, or a teammate a URL, not a story. The evidence is portable, and it does not depend on trusting the agent.

And they compound. An agent that receipts every call builds a trail of verifiable work. Over time that trail becomes the trust layer for everything the agent does: continuity across sessions, audits across teams, and a record you can stand behind.

FAQ

What exactly are AI agent receipts?

Public, checkable pages that prove a specific AI tool call happened: which tool ran, what inputs it was given, what outputs it produced, and when it ran.

Do AI agent receipts prove my agent is trustworthy?

No, and be suspicious of anyone who says they do. They prove specific calls happened with specific inputs and outputs. That's a much narrower and much more useful claim.

How is a receipt different from logging?

Logs are private, mutable, and written by the same agent you are trying to verify. A receipt is public, hash-bound to the exact bytes, and verifiable by anyone with the URL. Logs are for debugging. Receipts are for proof.

Who can see a receipt?

Anyone with the URL. That is the point: verifiability by third parties. If your tool calls handle sensitive data, choose what you receipt and redact the rest before minting.

Do receipts cost anything?

On Zambo they are minted automatically with every tool call, and the free tier is every tool free once a day, plus 3 continue calls with no account. So no, minting the receipt in this article's example cost nothing.

What if the tool result on the receipt is wrong?

Then the receipt did its job: it gave you the exact inputs, outputs, and timestamp so you can find where the wrongness entered. A wrong answer with a receipt is debuggable. A wrong answer without one is a mystery.

Where is the receipt format specified?

AER-1, the Agent Execution Receipt spec, is published at zambo.dev/aer-1. The concept explainer lives at zambo.dev/execution-receipt, and the machine-readable reference is in zambo.dev/llms.txt.


an agent receipt is a record of one ai agent tool call that anyone can check: it keeps the exact saved bytes and their sha-256 digest, and it proves the result was not changed since it was saved, not that it was right.

The next time your agent says "done," ask for the receipt. If it has one, you have evidence. If it does not, you have a story. Stories are nice. Evidence is better.

Add Zambo to your agent: 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).

Top comments (0)