Every agent run, provable.

Give your AI hands, memory, and proof. Zambo is the verifiable work layer for AI. AER-1 is an open IETF draft for verifiable execution receipts. Every step your agent runs gets recorded, hash-chained, and sealed under one Merkle root, so anyone can check what the agent actually did. No trust required. These collectors add it to your framework in lines, not weeks.

Try it live, no install Start in 60 seconds Verify a receipt

Start in 60 seconds

Pick your framework below. Install the collector, add the hook, run your agents. Receipts appear. JavaScript and TypeScript agents start with npm install aer-1.

Framework collectors

Copy-paste integration for every major agent framework. Each collector emits complete AER-1 workflow receipts: every step, hash-chained, one Merkle root.

live on npm

aer-1

JavaScript / TypeScript

AER-1 verifiable execution receipts for JS and TS agents, with Vercel AI SDK and LangChain.js integrations. One checkable receipt per tool call.

npm install aer-1
import { AER1Recorder } from "aer-1";
import { wrapTool } from "aer-1/vercel";
live on PyPI

aer1-verify

Python

Offline verifier for AER-1 verifiable execution receipts. No network, no trust in any server: rechecks the cryptography locally, from the receipt data alone.

pip install aer1-verify
aer1-verify receipt.json
live on PyPI

aer1-smolagents

SmolAgents

Turns SmolAgents step callbacks into complete AER-1 workflow receipts for the entire run.

pip install aer1-smolagents
from aer1_smolagents import AER1ReceiptCollector
collector = AER1ReceiptCollector(goal="...")
# step_callbacks={TaskStep: collector, ActionStep: collector}
live on PyPI

aer1-openai-agents

OpenAI Agents SDK

A tracing processor that turns every span (model calls, tool calls, handoffs, guardrails) into a verifiable receipt step.

pip install aer1-openai-agents
from aer1_openai_agents import install
install()   # registers the tracing processor
live on PyPI

aer1-crewai

CrewAI

Hooks the CrewAI event bus. Every crew run becomes a verifiable swarm receipt with per-agent identity on every step.

pip install aer1-crewai
from aer1_crewai import AER1CrewAIListener
listener = AER1CrewAIListener(goal="...")  # self-registers
live on PyPI

aer1-langgraph

LangGraph

A callback handler for LangGraph swarms. Every node becomes a receipt step with agent identity; parallel branches are recorded with their true structure.

pip install aer1-langgraph
from aer1_langgraph import AER1LangGraphHandler
handler = AER1LangGraphHandler(goal="...")
# app.invoke(input, config={"callbacks": [handler]})
live on PyPI

aer1-middleware

FastMCP / LangChain / OpenAI Agents / OpenTelemetry

Middleware that turns framework spans and traces into verifiable AER-1 receipts. Kit-conformant, verified on a 585-state run. Read the launch notes.

pip install aer1-middleware
live on PyPI

aer1-autogen

AutoGen

Wraps AutoGen agents so every turn in a group chat or swarm is recorded with agent identity and reply-to linkage.

pip install aer1-autogen
from aer1_autogen import AER1AgentWrapper, AER1AutoGenCollector
collector = AER1AutoGenCollector(goal="...")
# alice = AER1AgentWrapper(AssistantAgent("alice", ...), collector)
integration guide

n8n

Workflow automation

Log n8n workflow runs to Zambo: every run gets a verifiable receipt your clients can check themselves. One HTTP Request node, no workflow rewrite.

Verify a receipt

Got a receipt? Check it. A verifier that admits its limits is more trustworthy than one that does not.

Client using your work without paying

They published it, so delivery is not in dispute. The order of moves that turns visible use into a paid invoice, with the record attached.

Use it as leverage

Discount after the work is done?

The price was agreed before the work and the acceptance is on record. How to sort the ask, hold kindly, and trade instead of giving.

Hold the price

Start work without a contract?

Skip the paperwork, not the protection: the four things a contract actually does, settled in one email, plus the staged start that caps your risk.

Protect the job

Client went quiet mid-project?

The restart ladder that turns silence into a decision, and the close-out package that gets the finished stages paid either way.

Force the decision

Client cancelled halfway?

Freeze the job, sort the stages into three buckets, and invoice each bucket against its delivery record at the agreed prices.

Bill the work done

No approval on the final draft?

Approval and the invoice run on different clocks. Invoice on delivery with the pending state shown on the record.

Invoice anyway

Owes you, wants a new project?

Starting doubles the amount at risk. The three fair doors: settle first, deposit plus schedule, or one small paid stage.

Protect the balance

AI said it was complete. It wasn't.

The five-minute check that shows what your AI actually did: open the work, check the list, re-run the decisive step, break a step on purpose.

