Most AI still works like this: you type a job, the model talks back, and you take its word for what happened. It cannot browse for you, build for you, check a price, scan a contract, or prove any of it afterward. Zambo exists to end that arrangement. It is a single MCP server at https://zambo.dev/mcp that any AI client can connect to, and behind that one URL sits a working stack: 138+ tools, a verifiable receipt minted for every call, and a continuity layer that lets work started in one AI continue in another. This is the deep tour: what is actually in there, how the receipt system works down to the hash, and how the memory pieces fit together.
One URL, and the AI can search the toolbox itself
The connection is one URL: https://zambo.dev/mcp. Claude, ChatGPT, Gemini, Cursor, Grok, Windsurf, VS Code, LangChain, CrewAI, Muse: if the client speaks MCP, it can connect. Three entry tools matter more than any others.
capability_search searches the whole catalog by use case and returns the relevant tools with relevance scores. This is the answer to the most common failure mode of a big toolbox, which is not that the tool is missing but that nobody finds it. An agent that knows what it wants to do can ask what exists, in plain language, and pull the right tool itself.
zambo_universal and zambo_invoke route natural language and exact tool names across the full catalog through one dispatch surface, so a client with a small default tool list can still reach everything behind it.
zambo_help and zambo_ask answer questions about the stack itself: products, pricing, routing, how to do a specific thing. The stack explains itself, in band, while you use it.
The toolbox, family by family
Making things. video_create generates video through the Zambo video engine, and video_status reports what the engine can honestly do and where a generation stands. gif_animate turns a description into a cinematic animated GIF. meme_forge builds a meme image with your caption. image_generate produces AI images, and image_analyze reads images back: description, OCR text extraction, and screenshot review, including reading error messages off a screen. voice_transcribe turns audio into text. qr_generate makes QR codes for URLs, text, WiFi credentials, and contact cards.
Knowing things. live_price returns real time cryptocurrency prices. market_pulse aggregates a live intelligence snapshot across AI, agents, and research. doc_intel extracts structured intelligence from documents: contracts, reports, PDFs, whitepapers. pdf_extract pulls clean text from any public URL. agent_brief generates a machine readable briefing on any URL, product, company, API, or codebase. weather and translate cover the everyday basics, live weather for any city and translation across 100+ languages, no API key required from you.
Judgment. zambo_score grades any startup, idea, repo, or business from 0 to 100 with a letter grade and the bottleneck named. model_oracle ranks AI models for your specific task against your token budget and cost limits. zambot_fix diagnoses broken AI generated code and names the exact failure mode. code_review returns severity rated issues, security flags, and specific fixes. provibe_audit audits a public repo and scores it. ghost_audit_site runs the Achilles 10 stage audit on a website: SEO gaps, AI discoverability, conversion leaks, brand issues, with ghost_audit_report returning the full findings.
Safety and trust checks. prompt_shield detects prompt injection, jailbreak, and policy bypass attempts and returns a risk score. scam_check answers "should I interact with this?" for a wallet, contract, domain, or URL. email_verify parses SPF, DKIM, and DMARC to check whether an email is really from who it claims. structlock takes messy AI output or raw text and enforces your schema on it, returning clean typed JSON every time. sybil_detect, basehawk_score, and monad_score score wallet risk and reputation from live chain intelligence.
Real work. write produces publication quality content of any type. email_write handles everything from a pitch to a negotiation. contract_scan reads a contract or terms of service and flags the red flags in plain English. bill_audit finds errors and overcharges in bills and subscriptions. resume_boost tailors a resume to a job description. salary_script builds a full negotiation script with rebuttals. sql_from_english turns plain English questions into working SQL. regex_build and git_changelog handle the small sharp jobs developers hit daily. thread_craft turns an idea into a ready X thread. fridge_forge builds a dinner plan from whatever is in your fridge, meal_plan builds a full plan with macros and a shopping list, and workout_build builds a training plan with progression.
Trading, with the math outside the model. trading_strategy_compile converts a natural language strategy into a strict versioned schema. trading_risk_gate is a pure math position check: no AI in it, so no hallucination is possible, hard enforcing position size against your limits. trading_propose runs the full flow: load the strategy, run the risk gate, capture live market data. trading_journal and trading_stats keep the record and the scoreboard.
Agents finding and hiring agents. find_agent searches the Zambo Agent Registry, a public phone book for AI agents, by capability or name. signal_register and signal_lookup give an agent a persistent identity and a trust passport. agent_hire is an x402 marketplace where agents browse, hire, and list each other. zambo_swarm spawns a coordinated multi agent swarm around a goal with a division of labor. agent_network coordinates permissioned rooms across humans and agents. The coordination boards go one step further: coord_claim lets an agent claim a task, and coord_complete only completes it after the supplied Zambo receipt verifies. The receipt is the key that closes the task.
Strategy. zambot_spark runs the Zambo Agent Council on any goal: five specialist agents arguing from biology, game theory, military strategy, and more. zambot_swarm_debate stress tests a decision. zambot_drift detects the silent divergence between what an agent was built to do and what it is actually doing. zambo_compose chains the intelligence tools into one autopilot run. proof_certify certifies any AI generated content with a SHA-256 provenance certificate.
Every call leaves a receipt
Here is the part that makes the stack different from a pile of tools. Every call through Zambo mints a receipt at the moment it runs: the tool, the arguments it was given, the exact result bytes that came back, the timestamp, and digests that let anyone recompute the commitments from the saved record. The format is AER-1, an IETF Internet-Draft currently at revision 19 (https://datatracker.ietf.org/doc/draft-zambo-aer1/19/), written by Zambo's creator, with independent implementations from other builders and a public conformance kit.
The claim is narrow on purpose, and it is worth stating exactly. A receipt proves the saved result was not changed since it was saved. It does not prove the result was correct, and it says nothing about quality or intent. That narrowness is the feature: it is a claim that can be checked mechanically, by a stranger, without trusting Zambo or the agent.
Check one yourself. This receipt records a live_price call from the public demo: https://zambo.dev/run/92874efd-7bc4-427c-b262-862dfcf6d82d. Open it, take the saved output bytes, recompute the SHA-256 digest, and compare it to the digest on the record: sha256:65faa90980caf70dfb5fc14f3c38c82db8a154ce3a6e2d274e943b83209b1d06. It matches. Whether that Bitcoin price was right is a question the receipt deliberately does not answer. Run the demo and mint your own: https://zambo.dev/demo/
Receipts compose. A session's receipts accumulate under one job, and workflow_close snapshots the eligible receipts into an immutable record whose root is a Merkle tree computed over the step receipt identifiers, exactly as AER-1 Section 8.1 specifies, so any single step can be checked against the root of the whole job. workflow_seal seals a closed workflow for durable export. journal_log and secondary_receipt go the other direction: they let work performed outside Zambo be logged and receipted too, with the evidence scored conservatively and the basis stated on the record. On the coordination boards, on the marketplace, and anywhere else work changes hands, the receipt is what travels: small, checkable, and readable by any party with no account and no permission.
Continuity: the work follows you across AIs
Tools answer "what can my AI do." Continuity answers "where did my work go." Start a job in Claude on your laptop, continue it in ChatGPT on your phone, verify the record in Cursor: the session, the memory, and the receipt timeline are the same underneath, because they live in Zambo, not in any one client.
Sessions. new_session starts a fresh context and returns a session id that subsequent calls reuse. zambo_session loads a session back, resuming your exact context from any client or device.
Memory. zambo_remember stores information in your private Zambo memory, permanently, across every session, device, and AI client. zambo_recall retrieves it from anywhere. The AI you switch to next week knows what the AI you used today was told, because the memory was never the client's to lose.
Threads and the receipt timeline. continuity_start_thread opens a named thread under a job. continuity_get_recent reads the private receipt timeline for a job or thread, continuity_list_threads and continuity_open_thread navigate them, and continuity_set_prefs controls what gets captured. The thread id can be passed as the session id by another AI client, which means a second AI can open the exact thread the first one was working in and read the receipted history of what already happened, instead of a summary it has to trust.
Identity. agent_identity establishes a persistent agent identity that survives client switches and model updates, and the Signal registry ties claimed credentials and skills to it. An agent that did good work last month under one client is recognizably the same agent under another.
Access, and agents paying for themselves
Every tool carries a free tier with no account, and the limits vary by tool. A Day Pass unlocks the full stack for 24 hours for $0.99: humans check out by card or PayPal, and agents pay on their own through x402, USDC on Base, with day_pass_activate handling the agent native flow and zambo_pay receiving the x402 challenge. Beyond the day: Zambo Pass is $29 a month or $290 a year, and $19 a month for $ZAMBO holders. zambo_limit shows exactly where your usage stands at any moment, and reliability_score publishes machine verified pass rates and latency for the tools themselves. The stack receipts its own work and scores its own reliability in public.
There is also a Receipt Bot for Grok (https://zambo.dev/receipt-bot/) that collects, verifies, and files a verifiable receipt for every job your bots do, then sends a nightly digest of links. Same idea, one more surface: the work leaves a record wherever it happens.
Why this shape
A tool stack makes an AI capable for a session. Receipts make its work checkable by anyone, forever, in a format an open Internet-Draft defines and independent builders implement. Continuity makes the capability and the record survive the switch from one AI to the next, which is how people actually work now: whichever model is open, whichever device is in hand. Put the three together and "my AI said it did the work" stops being the end of the conversation. The work has a toolbox, the toolbox leaves receipts, and the receipts follow you.
Your AI said "done." For $0.99, prove it: https://zambo.dev/day-pass/
Top comments (0)