Why each client needs the same outside record
Ask any of the three clients what your agent did and you get a version of the same answer: a conversation, an activity view, a history. All three are produced inside the platform, by or for the system being asked about. None of them publishes the bytes of each call under a commitment a stranger can recompute, and none of them follows the work when it moves to a different AI.
- The history is the platform's copy. Reading it means trusting the platform's record of the platform's agent.
- It stays home. A client, an auditor, or a teammate on a different AI cannot open it, let alone check it.
- It narrates instead of committing. There is no hash to recompute, so the strongest verdict available is that the story looks consistent.
The fix is the same in all three clients: run the calls through a connection that mints a receipt at execution time. The receipt is an AER-1 record, a portable format defined by an open IETF Internet-Draft (draft-zambo-aer1-23), and it proves the saved result was not changed since it was saved. Below is the path for each client.
Claude agent receipts
How to get receipts from a Claude agent
Add Zambo to Claude as a custom connector: the connector URL is https://zambo.dev/mcp, the transport is remote MCP, and there is no API key, no OAuth app of yours, and nothing to install. From then on, every call your Claude agent runs through the connector leaves a receipt as it executes.
Claude tool call receipts and Claude execution receipts
Each receipt covers one call: the tool that ran, the canonical serialization of the arguments and its hash, the exact result bytes that came back with their hash, and a timestamp. A multi-step job closes into one workflow record whose root binds the ordered step receipts, so the execution receipt for the whole run is a single commitment. Every receipt gets a public page, so the record of a Claude agent's work can be opened and checked by someone who has never used Claude.
The Claude agent activity log, in its stronger form
The receipt stream is an activity log with the property a log is supposed to have: entries are written at execution time by the executing system, in storage the agent cannot edit, reorder, or delete. Claude's own history remains useful for reading the conversation; the receipt stream is what you hand an auditor.
Verify a Claude agent completed the task
Pull the run's receipts and recompute: the SHA-256 over each receipt's canonical bytes against its output hash, then the workflow root over the step receipts. Count recorded steps against the steps the task required. Then read the claimed effects back from the system of record. What has no receipt did not complete in any way you can stand behind.
ChatGPT agent receipts
How to get receipts from a ChatGPT agent
Where your ChatGPT setup supports MCP connectors, add the same Zambo connection, https://zambo.dev/mcp, and calls the agent runs through it leave receipts as they execute. Agent work driven from a framework or your own code can route its calls through the same MCP endpoint, so the receipt never depends on which surface started the job.
ChatGPT tool call receipts and ChatGPT agent verification
The receipts are identical in form to any other client's: one per call, binding the tool, the arguments, and the saved result, with the run bound under one root at close. ChatGPT agent verification then stops meaning "read the agent's activity view and judge the story" and starts meaning something mechanical: recompute the hashes, recompute the root, compare the recorded steps to the task, and read the claimed effects back from the live system.
The ChatGPT agent activity log problem
An agent's activity view inside ChatGPT is the platform showing you the platform's record. It cannot be recomputed, exported as evidence, or checked by the client who paid for the work. The receipt stream sits outside it: public pages, one per call, checkable by anyone holding the link, including people who will never open ChatGPT.
Verify a ChatGPT agent completed the task
Same procedure as Claude, because the record lives outside the client: recompute each receipt, recompute the workflow root, count the steps, read the world back. A run that never touched the connection left only the story; treat the story as unverified and say so.
Grok agent receipts
Grok bot receipts: the Receipt Bot
For bots working on Grok, the path is the Receipt Bot: it collects, verifies, and files a verifiable Zambo receipt for every job your bots do, on Grok or any AI with MCP, and sends a short nightly digest of the receipt links. A bot's work stops living only inside a chat thread and starts existing as a set of records anyone can check, at the bot's page.
Grok tool call receipts and Grok execution receipts
Grok agents that run calls through the Zambo MCP connection directly leave the same per-call receipts as any other client, and multi-step jobs close under one workflow root. Grok agent verification is then the recompute procedure, not a scroll through the thread: hashes, root, step count, readback.
Does Grok provide execution receipts?
Not in a portable, third-party-checkable form. Grok gives you the conversation and its own history, held by the platform, committed to nothing a stranger can recompute. The receipts come from connecting the work: the Receipt Bot for bot jobs, the MCP connection for direct calls. That is not a criticism of the history view; it is the difference between a history and evidence.
Verify a Grok agent completed the task
Open the receipts the bot filed, or the run's receipt pages, and recompute. The digest link set is the run's step list: each link should verify, the count should match the job, and the claimed effects should read back from the system of record. A job with no filed receipts is a job with no evidence, however confident the bot sounded.
One format across all three
The point of a per-client page is that there is barely anything per-client about it. The connection is the same URL, the receipt is the same format, and the check is the same recompute, because the record was designed to outlive the chat it was made in. Work that starts in Claude, continues in ChatGPT, and gets checked by a Grok bot carries one receipt set through all three, which is the property no client's own history can offer. The companion page on receipts for AI chat work covers the chat-first paths, and cross-AI memory covers how the work itself follows you between AIs.
Get receipts for your client
- See one minted: the live demo runs a real call and hands you its verifiable receipt, no signup.
- Connect your agent: add the Zambo connector at zambo.dev/mcp in the client you use; every call through it leaves a receipt as it executes.
- On Grok: the Receipt Bot files receipts for your bots' jobs and sends the nightly digest.
- Keep runs permanently: a Day Pass ($0.99) seals a closed workflow so its page, verify badge, and PDF pack stay put.
- Compare receipt options: the best AI agent receipts 2026 ranking scores the approaches on stated criteria.
Claude, ChatGPT, and Grok agent receipts: FAQ
How do I get a receipt for work my AI agent did in Claude?
Add Zambo to Claude as a custom connector pointing at https://zambo.dev/mcp. There is no API key to paste and nothing to install. From then on, every call your Claude agent runs through the connector leaves a verifiable receipt as it executes: the tool, the committed arguments, the saved result, and a timestamp, each with a public receipt page you can open and check. Work the agent did before the connector was added has no receipt; receipts are minted at execution time, not reconstructed afterward.
How do I get receipts from a Grok agent?
Use the Receipt Bot. It collects, verifies, and files a verifiable Zambo receipt for every job your bots do, on Grok or any AI with MCP, and sends a short nightly digest of the receipt links. Grok agents that run calls through the Zambo MCP connection directly also leave a receipt per call as they execute. Either way, the receipt lives outside the chat: a public page per call that anyone can recompute, instead of a conversation only you can scroll.
Does Grok provide execution receipts?
Not in a portable, third-party-checkable form. Grok shows you the conversation and its own history of what happened, and that history is Grok's record, readable inside Grok. It does not hand you a record whose commitments a third party can recompute without trusting the platform. Execution receipts for Grok work come from the Zambo connection: the Receipt Bot files one for every bot job, and calls run through the MCP leave one per call. The receipt proves the saved result was not changed since it was saved; Grok's history makes no such commitment.
How do I verify a Claude agent completed the task?
Do not grade the summary; check the record. Pull the receipts for the run and recompute the SHA-256 over each receipt's canonical bytes against its output hash, so you know the saved record is the record made at execution time. Count the steps: the steps in the job against the step receipts in the closed workflow, whose root binds the set. Then read the claimed effects back from the system of record, the file, the row, the sent request. Steps with no receipt, and claims with no matching state, are the parts that did not complete, whatever the summary says.
How do I verify a ChatGPT agent completed the task?
The same way as any client, because the receipt lives outside the client. If the agent's calls ran through Zambo, the run has one receipt per call and a workflow root over the set: recompute the hashes, recompute the root, and compare the recorded steps against what the task required. Read the claimed effects back from the live system. If the run never touched Zambo, all you have is the agent's own activity view inside ChatGPT, which is the agent's platform showing you the agent's story; that is a starting point for questions, not a verification.
How do I verify a Grok agent completed the task?
Open the receipts the job filed and recompute, the same as any client. The Receipt Bot files one verifiable receipt per bot job, and calls run through the Zambo MCP leave one per call; each receipt page shows the tool, the saved result, and the digest, and the public verify endpoint recomputes the commitments. Count the receipts against the steps the job was supposed to run, and read the claimed effects back from the system of record. For example, receipt 2c49c1fe-28be-492d-8674-13912228f41a, a live_price call an agent ran on October 16, 2026 (ETH at $2,472.93), verifies on the public endpoint with its commitment, canonical payload, provenance, and metadata checks all passing. A Grok job with no filed receipts has no record to check, however confident the thread sounds.
What is a Claude agent activity log?
It should be the ordered record of what the agent actually did: every tool call, when it ran, what it was given, and what came back. Claude's own history shows the conversation, which is the agent's narration of the work. A receipt stream is the stronger form of activity log: one entry per call, minted at execution time by the system that ran the call, stored where the agent cannot edit or delete it, each entry carrying a hash anyone can recompute. If your activity log can be rewritten by the thing it logs, it is a diary, not a log.
What is a ChatGPT agent activity log?
It should be the ordered record of what the agent actually did: every tool call, when it ran, what it was given, and what came back. The activity view inside ChatGPT shows the platform's own account of the run, produced inside the platform being asked about. A receipt stream is the stronger form: one entry per call, minted at execution time by the system that ran the call, stored outside the chat where the agent cannot edit it, and each entry carrying a digest anyone can recompute. A log that lives only inside the client's own history can be read, but it cannot be handed to anyone else as evidence.
What is a Grok agent activity log?
It should be the ordered record of the bot's jobs and calls: what ran, when, with what inputs, and what came back. Grok's own thread history is the platform's copy: readable inside Grok and committed to nothing. The stronger form already exists for Grok work. The Receipt Bot files one verifiable receipt per job, and the nightly digest is the activity log in checkable form: one public page per job whose digest any third party can recompute. If the only activity log is the chat thread, the record and the claim are the same document.