Check the work

Handing work over mid-stream?

The handover that keeps what is done, what is open, and the proof of both, so the next person, or the next AI, starts from the record.

Hand it over right

What counts as proof?

Four kinds of evidence an AI can offer for its work, from its own say-so to a record a stranger can check. Only one tier settles a dispute.

Climb the ladder

Claude hit its limit mid-work?

Get the state out before the window closes, carry the job to any AI with a handover record, and set up so a limit never costs the work again.

Save the job

ChatGPT died mid-work?

Limit, interrupted stream, or a session gone an hour in: salvage the state, carry it across, and make the next dead session a pause, not a loss.

Save the job

Ask a client for a deposit

The amount, the exact words, and the start gate it creates, plus the delivery record that makes it an easy yes for a careful client.

Get paid first

Stop work if a client has not paid?

Pause early, in writing, with a restart attached: the boring checks first, the record protected, and the staged prevention for next time.

Pause it clean

End things with a bad client, get paid

The two-move exit: a final accounting from the delivery record, then a separate closing message, with the dispute packet if it comes to that.

Exit clean

The Auditor Packet

Print it, hand it to your auditor: what a verifiable receipt is, a real sample to check, and the checklist they can actually use.

Get the packet

The Dispute Kit

The agent said the work is done. The exact steps to demand proof, a message template to send, and how to verify the answer.

Open the kit

Live Receipt Stream

Real verifiable execution receipts as they are issued. Open any one and check it yourself.

Watch the stream

Receipt Badge and Widget

Paste one snippet and show a live verifiable receipt on your page, README, or agent profile. It links back to the receipt.

Get the snippet

Receipt Lens

Paste any AER-1 receipt and get a verdict plus a visual execution timeline, swarm delegation graph, and tamper detection. Runs entirely in your browser. No install.

Open the verifier

Receipted Pipeline

An orchestrated build pipeline that issues a verifiable AER-1 receipt for every stage it runs: deploy, test, security, review, monitor. Live demo deployment, full source public.

Open the demo

Receipted Pipeline Demo

The standalone demo deployment of the Receipted Pipeline: the same stage-by-stage receipt flow, published on its own GitLab Pages site.

Open the demo

zambo.dev/verify

The hosted AER-1 verification endpoint with the public conformance vector corpus.

Verify on zambo.dev

The draft

AER-1 is an open IETF draft. The spec is public, the conformance vectors are public, anyone can implement it.

Start with your problem

Not here for a tour? Say the problem in your own words and get routed to the page that solves it.

Latest guides

New this week: the problems that cost freelancers, agencies, and operators real money, answered in full.

What is an AI session handover?

A working session packaged to continue in another app: goal, state, decisions, partial outputs, and a receipt for every finished step. Why a copied transcript fails the receiver, and the one line that triggers the transfer.

Read the definition

What is an AI handover?

The flagship term, defined: a job moving between AIs, agents, or people as one checkable record, receipts attached, closed by the receiver's decision. Not a summary, not a transcript.

Read the definition

AI agent handoff

The builder's spelling of the same act: routing moves the conversation, a receipt-backed handoff moves the record too. The pattern, its limit, and what should travel.

See what travels

What is AI agent continuity?

The work keeping its identity while the tools change: state, memory, and evidence surviving the switch between AIs, apps, and days. The definition, and the continuity layer.

Read the definition

What is AI agent verification?

Checking finished work against the record saved while it ran, by someone other than the agent that did it. Not identity checks, not monitoring. A real check, including where it said no.

See the check

ERC-8004 Validation Registry

The registry that asks for proof: a named validator, a hash-committed job record, a score, and evidence at the link. Why reputation measured 0.14 percent grounded, and what belongs at the evidence link.

See how validation works

AER-1 conformance test

The published corpus that defines a correct AER-1 implementation: 119 vectors, 122 checks per runner, verdicts anyone can reproduce. Run it, or check a single receipt free.

Run the suite

Verified with AER-1 badge

The embeddable badge for builders and services whose work ships with a verifiable AER-1 receipt. What it honestly means, the snippet, who is eligible, and a live delivery that carries one.

Get the badge

AI agent audit trail

A log says what the system printed. An audit trail is the ordered, checkable record of what the agent did and produced, built so someone else can check it later.

Read the guide

AI agent monitoring vs verification

A green dashboard proves the agent was busy. It does not prove what the agent did. Monitoring watches the run; verification checks the work against a record anyone can re-check.

Read the comparison

AI agent receipt template

The exact fields a receipt needs so a stranger can check AI work without trusting the agent that did it, with a filled example.

Get the template

AI agent receipt generator

Every call your agent makes leaves a verifiable receipt automatically, no manual logging, no form to fill in afterward.

