Metadata-Version: 2.4
Name: zambo
Version: 1.0.19
Summary: Zambo: the verifiable work layer for AI, on the command line. A verifiable AER-1 receipt for every job, no API key.
Author: Brennan Zambo
License: MIT
Project-URL: AER-1 standard, https://zambo.dev/aer1/
Project-URL: Add Zambo to your AI, https://zambo.dev/add/
Project-URL: Homepage, https://zambo.dev
Project-URL: Documentation, https://zambo.dev/docs
Project-URL: Receipt Test, https://muse.ai/s/the-receipt-test-uxk6ljxzgxyxn1xo
Keywords: mcp,ai,agents,tools,receipts,automation,llm
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: requests>=2.28
Dynamic: license-file

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

**AER-1, the agent execution receipt standard: [zambo.dev/aer-1](https://zambo.dev/aer-1/) | Add Zambo to your AI: [zambo.dev/add/](https://zambo.dev/add/)**

**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.

```bash
pip install zambo
zambo "what's the price of BTC right now?"
```

```text
BTC $81,235.00 USD ...

receipt 89ccbddc-0b3b-4dbd-b424-4ee75119ef80
audit: https://zambo.dev/run/89ccbddc-0b3b-4dbd-b424-4ee75119ef80
verify: zambo verify 89ccbddc-0b3b-4dbd-b424-4ee75119ef80
```

No account. No API key. No config. 20 calls + 1 wrap-up free every day. Picking up in another AI is always free.

## Quickstart

```bash
# One-command: describe any goal
zambo "audit example.com for AI discoverability"

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

# Search the tool catalog
zambo search 'generate QR code'

# 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:

```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"])
```

## 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: 20 calls + 1 wrap-up free every day, and picking up in another AI is always free.

Proof from a real scheduled run: the [wrap receipt](https://zambo.dev/run/1e97b3a8-8c6d-4eff-8dd9-3671b2dfa2e2). The full recipe: [the scheduled agent heartbeat](https://rambozambodotdev.gitlab.io/aer1-hub/scheduled-agent-heartbeat.html).

## What Zambo is

[Zambo](https://zambo.dev) is the verifiable work layer for AI: tools behind one MCP endpoint (https://zambo.dev/mcp), 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.

## 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:

```bash
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](https://muse.ai/s/the-receipt-test-uxk6ljxzgxyxn1xo): run a free call, get a receipt, verify it yourself.

## When you hit the daily free limit

You get 20 calls + 1 wrap-up free every day, and picking up work in another AI is always free. 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: the wall response itself carries an x402 payment, settled in USDC on Base, and the pass activates when that payment settles. 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:** 20 calls + 1 wrap-up free every 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](https://zambo.dev/day-pass/): humans pay by card or PayPal, agents pay with USDC on Base via x402. The Zambo Pass is $29/mo or $290/yr ($19/mo for $ZAMBO holders). 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](https://zambo.dev) (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 3,991 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: 20 calls + 1 wrap-up free every day; 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

- **zambo-swarm**: use it when the job is bigger than one agent and several workers must each prove their piece of one shared job. PyPI: https://pypi.org/project/zambo-swarm/ and npm: https://www.npmjs.com/package/zambo-swarm
- **zambo-loop**: use it when an agent must pick up its own work tomorrow, recall its baseline verbatim, and keep one job alive across sessions. PyPI: https://pypi.org/project/zambo-loop/ and npm: https://www.npmjs.com/package/zambo-loop
- **zambo-verify-pass**: use it when someone retells a result and you need to catch the drift against the receipt of record. PyPI: https://pypi.org/project/zambo-verify-pass/ and npm: https://www.npmjs.com/package/zambo-verify-pass
- **zambo-delivery**: use it when a client must check delivered work step by step and their pickup is the sign-off. PyPI: https://pypi.org/project/zambo-delivery/ and npm: https://www.npmjs.com/package/zambo-delivery
- **zambo-watch**: use it when one watcher checks the same signal on a schedule and must prove what it saw, quiet days included. PyPI: https://pypi.org/project/zambo-watch/ and npm: https://www.npmjs.com/package/zambo-watch

## Semantic Kernel (Microsoft)

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

```python
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:

```python
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:

```python
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
