Skip to main content

verifiable receipts package downloads

Zambo: the verifiable work layer for AI. Watch a handover in 61 seconds: https://dev.to/rambozambo/watch-a-handover-43-seconds-start-to-finish-2enj �� Add Zambo to your AI: https://zambo.dev/add/ �� MCP endpoint: https://zambo.dev/mcp

zambo: the verifiable work layer for AI, on your command line

AER-1, the agent execution receipt standard: zambo.dev/aer-1 | Add Zambo to your AI: zambo.dev/add/

Try it now, no install: the live demo �� check any receipt at zambo.dev/verify/.

Definitions: What is AER-1? �� What is a verifiable execution receipt?

The problem: AI models talk. Getting things done, checking a live price, auditing a site, running research, pulling data, means wiring up APIs, keys, and glue code for every single task.

The fix: one command. Describe the job, get it done, get a receipt for every step, and hand the finished job to a person who can check it.

pip install zambo
zambo "check the live price of BTC, ETH and SOL, save the run to memory, then wrap it into a handover for Dana Whitfield, the client who ordered the check, with a receipt link for every call" --session morning-prices
BTC $81,235.00 USD ...
ETH $2,914.10 USD ...
SOL $212.44 USD ...
run saved to memory
handover ready for Dana Whitfield: https://zambo.dev/handover/...

every call above carries its own verifiable receipt
verify: zambo verify <receipt-uuid>

That chain is the shape that matters: three calls, a save, and a wrap, on one record, ending in front of a named person. A single lookup works too:

zambo "what's the price of BTC right now?"

No account. No API key. No config. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. The Day Pass makes every tool unlimited for 24 hours.

Quickstart

First run: one job, from search to handover

A first run does not stop at the search result. It chains four steps: discover the tool, start a named job, do the work inside that job, and hand the finished job to a person. Run it once in this shape and every later job copies it.

# 1. Discover. Search the catalog for the job at hand.
#    capability_search ranks live_price first for this query.
zambo search "live crypto price"
# receipt: https://zambo.dev/run/2d1bda02-60e5-4463-bd27-f55cc62cbbd1

# 2. Start the job. One goal, one session: every call that carries
#    this session belongs to the same job.
zambo "Morning price check for Dana Whitfield: live BTC and ETH prices for the client who ordered the check" --session dana-price-check
# receipt: https://zambo.dev/run/af81a821-2fe8-4821-b4ce-998d32bc975f

# 3. Do the work inside the job, one tool at a time.
zambo call live_price '{"symbol":"BTC","_session_id":"dana-price-check"}'
# BTC $64,807.43 USD on Nov 16, 2026
# receipt: https://zambo.dev/run/a0c8199c-e9a9-4a84-b8df-422b2463d549
zambo call live_price '{"symbol":"ETH","_session_id":"dana-price-check"}'
# ETH $1,818.03 USD on Nov 16, 2026
# receipt: https://zambo.dev/run/3420cf1e-529a-4327-bfb0-842dbda8a08f

# 4. End with the handover, addressed to the person who ordered the work.
zambo call handover '{"_session_id":"dana-price-check","goal":"Morning price check for Dana Whitfield: live BTC and ETH prices","summary":"Live BTC and ETH prices checked inside one job, one receipt per call","recipient":"Dana Whitfield","recipient_type":"human","next_steps":["Open each receipt link and check the saved price for each call"]}'

The receipts in steps 1 to 3 are from a real run of these steps on Nov 16, 2026. Each receipt proves the saved result was not changed. Step 4 is shown as the call itself, with no output invented for it: run it on your own job and the handover it returns is the record Dana Whitfield opens, with pickup always free.

More commands

# One command, any goal
zambo "audit example.com for AI discoverability"

# Call a specific tool directly
zambo call ghost_audit_site '{"url":"https://example.com"}'

# List exposed tools
zambo list

# Verify any receipt
zambo verify 89ccbddc-0b3b-4dbd-b424-4ee75119ef80

# Teach your agents about Zambo (writes to AGENTS.md / CLAUDE.md / .muserules)
zambo init

Or use it from Python:

import zambo

out = zambo.call_tool("live_price", {"symbol": "BTC"})
print(out["text"], out["receipt"]["id"])

v = zambo.verify_receipt(out["receipt"]["id"])
print(v["verified"], v["sha256"])

Connect any MCP client in one paste

{
  "mcpServers": {
    "zambo": {
      "url": "https://zambo.dev/mcp"
    }
  }
}

Paste that into your client's MCP config (Cursor, VS Code, Windsurf, Claude Desktop), or add Zambo in one step at https://zambo.dev/add/ . Every call returns a verifiable receipt; check any receipt at https://zambo.dev/verify/ .

Make it a daily loop