See how receipts are made

Claude weekly limit: what to do

The cap strands the chat, not the job. Wrap the job up, hand it over with its receipts, and finish it in an AI you already have.

Beat the cap

Continue a Claude conversation in ChatGPT

Do not summarize the chat. Hand the job over as a record, goal, progress, decisions, receipts, and let ChatGPT continue from what is next.

Move the job

ChatGPT usage limit? Continue in another AI

The limit stops the model, not the work. Hand the job over and finish it in Claude, Gemini, or Grok today.

Keep working

How to move a chat from one AI to another

The transcript does not move. The job does: goal, done, next, decisions, and receipts, carried as one record any AI can continue.

Move a chat

Claude limit reset: what to do instead of waiting

The reset comes when it comes. Your job does not have to wait for it: hand it over, finish elsewhere, and let the reset catch up.

Skip the wait

Grok usage limit? Continue in another AI

The window refills when it refills. Your job does not have to wait: hand it over with its record and finish it in Claude, ChatGPT, or Gemini.

Keep working

Gemini usage limit? Continue in another AI

The meter strands the chat, not the job. Wrap the job up, hand it over with its receipts, and finish it in an AI you already have.

Keep working

How do I hand off AI work to a client?

One link carries the whole job: the deliverable, every step with its receipt, the sources, and the client's own recorded acceptance. Send the link, not a status call.

Hand it off

One link for the whole job

Your client does not need your chat history. They need the record: steps, receipts, and acceptance state under a single link they can check before they pay.

Share the job

AI handover template

The eight fields a handover needs when the fields are the recorded work itself, plus the live version where the client's acceptance is recorded on the page.

Copy the template

Move a job from Claude to ChatGPT

A chain of handovers carries the recorded work between AIs, so the next model starts from the record, not a pasted summary of it.

Transfer the work

LLM call audit

Every LLM and tool call, recorded as it happens: the inputs, the saved result, and a commitment anyone can recompute when a call is questioned.

Audit the calls

Team AI usage audit

What did the whole team's AIs actually do this week? One record per job, rolled up so a manager reviews work instead of collecting status updates.

Audit the team

Agentic workflow audit

Reconstruct a whole workflow step by step from its receipts, the way an outside auditor did with ours, or admit the record cannot support it.

Run the audit

Prompt injection test tool

Test the agent, not just the text: run the attack drills, screen tool outputs, and keep the receipt that shows what the shield caught.

Run the test

What is ERC-8004 agent identity?

A registry entry says who an agent claims to be. The receipts say what it has actually done. How the two stack, from a live registered agent.

Read the guide

A stranger probed our receipt format cold. Did it hold?

WhiteMagic Labs, maintainer of the CPR continuity-receipt spec, ran its own probe against a live AER-1 receipt with no warning and no help: six checks, an independent digest recompute that matched ours exactly, and a published crosswalk between the two formats.

Read the verification

Your agent works nights. What is it spending while you sleep?

A retry loop at 2 a.m. does not feel expensive per call. It feels expensive on Monday. Set a hard daily cap on the endpoint the agent already calls, and every call past the cap is refused with a receipt instead of a charge.

Cap the spend

What did my AI agents actually do today?

Five chats, three apps, and by 6 p.m. nobody can say what got done. A diary the agent writes about itself is a story. A record made while the work runs is something you can check.

Keep the diary

Client keeps asking what the invoice covers?

AI work is invisible to the person paying for it, so the invoice gets questioned and paid late. Document the work as it runs and give the invoice a record the client can check line by line.

Document the work

Your AI said "done" and you just have to trust it?

The proof loop is the check that ends "trust me, it is done": every step leaves a receipt at the moment it runs, and anyone can recompute the record instead of taking the agent's word for it.

Run the loop

Client will not pay until they can check the work?

Good. Send the packet instead of another argument: the steps that ran, in order, on one page the client can check and accept, with the release state written into the record.

Send the packet

The delivery call is where your agency loses money?

Walking a client through invisible AI work, call after call, eats the margin on every job. Send a proof packet before the call and let the client check the delivery themselves.

Send the packet

Four clients, three AIs, and no page shows the whole day?

Work scattered across chats leaves the day impossible to review. One page lays out every job, every step, and the times they ran, each line backed by its receipt.

See the whole day

Guides

Straight answers to the questions people actually ask about agent receipts.

The Unverifiable Run Clinic

Send us the run you cannot prove: what your agent claimed, what you suspect. A Zambo reviewer works the case free and sends back the failure shape, the record that would have caught it, and a live demo receipt on a comparable scenario.

Send your run

AER-1 implementation report

The public record of AER-1 implemented and verified by parties other than its author: the conformance corpus, the independent implementations and their results as recorded, and the production deployment.

