Add the server: Agent Canvas, CLI, or SDK
OpenHands takes MCP servers on every surface it ships, and Zambo is a hosted Streamable HTTP endpoint, so there is nothing to install locally:
Agent Canvas (local or connected to OpenHands Cloud): open Customize, then MCP Servers, then Add custom server. Set Server Type to SHTTP, the transport OpenHands recommends for remote servers, URL to https://zambo.dev/mcp, and Authentication to None. Click Test connection, a working server reports how many tools it provides, then Save.
CLI: one command writes the same entry into ~/.openhands/mcp.json:
openhands mcp add zambo --transport http https://zambo.dev/mcp
SDK: pass the config to your agent:
mcp_config = {
"mcpServers": {
"zambo": {"url": "https://zambo.dev/mcp"}
}
}
agent = Agent(..., mcp_config=mcp_config)One rule from the OpenHands docs worth knowing before you test: servers you add or change apply to new conversations, not to conversations already running. Add the server, then start a fresh conversation, and the agent can call Zambo's tools alongside its built-in ones. The endpoint serves 153 tools in total, 36 of them on the default surface the client sees first.
What gets receipted, and what does not
Calls served through the endpoint return a receipt inside the response itself, with a public URL at https://zambo.dev/run/ that anyone can open. Route the steps a reviewer will ask about through it: the research the fix was based on, the checks run against the result, the decisions recorded along the way, and the wrap-up that hands the finished job over with its record attached.
The honest edge: OpenHands' own built-in actions, the file edits, terminal commands, and browser steps it runs itself, are not receipted by this route. No page should tell you a tool-call record covers work that never passed through the tool. What the endpoint route gives you is a checkable record of the working calls you route through it, kept outside the run, in a form that survives the session, the workspace, and the agent's own summary of itself.
Verify one yourself before you rely on it
Take any receipt from your first run and check it at zambo.dev/verify. 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. Then do the negative test every evidence system should survive: change one character in a copy of the record and check again. It fails, plainly, in public. A record system that cannot fail in public cannot pass in a way that means anything.
And keep the claim honest when you present it: a receipt proves the saved call record was not changed after it was saved. It does not prove the code the agent wrote was good. Review still matters; the receipt just makes the review about the real calls instead of about a summary of them.
Questions, answered
How do I add receipts to OpenHands?
Add Zambo as a custom MCP server. In Agent Canvas, open Customize, then MCP Servers, then Add custom server: Server Type SHTTP, URL https://zambo.dev/mcp, Authentication None, then Test connection and Save. On the CLI, run: openhands mcp add zambo --transport http https://zambo.dev/mcp. In the SDK, pass mcp_config with an mcpServers entry named zambo pointing at the same URL. Servers you add apply to new conversations, not ones already running. Every call the agent makes through the endpoint returns a verifiable AER-1 receipt with a public URL, and checking a receipt is free at zambo.dev/verify with no account.
What part of an OpenHands run do the receipts cover?
The calls your agent makes through Zambo's tools: the research, checking, continuity, and hand-off steps it runs as part of the job. OpenHands' own built-in actions, the file edits and terminal commands it runs itself, are not receipted by this route, and this page does not pretend otherwise. The pattern that works in practice is to route the steps a reviewer will ask about through the endpoint: what was checked, what was decided, what state the job was left in, and the wrap-up at the end. Those steps come back receipted, and the rest of the run stays exactly as it was.
What does an OpenHands receipt prove?
It proves the saved call record was not changed after it was saved. The receipt fixes a hash of the call's record at execution time; recompute it later and a match means the record is the one that was made. It does not prove the agent's code was correct or its answer right. What it settles is the factual layer underneath every review: which calls ran, in what order, and what came back, in a form someone who was not present can verify.
Why does the record need to live outside the run?
Because the run's own record is kept by the run. OpenHands' tracker carries a live case where a conversation's workspace files were lost while the conversation record survived: two halves of the same job, one of them gone. A receipt is fixed at the moment the call runs and is checkable from outside the run entirely, so the record of the work does not depend on the workspace, the session, or the agent's own summary surviving intact.
What does it cost to receipt an OpenHands run?
Starting costs nothing: the free tier is 20 calls + 1 wrap-up free every day, and picking up a job in another AI is always free, so you can add the server and see real receipts before paying anything. A Day Pass is $0.99 one time and covers 24 hours of calls. 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. Full pricing: https://zambo.dev/pricing. Checking a receipt is always free at https://zambo.dev/verify/ with no signup, so reviewers never need a plan to check your agent's work.
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.