aer-1
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";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.
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.
Copy-paste integration for every major agent framework. Each collector emits complete AER-1 workflow receipts: every step, hash-chained, one Merkle root.
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";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
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}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
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
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]})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
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)Log n8n workflow runs to Zambo: every run gets a verifiable receipt your clients can check themselves. One HTTP Request node, no workflow rewrite.
Got a receipt? Check it. A verifier that admits its limits is more trustworthy than one that does not.
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 leverageThe 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 priceSkip 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 jobThe restart ladder that turns silence into a decision, and the close-out package that gets the finished stages paid either way.
Force the decisionFreeze the job, sort the stages into three buckets, and invoice each bucket against its delivery record at the agreed prices.
Bill the work doneApproval and the invoice run on different clocks. Invoice on delivery with the pending state shown on the record.
Invoice anywayStarting doubles the amount at risk. The three fair doors: settle first, deposit plus schedule, or one small paid stage.
Protect the balanceThe 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 workThe 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 rightFour 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 ladderGet 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 jobLimit, 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 jobThe 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 firstPause early, in writing, with a restart attached: the boring checks first, the record protected, and the staged prevention for next time.
Pause it cleanThe 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 cleanPrint 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 packetThe 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 kitReal verifiable execution receipts as they are issued. Open any one and check it yourself.
Watch the streamPaste one snippet and show a live verifiable receipt on your page, README, or agent profile. It links back to the receipt.
Get the snippetPaste 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 verifierAn 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 demoThe standalone demo deployment of the Receipted Pipeline: the same stage-by-stage receipt flow, published on its own GitLab Pages site.
Open the demoThe hosted AER-1 verification endpoint with the public conformance vector corpus.
Verify on zambo.devAER-1 is an open IETF draft. The spec is public, the conformance vectors are public, anyone can implement it.
draft-zambo-aer1-23: the living specification for verifiable execution receipts.
Read the draftThe one-prompt implementing guide plus starter kits in Python, Go, Rust, and Node.
Start implementingAER-1 x Tanilo: a full interop run with real values, chain verified end to end and double-verified by both sides.
See the interopFlyThink x AER-1: verifiable receipts bound to physical completion events, replayed and verified case by case with claim-scoped binding.
See the interopEvery recorded AER-1 conformance result and interop run in one matrix, reproduced as recorded, with the records linked.
See the resultsThe public leaderboard of independent AER-1 implementations and their conformance results.
See the leaderboardPassed the conformance kit and listed in the registry? Embed the badge in your README. It links back to the registry.
Get the badgeNot here for a tour? Say the problem in your own words and get routed to the page that solves it.
New this week: the problems that cost freelancers, agencies, and operators real money, answered in full.
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 definitionThe 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 definitionThe 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 travelsThe 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 definitionChecking 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 checkThe 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 worksThe 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 suiteThe 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 badgeA 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 guideA 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 comparisonThe 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 templateEvery call your agent makes leaves a verifiable receipt automatically, no manual logging, no form to fill in afterward.
See how receipts are madeThe 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 capDo 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 jobThe limit stops the model, not the work. Hand the job over and finish it in Claude, Gemini, or Grok today.
Keep workingThe transcript does not move. The job does: goal, done, next, decisions, and receipts, carried as one record any AI can continue.
Move a chatThe 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 waitThe 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 workingThe 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 workingOne 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 offYour 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 jobThe 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 templateA 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 workEvery 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 callsWhat 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 teamReconstruct 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 auditTest 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 testA 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 guideWhiteMagic 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 verificationA 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 spendFive 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 diaryAI 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 workThe 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 loopGood. 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 packetWalking 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 packetWork 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 dayStraight answers to the questions people actually ask about agent receipts.
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 runThe 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 reportThe 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 postThe 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 scoreboardThe 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 guideWhat 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 guideThe 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 rankingOutput 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 guideYour 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 guideSaid 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 guideThe 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 guideThe 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 guideWhat 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 guideYour 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 guideChatGPT 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 guideAn 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 guideOne 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 guideAgent 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 guideA 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 guideTraces 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 guideMost 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 guideThe 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 guideNo 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 guideOne 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 guideAI 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 guidePasted 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 guideYou 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 guideThree 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 guideThe 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 guideA 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 guideTracing 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 guideThe 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 guideAn 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 guideModel 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 guideThe 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 guideThe 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 guidelangchain-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 guideConnect 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 guideAdd 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 guideDemand 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 guidePer-call execution receipts anyone can verify independently: the evidence layer SOC 2 auditors build on for agent systems.
Read the guideEvery 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 guideWhy 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 guideWhat 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 guideWhat 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 guideHand 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 guideSwitch 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 guideVerifiable continuity across session boundaries: verify the receipt chain first, then resume from checked facts instead of trusting the last session's summary.
Read the guideAn 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 guideEvery 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 guideThe checklist compliance teams use before an agent touches production: verifiable records, evidence retention, and audit-ready proof of every action.
Read the guideHow to audit a multi-agent orchestration: per-agent receipts, handoff evidence, and a verifiable trail across every step of the workflow.
Read the guideThe 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 guideA complete, verifiable history of every tool your agent called. Not a log your agent wrote, a receipt record it cannot rewrite.
Read the guideWhen an agent causes harm, the first question is what it actually did. Verifiable execution receipts as the evidence layer for agent liability.
Read the guideVerifiable receipts for agent swarms: per-agent proof that chains into a swarm-level record. How to audit dozens of agents acting together.
Read the guideWhy replaying an agent run from its own logs proves nothing, and how verifiable receipts make replay checkable by a third party.
Read the guideYou 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 guideAER-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 guideThree categories: verifiable execution receipts, traces and observability, evals. What each one proves, when to use it, and how to start.
Read the guideCall 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 guideWhat a verifiable record of agent actions is actually built from: receipts, hash chains, public anchors.
Read the guideDon't trust the summary. Check the receipt. The practical checklist, ending at the live verifier.
Read the guideOn 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 guideA summary is a claim. A verifiable receipt is proof. What counts as proof, what does not, and the one-minute check.
Read the guideThe 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 guideAn 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 guideWhat verifiable evidence looks like, what to hand an auditor, and how to start collecting it in an afternoon. No jargon.
Read the guideThe definition: one AI agent tool call, recorded so anyone can check the result was not changed. Anatomy, verification, honest scope.
Read the guideWhen 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 guideThe 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 guideAccountability is provable behavior, not legal liability. The 3-part framework: declare, constrain, prove. Verifiable receipts close the loop.
Read the guideNo party can credibly claim "that wasn't me" or "that never happened." The three ingredients behind undeniable agent action records.
Read the guide"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 guideReconstruct 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 guideDon't ask the agent. Ask for its receipts. The one-minute check: recompute the hash, confirm the sequence, confirm the origin.
Read the guideThe 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 guideThe honest comparison: six verification approaches scored on what the record commits to, who can check it, workflow support, and price.
Read the guideWhat 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 guideSet 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 guideA 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 guideWhat 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 guideCheck 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 guideClaude 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 guideOne 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 guideSend the trail, not an argument: the dispute pack turns the whole job into one PDF, including what was not checked.
Read the guideWhat proves your client accepted the AI work, and when: steps checked, the decision, and the date stamp, in one record.
Read the guideOne link where your client can walk the job step by step and check each step's receipt themselves.
Read the guideContinuity that follows you between AIs: context, preferences, and the verifiable record of finished work, checkable by whichever AI you open next.
Read the guideWhat 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 guideThe 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 guideSessions 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 guideOne 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 guideWhat 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 guideReceipts, 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 guideA 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 guideWhat 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 guideThe 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 definitionWhat AER-1 is, how it works, the IETF draft, conformance, implementations, and how to use it today. The definitive page.
What is AER-160-second self-test. Answer honestly about your agent's records. Most builders fail question 2.
Take the testThe six criteria that separate a receipt you can defend in an audit from one you cannot: integrity, chaining, anchoring, verification, conformance, standards status.
Compare formatsNine 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 diveThe receipt handoff: how a verifiable receipt lets you move a running job from one model to another without losing the trail.
Read the essayThe conformance suite, open-source receipt checkers, and the hosted verifier: what each one checks, and the loop that ties them together.
Read the essayAdd 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 essayAn 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 responseA 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 guideThe session is over. Pull the tool calls, mint AER-1 verifiable receipts, verify them, and know exactly what the audit proves.
Read the guideAttach 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 guideThe origin story: an agent said the work was done, nothing could prove it, and the receipt became the fix.
Read the essayHow one builder shipped the execution layer solo, and what the receipt standard cost to get right.
Read the essayThe dev.to essay on the Today view: every call your AIs made, on one page, each step with its receipt.
Read the essayThe Colony announcement: enterprise-grade agent evidence without a closed vendor, on an open draft.
Read the postAn independent team ran the full interop chain against the draft and published the verification on the Colony.
Read the postThe Colony announcement thread for revision 13 of the AER-1 Internet-Draft.
Read the postThe Colony announcement thread for revision 15 of the AER-1 Internet-Draft.
Read the postThe Colony post that opened an AER-1 implementation task to independent builders.
Read the postCompare 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.
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.
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.
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.
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.