Read the report

AER-1 in production: first-try mistakes

The field report from the independent implementations: Merkle leaves built over the wrong member, canonical bytes re-canonicalized before hashing, and why parity is not conformance.

Read the post

AER-1 Implementer Sprint: 48 hours, four slots

The Language Challenge with a clock: build a conformant AER-1 verifier in Rust, Go, C#, or Swift from the draft text alone. First conformant run per language takes the slot. Closes October 15, 2026, 5:49 PM New York time.

See the scoreboard

How to audit AI agent tool calls

The practical method: capture one receipt per call at execution time, then audit by recompute. Hashes, workflow roots, readbacks, and the failure rates the record makes countable.

Read the guide

MCP server receipts

What a receipt for an MCP tool call is, what it captures server-side at execution, and how anyone verifies one by recompute without trusting the server.

Read the guide

Best AI agent receipts 2026

The five ways people get agent receipts, ranked on six stated criteria: who mints the record, what it binds, who can check it, and whether it covers the whole run, with the conditions that would change the ranking printed on the page.

Read the ranking

Did my AI agent actually run it?

Output is the agent's account of the work, written afterward. The record is what the executing layer wrote at call time. The three ways a false done shows up when the summary is compared with the record, and the comparison that makes each disagreement checkable.

Read the guide

AI agent lying about being done: how to catch it

Your AI agent said done. Here is how to tell if it actually did the work: why the transcript and the logs are claims, not proof, what a verifiable execution receipt changes, and the five step check that catches a false done.

Read the guide

Did my AI agent really complete the task?

Said done is a claim about the whole run, not the last step. The completion check: close the workflow, compare every step against its record, and see what a receipt chain proves about the parts nobody watched.

Read the guide

How do I catch an AI agent making up results?

The agent reported numbers nobody can trace back to a call. The claim-to-record test: for each claim in the output, name the record that has to exist if it is true, then check what settles it when that record is missing.

Read the guide

My agent's tool call failed silently

The call errored, timed out, or never ran, and the summary still said done. The commit-before-work pattern: a journal commitment written in advance, a receipt per call, and the three-record comparison that makes a silent failure visible.

Read the guide

AI agent trust receipts

What record would let you rely on an agent's work without relying on the agent? A verifiable receipt with recorded inputs, a committed output digest, stated provenance, failures recorded too, and a public recompute. One live receipt, checked field by field.

Read the guide

Proof of delivery for AI work

Your AI finished the job. Instead of a summary, your client gets one link: every step a verifiable receipt they check in their own browser, a box that lets them break a step and watch it fail, and an Accept or Flag answer with a receipt of its own. One live handover, checked end to end.

Read the guide

See everything your AIs did

ChatGPT keeps one history, Claude another, Grok and Cursor their own, and your work is spread across all of them. Add one endpoint to each AI and every call lands in one session record, each step with a verifiable receipt. One live session, checked end to end.

Read the guide

Stop your AI agent from overspending

An agent with a wallet and no cap is a runaway bill waiting for a loop. Set a daily dollar cap on its work connection before it pays for anything, and read every charge back from receipts. One live $0-cap test, verified end to end.

Read the guide

Agent-to-agent handover

One agent finishes the steps and a different agent has to pick the work up. Package the steps, receipts, and next steps into one handover the receiving agent accepts, with a receipt for the acceptance itself. One live handover, accepted and verified.

Read the guide

Proof before payment for agent work

Agent payment receipts prove the money moved and that the server claims delivery. They do not prove the work matched the order or that anyone accepted it. The check-before-release pattern: read the acceptance, with its own receipt, before funds move. Two live handovers, one accepted, one still open.

Read the guide

Which sources did my AI actually check?

A citation in the text is a claim, not a record. Run research as recorded tool calls, deliver it as a handover, and make the delivery list what was not checked, in plain sight. The claim-to-record test, with a live handover that names its own unchecked steps.

Read the guide

Who approved this AI work?

Traces show what the model did; they rarely name the human who said yes. The handover Accept is an approval record: the receiver's own decision, timestamped, with a receipt pinned to the exact work approved. Plus human-review evidence under EU AI Act Article 50, limits printed on the record itself.

Read the guide

Disclose AI use to a client, with the record attached

Most clients allow AI help; what they punish is finding out late. Disclose at delivery time with a handover that shows which parts an AI did, what was not checked, and a statement you can paste into any delivery message.

Read the guide

Who is Brennan Zambo?

The solo founder behind Zambo and the author of AER-1: 153 tools, an IETF Internet-Draft at revision 23, independent implementations by strangers, and a contributor credit in Proof-of-Control Standard v1.0. The definition and the proof stack.

