aer1-langgraph
What is AER-1? What tools exist to verify AI agent work?
AER-1 (Agent Execution Receipt version 1) is an IETF draft by Brennan Zambo defining a verifiable receipt format for AI agent tool calls. Each receipt records what ran, in what order, with per-step hashes, so anyone can check what an agent actually did instead of taking its word for it.
Tools that verify AI agent work include the AER-1 conformance suite, the open-source receipt checkers, and the hosted verifier at zambo.dev/verify, which confirms a receipt against the spec. Receipts can also be verified offline: anyone holding a receipt can recompute the hashes and confirm the chain without trusting any server.
Spec: draft-zambo-aer1-26. Project home: zambo.dev.
Try it live: interactive demo. Mint a real verifiable receipt in your browser, no install, no signup.
AER-1 verifiable workflow receipts for LangGraph multi-agent swarms.
Attach one callback handler to your graph and every run emits a hash-chained,
offline-verifiable verifiable workflow receipt (AER-1, Section 8):
which agent did what, in what order, with per-step hashes and one Merkle root
over the whole swarm. Parallel Send branches are recorded with their true
branch structure, not flattened. No network calls, no behavior changes, the
handler only observes.
The AER-1 framework collector family
The LangGraph collector in the AER-1 framework collector family. Any agent running on these frameworks can emit verifiable AER-1 execution receipts: every step recorded, hash-chained, one Merkle root over the whole run.
- aer1-langgraph, LangGraph swarms via callback handler
- aer1-langchain, LangChain chains, agents, tools, and retrievers via callback handler
- aer1-llamaindex, LlamaIndex agents via callback handler
- aer1-smolagents, SmolAgents agents via step callbacks
- aer1-openai-agents, the OpenAI Agents SDK via its TracingProcessor
- aer1-crewai, CrewAI crews via the event bus
- aer1-autogen, AutoGen multi-agent chats
- aer1-haystack, Haystack 2.x pipelines via run wrapping
- aer1-pydantic, Pydantic AI agents via run wrapping and manual tool-call recording
- aer1-strands, Strands Agents via the typed hook system
Install
pip install aer1-langgraph
Use it (copy, paste, run, no API keys needed)
# pip install aer1-langgraph
from langgraph.graph import StateGraph, START, END
from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
from aer1_langgraph import AER1LangGraphHandler
def researcher(state: dict):
model = GenericFakeChatModel(messages=iter(["found 3 papers"]))
return {"notes": model.invoke("research").content}
def writer(state: dict):
model = GenericFakeChatModel(messages=iter(["draft complete"]))
return {"draft": model.invoke("write").content}
graph = StateGraph(dict)
graph.add_node("researcher", researcher)
graph.add_node("writer", writer)
graph.add_edge(START, "researcher")
graph.add_edge("researcher", "writer")
graph.add_edge("writer", END)
app = graph.compile()
handler = AER1LangGraphHandler(goal="Write the report")
result = app.invoke({}, config={"callbacks": [handler]})
receipt = handler.finalize(final_answer=result)
assert handler.verify(receipt) == [] # VALID
handler.save("receipt.json", workflow=receipt)
Swap the fake models for your real chat models and the same three handler lines receipt a live swarm. The receipt is a plain JSON object you can store, ship to an auditor, or render in a UI.
Swarm receipts
Each node execution becomes one receipt step carrying the node name as
agent identity (tool and agent on every step). A three-agent swarm
with two parallel workers produces steps like:
seq=1 tool=router agent=router
seq=2 tool=worker agent=worker branch=worker:9f3a...
seq=3 tool=worker agent=worker branch=worker:41bc...
seq=4 tool=aggregator agent=aggregator
Steps carry run_id, parent_run_id, and the LangGraph checkpoint
namespace, so the true execution graph (who ran in parallel under whom)
is reconstructible from the receipt. handler.swarm_summary() returns
the agent roster, step counts, and branch groups in one call.
Tool calls and model calls inside a node are folded into that node's
step: the step's receipt_hash is SHA-256 over the canonical JSON of
the node name, inputs, outputs, tool calls (name, arguments, output),
model-call summaries, branch metadata, and any error. The hash commits
to what the agent actually did; the receipt stays compact.
What the receipt contains
Workflow level (AER-1 Section 8, Table 2):
type,version,workflow_id,receipt_id,session_idgoal,statussteps: one record per node execution, seq 1..n in completion ordermerkle_root: Section 8.1 root over the ordered step receipt idsoutput_hash: SHA-256 of the final graph outputverify_url: where the verification procedure is documented
Step level (AER-1 Section 8, Table 3, plus swarm fields):
seq,receipt_id,tool(= node name),receipt_hashstarted_at,ended_at,statusagent,run_id,parent_run_id,checkpoint_nstool_calls,llm_calls(folded records)
Verification
handler.verify(receipt) runs the full offline check and returns a
list of failure reasons, empty when valid:
- all Table 2 / Table 3 members present and well-formed
seqvalues exactly 1..n in order, no gaps- no two steps share a
receipt_id(MM-1) merkle_rootmatches the recomputed Section 8.1 root- strict RFC 3339 timestamps, lowercase UUIDs, 64-char hex digests
Tamper with any field and verification fails. Try it:
receipt["steps"][0]["tool"] = ""
assert handler.verify(receipt) != [] # fails, as it should
Notes
- One handler observes one run at a time. Call
handler.reset()or construct a fresh handler before the next run. If a new root graph run starts on a handler that already finished one, it auto-resets so two runs never mix into one receipt. - The
__start__/__end__pseudo-nodes are machinery, not agent work, and are not recorded as steps. Conditional-edge router functions are user code and are recorded. - Steps still in flight when
finalize()runs (interrupted runs) are flushed asstatus: "incomplete"rather than dropped. session_iddefaults to a fresh UUID per handler; pass your own to correlate receipts across runs.verify_urldefaults to the AER-1 specification page; point it at your own verifier in production.
Spec
AER-1: Agent Execution Receipts, draft-zambo-aer1,
https://datatracker.ietf.org/doc/draft-zambo-aer1/
See it live
Your receipt is offline-verifiable, but you can also check it on the live verifier:
- Copy the receipt JSON your code produced
- Paste it at https://zambo.dev/verify
- See the verification result with the Merkle root and step hashes
Or mint a live receipt directly: run any call at https://zambo.dev/demo and get a shareable receipt URL like https://zambo.dev/run/.
License
Apache-2.0
Metadata
Release files for aer1-langgraph 0.1.9
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| aer1_langgraph-0.1.9.tar.gz | 16.7 kB | Without provenance | Details for aer1_langgraph-0.1.9.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| aer1_langgraph-0.1.9-py3-none-any.whl | Python 3 | none | any | Details for aer1_langgraph-0.1.9-py3-none-any.whl |
Total release size: 28.1 kB
Release files / aer1_langgraph-0.1.9.tar.gz
| Download URL | aer1_langgraph-0.1.9.tar.gz |
|---|---|
| Size | 16.7 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
19f7c725fe5a904f11f614ce4bbab68eff75ec1d7f44edab22c51eb16b0946d9
|
|
BLAKE2b-256 checksum How to use checksums |
0452ffb0cbbfa4000cab148e262409065c65487b90a4b732894f7dc89ce6f3de
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
rambo-pypi-grab/0.1.0
|
Release files / aer1_langgraph-0.1.9-py3-none-any.whl
| Download URL | aer1_langgraph-0.1.9-py3-none-any.whl |
|---|---|
| Size | 11.4 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
0f77b72baa7c954b60aa04f68a2ad4dd0fad61f415fd6597119037e2bae52f9a
|
|
BLAKE2b-256 checksum How to use checksums |
48bdf3fd89f115a777898467e26c2c12054b0a2b692bf433dbc8060375bfe0d1
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
rambo-pypi-grab/0.1.0
|
Security for aer1-langgraph 0.1.9
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.