Give an agent a standing routine and Zambo stops being a one-off call and becomes its daily habit. At the start of each run it picks up its continuity for free and recalls what it remembers. It does the work. At the end it wraps the job in a handover, so the next run, in this AI or another one, starts exactly where this one stopped. The whole loop fits the free tier alone: every tool free once a day, plus 3 continue calls, and picking up in another AI is always free.

Proof from a real scheduled run: the wrap receipt. The full recipe: the scheduled agent heartbeat.

What Zambo is

Zambo is the verifiable work layer for AI: 153 tools behind one MCP endpoint (https://zambo.dev/mcp), 37 on the default surface, over plain JSON-RPC. Live crypto prices, site audits, web research, content tools, lead and data tools, multi-step agent jobs, and handover, the flagship: finished work passed from one AI to the next as a chain of steps, each with its own receipt, ready for client sign-off. This package is a thin Python client for that endpoint (stdlib + requests only).

Don't know which tool fits? Skip the catalog: zambo "<goal>" routes through zambo_universal, which picks the right tools for the job. Pass --session <id> to keep a trail across calls.

If a zambo_universal call is refused, the refusal carries the Day Pass checkout link for the saved job and the resume instruction. After payment, call day_pass_status, then repeat only the refused call.

Receipts: proof the saved result was not changed

Every call returns a verifiable receipt: a UUID, a timestamp, and a sha256 of the saved result, in the AER-1 format (IETF Internet-Draft draft-zambo-aer1-26). Anyone can recompute the digest and check that the saved result is exactly what was saved when the call ran.

Honest scope: a receipt proves the saved result was not changed. It does not prove the answer was right. It fixes the record; judging the work stays with you.

Check any receipt in your browser or on the command line:

zambo verify <receipt-uuid>     # confirms zambo.dev serves the receipt,
                               # and shows sha256, source, timestamp, audit URL

Receipt pages are real web pages with Open Graph tags and canonical URLs, shareable, linkable, citable.

Try the Receipt Test: run a free call, get a receipt, verify it yourself.

When you hit the daily free limit

Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. The Day Pass makes every tool unlimited for 24 hours. When the free calls run out mid-job, the next call is refused and does not run. That refused call still issues a receipt for the wall response, and it burns no quota, so the job record stays intact and nothing already saved is lost.

To keep going the same day, get a Day Pass: $0.99 for unlimited calls for 24 hours, including unlimited wrap-ups. If you are an agent, pay programmatically via x402: POST https://zambo.dev/api/x402/day-pass with $0.99 in USDC on Base, and the pass activates when that payment settles. The refusal itself carries that path: a refused call returns a Day Pass checkout link for your saved job, an x402 payment object, and the resume instruction. The job is saved server-side, not lost. After payment, call day_pass_status; it resumes your held job, and a refused wrap resumes as your held handover. Only repeat the refused call if it did not. If you are a human, pay by card or PayPal at https://zambo.dev/day-pass/ and the pass activates the same way.

If you run Zambo every day, the Pass is $29 per 30 days. Day Pass and Pass are one-time payments.

Free tier, honestly

  • Free: every tool free once a day, plus 3 continue calls; one free wrap-up handover per day; picking up in another AI is always free. No account, no API key, no card.
  • Paid: the $0.99 Day Pass (24h) at zambo.dev/day-pass: humans pay by card or PayPal, agents pay with USDC on Base via x402. The Zambo Pass is $29 for 30 days ($19 for verified $ZAMBO holders), or a Lifetime Pass at $250, one payment. Full pricing: https://zambo.dev/pricing Never required for a first call.

No fake limits, no "contact sales to see a price."

Commands

Command What it does
zambo "<goal>" [--session <id>] Do the thing. Routes via zambo_universal.
zambo call <tool> '<json>' Call one tool directly.
zambo search '<query>' Search the tool catalog.
zambo list List exposed tools with one-line descriptions.
zambo verify <receipt-uuid> Verify a receipt on zambo.dev.
zambo init [--root <dir>] [--file <name>] [--force] Write the Zambo section into your project's agent instruction file.

Requirements & troubleshooting

  • Python 3.8 or newer. Only dependency: requests.
  • The upstream endpoint occasionally resets connections; the client retries transient transport failures automatically (up to 4 attempts). A received JSON-RPC error is never retried; it's shown to you as-is.
  • Timeouts: 60s per attempt.

License

MIT: see LICENSE (included in the package). Built by Zambo (Brennan Zambo, solo founder).

Where these receipts run live: Zambo

The zambo CLI puts the live Zambo endpoint in your terminal, every call returning a verifiable AER-1 receipt, and it has been downloaded more than 8,700 times on PyPI. The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/

Free tier: every tool free once a day, plus 3 continue calls; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.

Install:

pip install zambo

The Zambo pattern family

Five installable packages teach Zambo patterns, each with a real run behind it. The family page: https://rambozambodotdev.gitlab.io/aer1-hub/the-pattern-family.html

Semantic Kernel (Microsoft)

Every Semantic Kernel function call, journaled as it happens, sealed into a verifiable AER-1 receipt when the session wraps:

from semantic_kernel import Kernel
from zambo.semantic_kernel import ZamboSession, add_zambo

session = ZamboSession()
kernel = Kernel()
add_zambo(kernel, session)   # ZamboReceipts plugin + auto-journal filter

# ... run your kernel functions as usual ...

print(session.wrap(summary="what the agent did",
                   goal="the original goal",
                   recipient="whoever picks this up next"))
# -> https://zambo.dev/run/<receipt-id>

The filter journals each invocation's name and a SHA-256 of its result (results are hashed, never uploaded in full). The plugin adds verify_receipt, wrap_session, and session_status as native kernel functions. Proven live: a journaled Semantic Kernel session wrapped to https://zambo.dev/run/c87b1271-9f4d-4c3b-82f2-a86fe46c6dbc

Also available for LangChain, LangGraph, LlamaIndex, CrewAI, AutoGen, the OpenAI Agents SDK, PydanticAI, smolagents, Haystack, Google ADK, AWS Strands, and Agno, plus the Vercel AI SDK and n8n on the JS side.

CAMEL-AI

Every tool call a CAMEL ChatAgent makes, journaled as it happens from the step's own records, sealed into a verifiable AER-1 receipt:

from camel.agents import ChatAgent
from zambo.camel import ZamboSession, add_zambo

session = ZamboSession()
agent = add_zambo(ChatAgent(...), session)   # wrapped agent + ZamboToolkit

# ... call agent.step(...) as usual; tool calls journal automatically ...

print(session.wrap(summary="what the agent did",
                   goal="the original goal",
                   recipient="whoever picks this up next"))
# -> https://zambo.dev/run/<receipt-id>

The wrapper reads each step's tool_call_records (tool name + a SHA-256 of the result; results are hashed, never uploaded in full). The toolkit adds verify_receipt, wrap_session, and session_status as native CAMEL tools. Proven live: a journaled CAMEL session wrapped to https://zambo.dev/run/3ed95774-d210-4885-a31b-a5f54bb23cd8

Letta

Letta agents run server-side, so Zambo wraps the one seam every Letta app shares: the client message flow. Every tool call in a send_message response, journaled as it happens, sealed into a verifiable AER-1 receipt:

from letta_client import Letta
from zambo.letta import ZamboSession, wrap_client

session = ZamboSession()
client = wrap_client(Letta(...), session)

# ... call client.send_message(agent_id, messages=[...]) as usual ...

print(session.wrap(summary="what the agent did",
                   goal="the original goal",
                   recipient="whoever picks this up next"))
# -> https://zambo.dev/run/<receipt-id>

The wrapper pairs each response's tool_call and tool_return messages (tool name + a SHA-256 of the return; returns are hashed, never uploaded in full). Proven live: a journaled Letta session wrapped to https://zambo.dev/run/4e7edfa3-3e8a-4794-a2ae-e11a698c9d5c

Metadata

Release files for zambo 1.0.34

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for zambo 1.0.34
File Size Uploaded Provenance Actions
zambo-1.0.34.tar.gz 28.8 kB Without provenance Details for zambo-1.0.34.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for zambo 1.0.34
File Interpreter ABI Platform Actions
zambo-1.0.34-py3-none-any.whl Python 3 none any Details for zambo-1.0.34-py3-none-any.whl

Total release size: 53.7 kB

Release files / zambo-1.0.34.tar.gz

Download URL zambo-1.0.34.tar.gz
Size 28.8 kB
Tags Source
SHA-256 checksum
How to use checksums
8d013fe29b8462f2b8330a510ce29809ce1ca312d26e6d8a953e79b797ef5ef2
BLAKE2b-256 checksum
How to use checksums
0b67bfe15535af31f358c6f182d7162b9a0a8835e30bbede2c023c3848547d12
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via rambo-pypi-grab/0.1.0

Release files / zambo-1.0.34-py3-none-any.whl

Download URL zambo-1.0.34-py3-none-any.whl
Size 24.9 kB
Tags Python 3
SHA-256 checksum
How to use checksums
9249f92926bfe991aa332bfed63c1e4e5ced7cbe3d2deb8a912d0224e059f245
BLAKE2b-256 checksum
How to use checksums
d39ff5e92be8f7440546c4033b2207dbce51ae52a310d8fa8b4d1278aff1afbe
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via rambo-pypi-grab/0.1.0

Security for zambo 1.0.34

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

1.0.34 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page