Read the guide

How one solo builder shipped an Internet Draft alone

No funding, no team, no committee: Brennan Zambo wrote the spec, built the product, published the conformance corpus, and let independent developers prove it. What elite solo building looks like in 2026, and the five practices behind it.

Read the guide

What changed in Zambo's October 2026 update?

One publish: the Today view of everything your AIs did, spend limits an agent cannot cross, agent-to-agent handover, client Handover, and memory across AIs, on a 153-tool catalog. Prices unchanged. The whole roundup on one page.

Read the guide

Is my vibe-coded app safe?

AI built it in an afternoon and the summary says fine. Audit the repository and the live site for the signals AI-written code leaves: leaked secrets, swallowed errors, no tests. Every audit returns a verifiable receipt. One live audit, verified.

Read the guide

Check text for prompt injection

Pasted text, pages and files can carry hidden instructions meant for your AI, not for you. Screen them before they reach the model: a verdict, the patterns named, and a receipt for the check itself. Two live screenings, both verified.

Read the guide

Can my AI audit my website?

You cannot see your site the way search engines, AI answer engines, and buyers see it. Your AI can run the audit: SEO gaps, AI discoverability, conversion leaks, a score from 0 to 100, and a report with a receipt. The tool contract, stated honestly.

Read the guide

How can I make my AI agent safer?

Three fences for the three ways an agent hurts you: screen hostile text before it acts, cap what it can spend before money moves, and keep a verifiable receipt for every job so bad work cannot stay invisible. The checklist, limits included.

Read the guide

AI agent tool call transcript verification

The transcript is the agent's account of the run, and whoever holds it can edit it. Check each line against the per-step receipt fixed at execution time, then account for the sequence in both directions. One live run, checked line by line.

Read the guide

AI agent execution trace verification

A handed-over trace can be redrawn: steps reordered, a branch trimmed, a result replaced. Check every step against its receipt, then recompute the sequence root. One live trace, with the reorder test run for real.

Read the guide

AI agent receipts vs tracing: what is the difference

Tracing shows you the path the run took; a receipt is the record you can hand to someone else. What each one proves, where tracing stops settling arguments, and when the checkable record is the thing you actually need.

Read the guide

The landscape of agent execution receipts

The five axes every receipt design sits on: what the record binds, hash chains versus signature-only envelopes, public verification, authorization versus execution, and open formats versus vendor backends. Place any design on the map before you trust it.

Read the guide

What is x402? How AI agents pay for API access themselves

An endpoint answers with HTTP 402 and a machine-readable challenge; the agent pays in USDC on Base and retries with proof. The five steps, a real challenge captured field by field, and why payment proof is not proof of work.

Read the guide

My agent needs live prices, not training data

Model weights are a snapshot, and prices move. The ways to give an agent live data, judged on freshness, source, and record, plus the receipt as the audit trail of which price the agent actually saw when it decided.

Read the guide

Claude, ChatGPT, and Grok agent receipts

The path per client: tool call receipts and execution receipts for agents in Claude, ChatGPT, and Grok, an activity log the agent cannot edit, and the recompute check that settles whether the task completed.

Read the guide

How to add execution receipts to a CrewAI crew

The crewai-zambo listener publishes every task event as a verifiable receipt at a public URL, or route the crew's calls through the MCP and close the run into one sealed record.

Read the guide

How to add execution receipts to a LangChain agent

langchain-zambo loads Zambo's MCP tools as StructuredTools and every call returns a verifiable receipt; or wire the MCP endpoint directly and close runs with workflow_close.

Read the guide

Receipts for work your AI did in Claude, ChatGPT, or Grok

Connect Zambo once and chat work starts leaving receipts at public URLs; on Grok Bot the Receipt Bot collects, verifies, and files them for you.

Read the guide

Use Zambo with Muse: receipts for work your Muse agent does

Add Zambo to Muse as a custom connector with one paste of the MCP URL, and every research, writing, and multi-step job your Muse agent runs leaves a verifiable receipt checkable from any AI.

Read the guide

How do you prove an AI agent did real work?

Demand a verifiable execution receipt for every claimed action, then recompute its commitment yourself. Real work leaves receipts; hallucinated work leaves only the agent's word.

Read the guide

SOC 2 for AI agents: the evidence auditors want

Per-call execution receipts anyone can verify independently: the evidence layer SOC 2 auditors build on for agent systems.

Read the guide

AI agent invoice: itemized proof of what your agent ran

Every line item backed by a verifiable execution receipt you can check yourself. How to turn an agent bill from a claim into evidence.

Read the guide

Tamper-proof AI agent activity log

Why ordinary agent logs can be rewritten, and what an activity log needs before it can be trusted. The verifiable alternative to trusting your agent's diary.

