ZAMBO.

Direct answer

Agno Agent Receipts

Add verifiable receipts to an Agno agent by routing its tool calls through the Zambo MCP at https://zambo.dev/mcp, using the MCPTools class Agno already ships for connecting agents to MCP servers. Every routed call returns a verifiable receipt at a public URL, and closing the run with workflow_close binds the step receipts into one chained record. Capture happens when the call runs, outside the agent's control, so a claim with no receipt behind it is visible as a gap instead of being smoothed over by the agent's final answer.

See the artifact first: the live demo runs one real call and hands you its verifiable receipt in about 10 seconds, no signup. That receipt is the same object your Agno agent's routed calls will return.

Updated November 10, 2026.

Install: the MCP route to receipts

There is no Zambo package for Agno, and none is needed. Agno agents consume MCP servers natively: the docs import MCPTools from agno.tools.mcp, create one instance per server, and pass it in the tools list of the Agent constructor, alongside any Python functions or Toolkits the agent already uses. Point that instance at the Zambo MCP and the route is complete.

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.mcp import MCPTools

async def main():
    async with MCPTools(
        transport="streamable-http",
        url="https://zambo.dev/mcp",
    ) as zambo_tools:
        agent = Agent(
            model=OpenAIChat(id="gpt-4o"),
            tools=[zambo_tools],
        )
        await agent.aprint_response(
            "Run the job and keep every receipt URL.",
            session_id="your-stable-session-name",
        )

Three details from the Agno docs do the work here. MCPTools selects the streamable-http transport when a URL is supplied, which is the transport for a remote server like this one. Used as an async context manager, it connects before the run and closes the connection cleanly afterward. And the session_id passed to the run is Agno's own session identifier for conversation persistence, so every run of the job stays under one named session instead of scattering across anonymous ones. Use include_tools or exclude_tools on the MCPTools instance if you want to narrow which of the server's tools this agent can call.

Local tools that never leave the process, a plain Python function or a custom Toolkit subclass, do not pass through the MCP connection and get no receipt from this route. Agno documents pre-hooks and post-hooks on runs, and a post-hook is the generic place to capture a local tool's result into your own record if you need one; the checkable, public record this page is about comes from the routed calls.

Wire the agent's tools through Zambo

The Zambo MCP at zambo.dev/mcp carries 153 tools total, 37 on the default surface, and every call through it returns its result plus a verifiable receipt, captured server side at execution. Zambo is the verifiable work layer for AI: the record is made by the layer that ran the call, so the agent never gets to edit its own history. The pattern is the one described in MCP server receipts: per-call receipts answer what the agent did, in the order it did it.

Two properties do the work. Capture happens when the call executes, not when somebody later exports a session log. And the receipt states its own limit plainly: it describes what the endpoint recorded and observed, and it does not claim an outside outcome the endpoint did not observe.

Make the first call a search, under your label

A demo tour is not an onboarding. The pattern that turns a first session into a second day is a first call that searches the catalog for the job the agent actually has, carrying one pinned identity. Every Zambo tool accepts a caller label and a session id as call arguments; usage is counted under that label, and limits and any pass attach to it. Keep the Agno session_id identical across runs of the same job, and have the agent open with the catalog search before it does new work:

await agent.aprint_response(
    "First call capability_search for the job below, under our "
    "caller label, then do the job with the tools it returns.",
    session_id="your-stable-session-name",
)

The free tier makes the pattern cheap to adopt: 20 calls plus 1 wrap-up free every day, and picking up a job in another AI is always free, so a second-day session that starts by reading yesterday's record back costs nothing at the door.

Check the receipts

Every receipt lives at a public URL anyone can open, and checking one is free at zambo.dev/verify with no signup: paste the receipt link or ID and the verifier recomputes the commitment from the saved bytes and compares it with the commitment fixed when the call ran. A match means the saved record is the record made at execution. A mismatch means the record was changed after the fact, and the page says so plainly.

That gives the agent owner an acceptance check with teeth, the Walk-Away Test: set the agent a countable multi-step job, walk away, and on return read the record before the final answer. Claimed steps versus recorded steps is the whole audit. A step an agent claims but never ran has no receipt to point to.

Close the run with one workflow receipt

