ZAMBO.

Direct answer

Mastra Agent Receipts

Add verifiable receipts to Mastra tool calls and every tool call your agents and workflows make leaves a record anyone can check. Mastra runs agents in production TypeScript services, where the run's own logs and traces are written by the same system that did the work: useful for debugging, worthless as evidence when a client asks what actually ran. Register the Zambo MCP at https://zambo.dev/mcp as one of the agent's tool sources and each call returns its result plus a verifiable receipt, captured server side at execution, outside the service's control.

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 Mastra runs will publish.

Updated November 9, 2026.

Register Zambo as a Mastra MCP server

Mastra reaches MCP servers through the MCPClient in @mastra/mcp: name the server, give it the remote URL, and the tools it exposes become tools your agents and workflow steps can call:

npm install @mastra/core @mastra/mcp

import { MCPClient } from "@mastra/mcp";
import { Agent } from "@mastra/core/agent";

export const mcp = new MCPClient({
  servers: {
    zambo: { url: new URL("https://zambo.dev/mcp") },
  },
});

const agent = new Agent({
  id: "researcher",
  model: yourModel,
  tools: await mcp.getTools(),
});

Match the client and agent field names to the Mastra version you have installed; the route is the same either way. The Zambo MCP carries 153 tools total, 36 on the default surface, and every call through it returns its result plus a verifiable receipt, captured server side at execution. The record is made by the layer that ran the call, so the service never gets to edit its own history. The pattern is the one described in MCP server receipts: per-call receipts answer what each step did, in the order it did it.

The same registration serves workflows: a step that calls a Zambo tool produces the same receipt as an agent that calls one, so a mixed run of agent turns and workflow steps still closes into one record at the end.

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. Over a raw MCP session the labeled call looks like this:

result = await session.call_tool("capability_search", {
    "q": "the job you need done, in your own words",
    "_caller_label": "your-fleet-or-project-name",
    "_session_id": "your-stable-session-name",
})

Search first, run one worked call, then let the run's memory and continuity live under the same label, so the second day starts by reading the record back instead of starting over.

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 run's 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 summary. 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 endpoint. 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 agent did; the closed record answers what the run did, in full, and it is the link you hand a client or auditor.

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 PayPal or card through 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 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 run's 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 a Mastra agent?

Create an MCPClient from @mastra/mcp with the Zambo server registered at https://zambo.dev/mcp and pass its tools to your agent or workflow step. Every tool call then runs through the Zambo endpoint, which returns the result plus a verifiable receipt at a public https://zambo.dev/run/ URL. At the end of the run, call workflow_close through the same endpoint so the step receipts bind into one chained record a client or auditor can check as a whole.

Can I verify what a Mastra workflow step actually ran?

Yes, call by call. Each tool call routed through the endpoint becomes its own receipt: the tool that ran, the inputs the endpoint recorded, and the output it observed, committed under a SHA-256 hash at the moment the call finished and 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 workflow 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 service logs.

Do Mastra logs and traces prove what the tools did?

Not as evidence. Logs and traces are written by the same service that ran the work, and they can be edited, filtered, or regenerated later with nothing marking the change. Proof appears when the call is captured at execution time by a layer outside the service'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 the Zambo MCP route adds. It proves the saved result is the result recorded when the call ran; whether the result was any good remains a judgment the receipt does not make for you.

What does a Mastra run receipt contain?

One receipt per call, in the AER-1 format: the tool that ran, the inputs the endpoint recorded, the result it observed and saved, a timestamp, and the SHA-256 commitments (the canonical bytes and the output hash) that make the record checkable by recompute. Receipt URLs collect as the run proceeds, and a workflow_close at the end binds the step receipts into one chained record whose children list names every step. AER-1 is an open IETF Internet-Draft, so the format is public text, not a vendor schema.

What does it cost to receipt a Mastra run?

The free tier covers 20 calls and 1 wrap-up free every day, and picking up work in another AI is always free, so you can wire the route 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 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.