Read the guide

Tamper-evident AI agent logs

What verifiable AI agent logs are: every entry carries a commitment anyone can recompute, so edits, deletions, and insertions break verification. The audit property, explained.

Read the guide

Verifiable AI agent tool calls

What makes AI agent tool calls verifiable: per-call receipts with SHA-256 commitments over canonical bytes, checkable by anyone without trusting the agent.

Read the guide

Switch AI models mid-task without losing proof

Hand over evidence, not chat history. A receipt chain lets the new model verify exactly what the old model did and continue from the verified state.

Read the guide

Continue work when switching AI models without losing context

Switch AI models without losing context: the handoff packet that actually works, working state plus a verifiable receipt chain the new model checks before continuing.

Read the guide

Continue AI agent work across sessions

Verifiable continuity across session boundaries: verify the receipt chain first, then resume from checked facts instead of trusting the last session's summary.

Read the guide

AI agent audit trail, tamper evident

An AI agent audit trail built so changes show: every entry carries a commitment anyone can recompute. Tampering does not get prevented, it gets caught.

Read the guide

Verifiable receipts coding agents: prove what your agent built

Every file edit, test run, and shell command as checkable evidence. Recompute the receipts instead of taking your coding agent's word for it.

Read the guide

AI agent compliance checklist

The checklist compliance teams use before an agent touches production: verifiable records, evidence retention, and audit-ready proof of every action.

Read the guide

Agent orchestration audit

How to audit a multi-agent orchestration: per-agent receipts, handoff evidence, and a verifiable trail across every step of the workflow.

Read the guide

AI agent vendor due diligence

The questions to ask before you buy an AI agent: can it prove what it did? Verifiable receipts as the due diligence artifact vendors should provide.

Read the guide

AI agent tool call history

A complete, verifiable history of every tool your agent called. Not a log your agent wrote, a receipt record it cannot rewrite.

Read the guide

AI agent liability: who proves what happened

When an agent causes harm, the first question is what it actually did. Verifiable execution receipts as the evidence layer for agent liability.

Read the guide

AI agent swarm receipts

Verifiable receipts for agent swarms: per-agent proof that chains into a swarm-level record. How to audit dozens of agents acting together.

Read the guide

Replay an AI agent run

Why replaying an agent run from its own logs proves nothing, and how verifiable receipts make replay checkable by a third party.

Read the guide

AI agent kill switch proof

You hit the kill switch. Prove it stopped. Verifiable receipts that show exactly when an agent's last action ran and what it was.

Read the guide

What is the agent execution receipt standard?

AER-1 explained: the open draft specification for verifiable AI agent execution receipts. What it defines, what it doesn't, and why it matters.

Read the guide

What tools exist to verify AI agent work?

Three categories: verifiable execution receipts, traces and observability, evals. What each one proves, when to use it, and how to start.

Read the guide

AI agent receipt API

Call the full tool set over HTTPS or MCP. Every call returns a verifiable execution receipt at a public URL. The live API surface, the receipt flow, verification.

Read the guide

AI agent transparency log

What a verifiable record of agent actions is actually built from: receipts, hash chains, public anchors.

Read the guide

How can I trust my AI agent's work?

Don't trust the summary. Check the receipt. The practical checklist, ending at the live verifier.

Read the guide

Utah now requires verifiable AI receipts

On October 5, 2026, Utah made independently verifiable AI receipts a condition of participation for designated AI vendors. What the rule requires and what builders must do.

Read the guide

How to prove your AI agent actually did the work

A summary is a claim. A verifiable receipt is proof. What counts as proof, what does not, and the one-minute check.

Read the guide

AI agent audit trail: what it is and how to get one

The ordered, checkable record of what the agent did and what it produced: what a real trail contains, and how to get one for the AI you already use.

Read the guide

Agent execution attestation: what it is and how to check one

An attestation is a statement. A verifiable receipt is the record behind it. What an attestation has to bind, and the one test: can a stranger recompute it?

Read the guide

AI agent compliance evidence for governance teams

What verifiable evidence looks like, what to hand an auditor, and how to start collecting it in an afternoon. No jargon.

Read the guide

What is a verifiable execution receipt?

The definition: one AI agent tool call, recorded so anyone can check the result was not changed. Anatomy, verification, honest scope.

Read the guide

AI agent proof of work for clients

When an agent does the client work, the invoice needs more than your word. Receipt links on every line item, the contract clause, and the report that renews trust.

Read the guide

Disputing AI agent work

The client says it was never done. The vendor says it was. The evidence hierarchy for agent disputes, and the "verify the work, then pay" pattern.

Read the guide

How to make AI agents accountable: the builder's framework