When the run finishes, call workflow_close through the same MCP connection. The step receipts from the run bind into a single summary receipt whose children list names every step receipt and whose root digest is computed over them, so the whole job verifies as one record: a step added, dropped, or swapped after the fact breaks the root. Per-call receipts answer what this call did; the closed record answers what the agent did, in full, and it is the link you hand a client or auditor. The wrap-up call is the 1 free wrap-up in the daily free tier. If the job continues in another AI instead, handover moves the job, with its record, to that AI, and picking it up there is always free.

Cost stays small either way. A Day Pass is $0.99 one time and covers unlimited calls for 24 hours. The Zambo Pass is $29 for 30 days, one payment, and $19 for 30 days for $ZAMBO holders. A Lifetime Pass is $250, one payment for good. Humans pay by card or PayPal; agents pay USDC on Base via x402. Checking stays free for anyone you hand a receipt to.

Honest limits

A receipt proves the saved result was not changed since it was saved. It does not prove the agent's output was correct, the plan was good, or an outside outcome happened that the endpoint did not observe. It settles what ran, what it was given, and what came back, in a form the agent owner does not have to take on trust. Judge the work itself against that record.

Frequently asked questions

How do I add execution receipts to an Agno agent?

Connect the agent to the Zambo MCP with Agno's own MCP support: import MCPTools from agno.tools.mcp, create one instance for the Zambo server at https://zambo.dev/mcp with transport streamable-http, and pass it in the Agent constructor's tools list, the same way Agno docs attach any MCP server. Every call the agent then makes through that connection returns its result plus a verifiable AER-1 receipt at a public https://zambo.dev/run/ URL. At the end of the run, call workflow_close through the same connection so the step receipts bind into one chained record. There is no separate Zambo package for Agno to install; the route is the MCP connection itself.

Can I verify what my Agno agent did in a run?

Yes, call by call. Every tool call routed through the Zambo MCP becomes its own receipt: what the endpoint was given, what it recorded and observed coming back, a timestamp, and a SHA-256 commitment fixed at execution, published at a URL anyone can fetch. Recompute the commitment from the receipt's canonical bytes; a match means the saved record is the record made when the call ran. A step the agent claims but never ran has no receipt to point to, and that absence is visible in the run's record instead of hidden in the agent's final answer.

Do Agno agent outputs come with proof by default?

Not by default. Agno gives you the run output, the session history, and its own run records, and those are records your own application controls: an output can be retold, trimmed, or regenerated later and nothing in the framework marks the change. Proof appears when the result is captured at execution time by a layer outside the agent's control and committed under a hash: the result bytes saved as recorded, a digest over them, and a public URL where anyone can fetch the record and recompute the digest. That is the record a call through the Zambo MCP adds. It proves the saved result is the result that was recorded when the call ran; whether the result was any good remains a judgment the receipt does not make for you.

What does an Agno run receipt contain?

One receipt per routed tool call, in the AER-1 format: the tool that was called, the arguments the endpoint was given, the result the endpoint recorded and observed, a timestamp, and the SHA-256 commitments (the canonical bytes and the result hash) that make the record checkable by recompute. When you close the run with workflow_close, those step receipts also appear as the children of one summary receipt whose root digest is computed over them, so the full run verifies as a single record. AER-1 is an open IETF Internet-Draft (draft -26), so the format is public text, not a vendor schema.

What does it cost to receipt an Agno run?

The free tier is 20 calls plus 1 wrap-up free every day, and picking up a job in another AI is always free, so you can wire the MCP connection and see real receipts before paying anything. A Day Pass is $0.99 one time and covers unlimited calls for 24 hours. Ongoing use is the Zambo Pass at $29 for 30 days, one payment, and $19 for 30 days for $ZAMBO holders. A Lifetime Pass is $250, one payment for good. Checking a receipt is always free at https://zambo.dev/verify/ with no signup, so clients and auditors never need a plan to check your agent's work.

Run it on a record instead

Reading about the record is one thing; having it under your own work is the point. Work run through the Zambo MCP endpoint at zambo.dev/mcp saves its result at execution and returns a verifiable AER-1 receipt for every call. The Day Pass is $0.99 for 24 hours of the full endpoint, the Pass is $29 for 30 days, one payment, and checking any receipt is always free at zambo.dev/verify.

Related

Proof works best when it travels with the work itself. The AER-1 badge kit turns verifiable receipts into an embeddable badge for project pages, docs, and profiles, so anyone who sees the claim can reach the check in one click.