IETF Internet-Draft: draft-zambo-aer1-23 LIVE

Verifiable Execution Receipts
for AI Agents

AER-1 defines a portable receipt format for AI agent tool calls. When an agent does work, it mints a receipt. Anyone can verify the receipt proves the saved result was not changed.

Built by Zambo, the cross-AI execution layer. AER-1 receipts are live in production, powering verifiable agent work today.

Choose your path

Three ways in. Pick the one that sounds like you.

🤖

I build agents

Add verifiable receipts to your agent.

$ pip install aer1-middleware
from fastmcp import FastMCP from aer1_middleware.fastmcp import AER1Middleware mcp = FastMCP("my-agent") mcp.add_middleware(AER1Middleware())
Add receipts →
⌨️

I build languages

Implement AER-1 in your language. Pass the conformance kit and get listed in the official registry.

$ git clone https://gitlab.com/rambozambodotdev/zambo cd zambo python3 aer-1/conformance.py
See the registry → Implementation guide
👀

I'm just curious

Your AI agent does work. AER-1 gives you a receipt that proves what it did. The receipt is hash-chained, so anyone can verify the saved result was not changed.

What is a verifiable receipt? → Verify a receipt →
12
Draft Revision
80
Conformance checks in the live kit
0.2.5
Middleware on PyPI
585
TLC-Verified States
✓ Independent implementations ✓ IETF Internet-Draft ✓ Open source

What is AER-1

Your AI agent does work. AER-1 gives you a receipt that proves what it did.

Each receipt records which tool ran, a hash commitment of what it produced, and a timestamp. Receipts are hash-chained together, so changing any one receipt breaks the chain. Anyone holding a receipt can verify it on their own, no trust in the agent required.

This matters because agents are starting to do real work: moving money, filing tickets, changing data. When something goes wrong, "the agent did it" is not an audit trail. A verifiable receipt is. AER-1 is an IETF Internet-Draft, which means the format is public, documented, and open for anyone to implement.

Honest scope: A receipt proves the saved result was not changed. It does not prove the model was right, and it does not by itself prove an external outcome. AER-1 is about execution integrity, not correctness.

Have a receipt? Verify it →

For Builders

Implement the receipt format in your language. Run your output through the conformance kit. If check() passes, you are conformant. The kit is the test.

For Frameworks

Drop in aer1-middleware to generate receipts automatically from FastMCP, LangChain, or OpenAI Agents. One line of code, every tool call gets a receipt.

Implementations

Reference implementations across multiple languages, plus an independent external build. Each runs the frozen conformance corpus. Pass the vectors, you are conformant.

Rust
45/45 vectors
cargo run --bin conformance
Go
45/45 vectors
go run ./cmd/conformance
TypeScript
45/45 vectors
npm run conformance
Python
45/45 vectors
python3 conformance.py
Java
45/45 vectors
Single-file verifier, JDK runner
C#
45/45 vectors
dotnet run
Swift
45/45 vectors
swift run
Perl
68/68 vectors
Independent external build
external

View the Official Registry → Every implementation, every score, machine-readable.

Middleware

aer1-middleware 0.2.5 is on PyPI. Framework adapters validated end to end against the real SDKs. Generated receipts pass the conformance kit.

$ pip install aer1-middleware

View on PyPI →

FastMCP

from fastmcp import FastMCP
from aer1_middleware.fastmcp import AER1Middleware
mcp = FastMCP("my-agent")
mcp.add_middleware(AER1Middleware())

LangChain

from aer1_middleware.langchain import AER1Callback

# your_tool = any LangChain tool, args = its arguments
your_tool.invoke(args, config={"callbacks": [AER1Callback()]})

OpenAI Agents

from aer1_middleware.openai_agents import with_aer1

@with_aer1
def my_tool(query: str) -> str:
return f"Results for {query}"

What you get

Every tool call mints a verifiable receipt: tool name, output hash, timestamp, chain link. Verify any receipt at zambo.dev/verify/.

Tested against: cryptography 50.0.2, fastmcp 4.0.10, langchain-core 1.6.6, openai-agents 0.23.1, opentelemetry-sdk 1.45.0

Conformance Kit

The kit is the test. If your implementation passes check(), it is conformant. No exceptions, no judgment calls.

What the kit validates

  • Required receipt members and object shape (Section 3)
  • UUID v4 format with RFC variant bits
  • RFC 3339 timestamps with calendar validity
  • SHA-256 output commitments (sha256: + hex)
  • Provenance classes (Section 5)
  • Chain construction and attack resistance (Section 7)
  • Merkle tree construction (Section 8.1)
$ python3 aer-1/conformance.py
CONFORMANCE OK: all vectors behave as expected.

Guides & Deep Dives

Long-form guides on verifiable receipts, AER-1, and checking AI agent work. Written by the draft author, free to read.

Start here

Go deeper

Use AER-1 Today

Zambo is the live production implementation. Add it to your AI client in seconds and every agent run gets verifiable receipts automatically.

https://zambo.dev/mcp

Verifiable receipts on every call. Agents: $0.99 USDC on Base via x402. Humans: $0.99 Day Pass via PayPal. Proof: an AI bought a Day Pass, zero human involved.

Then run any task and verify the receipt here.

Build the Next Implementation

Kotlin, C, and C++ do not have implementations yet. Read Section 3 of the draft, run your output through conformance.py, iterate until check() is clean. That is the whole process.