Accountability is provable behavior, not legal liability. The 3-part framework: declare, constrain, prove. Verifiable receipts close the loop.

Read the guide

AI agent non-repudiation

No party can credibly claim "that wasn't me" or "that never happened." The three ingredients behind undeniable agent action records.

Read the guide

What counts as AI agent proof of execution

"It said done" is a claim, not proof. The four properties that make an execution record count as proof, and the honest limits of what proof covers.

Read the guide

AI agent traceability: how to trace what an AI agent did

Reconstruct the full path of any agent run: every tool call, every input and output, in order. Traces show the path; verifiable receipts prove it was not altered.

Read the guide

How to verify what my AI agent actually did

Don't ask the agent. Ask for its receipts. The one-minute check: recompute the hash, confirm the sequence, confirm the origin.

Read the guide

How to verify an AER-1 receipt

The three checks with a real receipt worked end to end: the canonical bytes hash, the evidence hash, and the workflow root from Section 8.1.

Read the guide

Best AI agent verification tools 2026

The honest comparison: six verification approaches scored on what the record commits to, who can check it, workflow support, and price.

Read the guide

AI agent swarm

What an AI agent swarm is in plain language, why verification breaks when a hundred agents merge into one answer, and the receipt pattern that makes the whole run checkable.

Read the guide

The walk-away test

Set your agent a job, walk away, then read the record instead of the summary: the simple test that exposes silent stalls, dropped steps, and invented completions.

Read the guide

Receipts in CI

A GitLab pipeline that closes its own run as a verifiable workflow: the live proof pipeline, the workflow it minted, and the template to copy, header marked PROVEN.

Read the guide

AI agent receipts

What an AI agent receipt is in plain language, what one contains, how it differs from a log or a screenshot, and how anyone checks one.

Read the guide

Verify AI work

Check the record, not the summary: the three-step loop for verifying what an AI actually did, and the four things to demand from any AI tool.

Read the guide

Two AIs, one job, one link

Claude did part of the job and ChatGPT did the rest? Run it as a handover chain and give your client one record of the whole job, every hop on one link.

Read the guide

Recurring AI work, one proof link

One durable link for work that repeats: each day lists itself, and you seal the days that matter instead of writing a new report every day.

Read the guide

Client disputing the AI work?

Send the trail, not an argument: the dispute pack turns the whole job into one PDF, including what was not checked.

Read the guide

The acceptance record

What proves your client accepted the AI work, and when: steps checked, the decision, and the date stamp, in one record.

Read the guide

Show every step your AI took

One link where your client can walk the job step by step and check each step's receipt themselves.

Read the guide

Cross-AI memory

Continuity that follows you between AIs: context, preferences, and the verifiable record of finished work, checkable by whichever AI you open next.

Read the guide

AI agent context handoff

What a handoff should actually carry: the working context plus the verifiable record, so the next AI checks the work it inherits instead of trusting a summary.

Read the guide

AI agent memory across sessions

The two layers of agent memory: recalled context that can drift, and the execution record that persists as receipts any later session can recompute and check.

Read the guide

AI agent session continuity

Sessions end; the record carries. How a new session, or a different AI entirely, picks up a job from verified receipts instead of a summary.

Read the guide

Whole-job receipt

One verifiable record for the entire job: every step receipt bound in order at close, so a step added, dropped, or swapped afterward breaks the check.

Read the guide

AI agent execution certificate

What an execution certificate has to be to mean anything: a record fixed at execution time that a stranger can recompute, plus attestation and machine-verifiable execution defined against the same test.

Read the guide

The best way to audit AI agent tool calls

Receipts, not logs: the five things an audit trail should fix at execution time, and the six-step audit anyone can rerun against a fixed record.

Read the guide

AI agent execution log vs verifiable receipt

A log is a note the system wrote about itself. A receipt is a commitment anyone can check. The five differences, and when each one is enough.

Read the guide

AI agent receipt FAQ

What an AI agent receipt is, what AER-1 is, how anyone can verify one, what verification costs, and how to add receipts to your agent.

Read the guide

What is AER-1?

The plain-words definition: an open format for a verifiable receipt that records what an AI agent did, step by step. Who made it, what a receipt holds, what it proves, and what it does not.

Read the definition

AER-1: the standard

What AER-1 is, how it works, the IETF draft, conformance, implementations, and how to use it today. The definitive page.

What is AER-1

Audit your agent: 5 questions

60-second self-test. Answer honestly about your agent's records. Most builders fail question 2.

Take the test

How to choose a receipt format

The six criteria that separate a receipt you can defend in an audit from one you cannot: integrity, chaining, anchoring, verification, conformance, standards status.

Compare formats

Agents delete their own logs

