It is late, and your Muse agent has just finished a day of work you did not watch.
It researched your closest competitors and wrote up what it found. It drafted the launch post twice and kept the better one. It rebuilt the pricing page, answered the inbox, and filed everything where it belongs. A full day of real work, done at machine speed, in another window, while you were living your life.
Then it reports back with one word.
Done.
Under that word, there is nothing. No record you can open. No trail you can walk. Just a summary, written by the agent, about the agent, out of the agent's own memory of itself. If a step failed quietly in the middle of the afternoon, the summary does not know. If a tool came back empty and the agent improvised around the hole, the summary will never mention it. Done is carrying the whole day on its back, and it is carrying it alone.
So here is the question everything turns on. When your Muse agent says done, what do you hold?
Right now, you hold a claim. There is another option, and it is almost embarrassingly old fashioned.
A receipt.
The record, captured at the moment it happens
A zambo receipt is a record of one execution, minted by the execution layer at the moment the call runs. Not a story the agent tells afterward. Not a log the agent keeps about itself. A record, made when the work happened, by the system that ran it.
Every receipt holds the same things:
- What ran. The tool that executed, by name.
- What it was given. The recorded inputs, with a digest of those inputs carried on the receipt.
- What it produced. The actual observed result, saved in full, inside a canonical record whose SHA-256 digest is printed on the receipt.
- When. A timestamp from the moment of execution.
The receipt lives at a public link. Anyone can check it, by recomputing the digest from the saved record and comparing it to the digest on the receipt. Change one character of the saved result after the fact and the check fails. The agent does not need to be online, cooperative, or even still installed for that record to be checked.
And the claim stays narrow, on purpose. A zambo receipt proves the saved result was not changed since it was saved. It does not prove the answer was right, and it never pretends to. That narrowness is the reason it can be trusted: it only ever claims what it can show.
A real one, minted while this was being written
Enough shape. Here is an actual receipt, from an actual call, run through Zambo's MCP server during the writing of this article. A simple one on purpose: a live Bitcoin price check.
- Run page: https://zambo.dev/run/46de82e7-e6ed-47ba-864e-d94eac4904ab
- Tool: live_price, given one input, BTC
- Result, saved in full:
BTC · $83,425.00 USD
▲ 0.94% (24h) · Market cap: $1677.05B
Live price via CoinGecko · Tue, 13 Oct 2026 21:52:53 GMT
- Output digest: sha256:e188334b736b3dd005885f62c362eb5a0068524e3700a9142685796853e65baa
Before this article went anywhere near publish, we took the canonical record behind that receipt, decoded it, and recomputed its SHA-256 ourselves. It matches the digest above, character for character. That is not a courtesy detail. It is the entire idea, demonstrated on a receipt you can open right now and redo the math on yourself.
One call, one receipt. A real job chains up: every step leaves its own receipt, and the job can close with a summary receipt that binds the step receipts together under a single root digest. Break one step later and the root no longer matches. The record covers the whole run, not just the parts the agent felt like summarizing.
The add that feels like a superpower
Here is the part that feels like discovering a cheat code.
You do not install anything. You do not create an account or generate an API key. You simply ask Muse, in chat, to create a custom connector to one line:
That is the whole setup. The ask is the whole step: Muse builds the connector itself, walks you through connecting it, and saves it under Settings, then Connectors, where you manage it from then on. One sentence, and the most capable worker you have ever had gains a memory you can audit.
One honest line, because receipts are about honesty: Zambo's submission to the Muse connector directory is still in review, so the custom connector is the way in today. It is the same connection either way, and it takes less time than making coffee.
From then on, when your Muse agent works through Zambo's tools, every call leaves a receipt like the one above. The day of work still happens in another window. The difference is that now, underneath the word done, there is something.
The record follows you
A Muse session ends. The receipt does not.
Every receipt lives at a public link, so the record follows the work instead of staying trapped inside one app, one chat, one afternoon. Start a job with your Muse agent in the morning. Check the receipts from your phone at lunch. Hand the link to a teammate. Open the same record inside a completely different AI next week and keep going. Work follows you across AIs now, and the record travels with it.
Underneath it all, the format is AER-1, an open IETF Internet-Draft (draft-zambo-aer1-19), defined by a public specification with public test vectors. Your records are not locked inside one vendor's private format, waiting to become unreadable the day you switch tools.
Ten seconds, no commitment
If connecting anything feels like a step too far tonight, the human version is the live demo: https://zambo.dev/demo/ It runs a real call and mints a real receipt you can check on the spot. No signup, ten seconds, and you will understand the whole thing better than this article can explain it.
Your Muse agent is going to keep doing work you cannot watch. That is not a flaw in the arrangement. That is the arrangement, and it is a wonderful one.
Just make sure done comes with a receipt.
Your AI said "done." For $0.99, prove it: https://zambo.dev/day-pass/
Top comments (0)