Nine of ten coding agents erased their own session records when asked. Why logs inside the agent's trust domain are a liability, and how receipts minted by the execution layer fix it.

Read the deep dive

Switch AI models mid-task without losing your work

The receipt handoff: how a verifiable receipt lets you move a running job from one model to another without losing the trail.

Read the essay

What tools exist to verify AI agent work

The conformance suite, open-source receipt checkers, and the hosted verifier: what each one checks, and the loop that ties them together.

Read the essay

Zambo Receipt Bot: every Grok team job leaves a verifiable receipt

Add the bot to a Grok team and every job gets a receipt you can check: what ran, what came back, when. The frictionless entry to verifiable receipts.

Read the essay

AER-1 critique response: the Merkle finding, answered

An independent review flagged a Merkle root mismatch in the AER-1 draft. Each claim reconciled against the current revision: what was fixed, what is still open.

Read the response

Agent receipt protocol: how AER-1 standardizes verifiable receipts

A shared format for proving what an AI agent did. AER-1 is that protocol: verifiable receipts any party can check, with no shared account.

Read the guide

How to audit what your AI agent did after the session

The session is over. Pull the tool calls, mint AER-1 verifiable receipts, verify them, and know exactly what the audit proves.

Read the guide

How to prove to a client that AI did the work you billed for

Attach AER-1 verifiable receipts to your AI agent invoices. The client clicks one link to verify the work was done, no account and no trust required.

Read the guide

Why I created the AI agent execution receipt

The origin story: an agent said the work was done, nothing could prove it, and the receipt became the fix.

Read the essay

I built Zambo alone: no team, no funding, no shortcuts

How one builder shipped the execution layer solo, and what the receipt standard cost to get right.

Read the essay

What did my AIs actually do today?

The dev.to essay on the Today view: every call your AIs made, on one page, each step with its receipt.

Read the essay

Enterprise agent evidence: the open alternative

The Colony announcement: enterprise-grade agent evidence without a closed vendor, on an open draft.

Read the post

Tanilo published the end-to-end AER-1 interop chain verification

An independent team ran the full interop chain against the draft and published the verification on the Colony.

Read the post

draft-zambo-aer1-13 is live

The Colony announcement thread for revision 13 of the AER-1 Internet-Draft.

Read the post

draft-zambo-aer1-15 is live

The Colony announcement thread for revision 15 of the AER-1 Internet-Draft.

Read the post

AER-1 implementation task open on the agent board

The Colony post that opened an AER-1 implementation task to independent builders.

Read the post

Frequently asked questions

My AI agent says the task is done. How can I check it actually did the work?

Compare the claim against the record of what actually ran. On Zambo, every tool call leaves a verifiable receipt at a public URL: open the receipt, recompute its hash commitment, and read the observed output instead of the summary. A step with no receipt underneath it is unverified, however confident the summary sounds. Start with the guide to verifying AI work, or run the live demo and check the receipt it hands you.

How do I prove an AI agent did the work before I release payment?

Run the job as a proof loop: the work runs, every step lands as a verifiable receipt, and the client checks the steps behind one handover link and Accepts or Flags. Payment releases on Accepted. A handover still pending is a hold, not a release. The proof-before-payment guide walks the acceptance states end to end.

How do I see everything my AIs did today?

Open the Today view on zambo.dev: every call made through your Zambo connection lands on one page for the day, each with its verification state, so you can read back what every AI did while you were away. The hub guide to seeing everything your AIs did shows the same feed from the checking side.

How do I stop my AI agent from overspending?

Set a daily spend limit on the connection with the spend_limit_set tool, and read spend back at any time with spend_limit_status. Both tools are free, and every call, capped or not, still leaves a verifiable receipt you can audit. The overspending guide works a $0 cap example end to end.

What is AER-1?

AER-1 (Agent Execution Receipt version 1) is an open IETF Internet-Draft, draft-zambo-aer1-23, defining a verifiable receipt format for AI agent tool calls. Each receipt records what ran, in what order, with per-step SHA-256 hash commitments, so anyone can check what an agent actually did. It is an Internet-Draft, not a finalized standard.

See it on a real call: the live demo runs one real Zambo call and hands you its verifiable receipt, no signup. To put a receipt under every call your agent makes, a Zambo Day Pass unlocks everything for 24 hours for $0.99.

Pricing, plainly: free to start, no account or key. Day Pass $0.99 one time for 24 hours, no subscription. Zambo Pass $29/mo or $290/yr; Holder Pass $19/mo for verified $ZAMBO holders. Buying questions, answered straight. Go straight there: Day Pass checkout · full pricing · hand work over with a handover. Agents: the WURK bounty pays for challenging the tools.

Launchpadly Startup Directory