Metadata-Version: 2.4
Name: aer1-crewai
Version: 0.1.8
Summary: One-line verifiable execution receipts for CrewAI crews. Free, no API key, offline verification, chain-head anchoring to Nostr and Bitcoin.
License: Apache-2.0
Project-URL: Homepage, https://zambo.dev
Project-URL: IETF Draft, https://datatracker.ietf.org/doc/draft-zambo-aer1/
Keywords: aer-1,crewai,ai-agents,ai-agent,verifiable-receipts,verifiable-receipt,execution-receipt,ai-agent-receipt,audit,tracing,audit-trail,agent-audit-trail,agent-accountability,tamper-evident,mcp,zambo
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: crewai>=1.0.0
Provides-Extra: anchor
Requires-Dist: coincurve>=18.0; extra == "anchor"
Requires-Dist: websocket-client>=1.7; extra == "anchor"

# aer1-crewai

## 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](https://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-12](https://www.ietf.org/archive/id/draft-zambo-aer1-12.txt). Project home: [zambo.dev](https://zambo.dev).

**Try it live:** [interactive demo](https://rambozambodotdev.gitlab.io/aer1-hub/try/). Mint a real verifiable receipt in your browser, no install, no signup.


One-line install, no API key, free forever: attach this listener and every [CrewAI](https://github.com/crewAIInc/crewAI) crew run emits a hash-chained, offline-verifiable **verifiable workflow receipt** (AER-1, an IETF Internet-Draft, Section 8). What the crew did, in what order, with per-step hashes and a Merkle root over the whole run. It hooks CrewAI's own event bus, so there is no monkey-patching, no behavior change, and no network calls. The listener only observes. Receipt chain heads can anchor to Nostr and Bitcoin, so anyone can later confirm the record was not changed, without trusting any server.

> For per-tool-call receipts via CrewAI's event bus, see [crewai-aer1](https://pypi.org/project/crewai-aer1/).

## The AER-1 framework collector family

The CrewAI 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-crewai](https://pypi.org/project/aer1-crewai/), CrewAI crews via the event bus
- [aer1-langchain](https://pypi.org/project/aer1-langchain/), LangChain chains, agents, tools, and retrievers via callback handler
- [aer1-llamaindex](https://pypi.org/project/aer1-llamaindex/), LlamaIndex agents via callback handler
- [aer1-smolagents](https://pypi.org/project/aer1-smolagents/), SmolAgents agents via step callbacks
- [aer1-openai-agents](https://pypi.org/project/aer1-openai-agents/), the OpenAI Agents SDK via its TracingProcessor
- [aer1-langgraph](https://pypi.org/project/aer1-langgraph/), LangGraph swarms via callback handler
- [aer1-autogen](https://pypi.org/project/aer1-autogen/), AutoGen multi-agent chats
- [aer1-haystack](https://pypi.org/project/aer1-haystack/), Haystack 2.x pipelines via run wrapping
- [aer1-pydantic](https://pypi.org/project/aer1-pydantic/), Pydantic AI agents via run wrapping and manual tool-call recording
- [aer1-strands](https://pypi.org/project/aer1-strands/), Strands Agents via the typed hook system

See the [AER-1 implementation registry](https://rambozambodotdev.gitlab.io/registry.html) for every implementation.

## Install

```bash
pip install aer1-crewai
```

## Use it (two lines; needs a model key)

CrewAI runs a real crew, so it needs an LLM API key in your
environment (for example `OPENAI_API_KEY`). The listener itself needs
no model configuration.

```python
# pip install aer1-crewai
from aer1_crewai import AER1CrewAIListener
from crewai import Agent, Task, Crew

listener = AER1CrewAIListener(goal="Research AER-1 adoption")  # line 1

researcher = Agent(
    role="Researcher",
    goal="Find the latest AER-1 adoption numbers",
    backstory="You are a diligent research analyst.",
)
writer = Agent(
    role="Writer",
    goal="Turn research into a crisp summary",
    backstory="You write clearly and cite numbers.",
)
crew = Crew(
    agents=[researcher, writer],
    tasks=[
        Task(description="Find the latest AER-1 adoption numbers",
             expected_output="A bullet list of numbers with sources",
             agent=researcher),
        Task(description="Write a 3-sentence summary of the findings",
             expected_output="Three sentences",
             agent=writer),
    ],
)
result = crew.kickoff()
receipt = listener.finalize(final_answer=result.raw)  # line 2
assert listener.verify(receipt) == []  # VALID
listener.save("receipt.json", workflow=receipt)
```

Keep the `listener` referenced for the whole process. Constructing it
registers its handlers on CrewAI's global event bus; dropping the
reference can unregister them.

That is the whole integration. The receipt is a plain JSON object you
can store, ship to an auditor, or render in a UI.

## What gets recorded

One receipt step per observed event, in arrival order:

- `ToolUsageFinishedEvent` becomes a step named for the tool, with the
  tool arguments, output, agent role, and task name hashed in, and
  `started_at` / `ended_at` taken from the event's own timestamps.
- `ToolUsageErrorEvent` becomes the same step with `status: "error"`.
- `TaskCompletedEvent` / `TaskFailedEvent` become `tool: "task"` steps
  carrying the task name and output.

## What the receipt contains

Workflow level (AER-1 Section 8, Table 2):

- `type`, `version`, `workflow_id`, `receipt_id`, `session_id`
- `goal`, `status`
- `steps`: one record per observed event, seq 1..n in order
- `merkle_root`: Section 8.1 root over the ordered step receipt ids
- `output_hash`: SHA-256 of the final answer
- `verify_url`: where the verification procedure is documented

Step level (AER-1 Section 8, Table 3):

- `seq`, `receipt_id`, `tool`, `receipt_hash`, `started_at`, `ended_at`, `status`

Each step `receipt_hash` is SHA-256 over the canonical JSON of what the
step actually did. The hash commits to the content; the receipt stays
compact.

## Verification

`listener.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
- `seq` values exactly 1..n in order, no gaps
- no two steps share a `receipt_id` (MM-1)
- `merkle_root` matches 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:

```python
receipt["steps"][0]["tool"] = ""
assert listener.verify(receipt) != []  # fails, as it should
```

### Separate verification verdicts

For honest reporting, use `verify_receipt_verdicts()` instead of a
single boolean. Each dimension gets its own verdict; they are never
conflated:

```python
from aer1_crewai import verify_receipt_verdicts, verdicts_summary

verdicts = verify_receipt_verdicts(receipt)
print(verdicts_summary(verdicts))
# byte_integrity=pass schema_validity=pass issuer_authenticity=not_checked
# evidence_linkage=not_checked anchor_verification=not_checked
# chain_integrity=pass
```

| Dimension | What it checks | Collector behavior |
|---|---|---|
| `byte_integrity` | Merkle root matches the recomputed root | `pass` / `fail` |
| `schema_validity` | All required fields present and well-formed | `pass` / `fail` |
| `issuer_authenticity` | Cryptographic proof of who issued the receipt | Always `not_checked`; the collector does not verify signatures |
| `evidence_linkage` | Upstream evidence bytes match their digests | Always `not_checked`; the collector does not capture upstream evidence |
| `anchor_verification` | Anchor proof is valid and binds the root | `pass` / `fail` / `not_checked` (no proof provided) |
| `chain_integrity` | `seq` values are 1..n in order, no duplicate receipt ids | `pass` / `fail` |

Verdict values are `pass`, `fail`, `not_checked`, and `unavailable`.
`not_checked` is neither a successful check nor evidence of failure.

### What the commitment covers (and what it does not)

The `merkle_root` commits to the ordered list of step `receipt_id`
values. Each step `receipt_hash` commits to that step's tool name,
arguments, and observations. The `output_hash` commits to the final
answer bytes.

What this does **not** cover:

- The commitment does not prove the bytes are unchanged since issuance.
  An attacker able to replace both bytes and digest creates another
  matching pair. Continuity requires comparing against a digest from
  an independently trusted path (a retained receipt, a verified
  signature with a trusted key, or a separately verified anchor).
- A matching hash does not prove the action ran, the data is true, or
  any external outcome occurred. It proves the supplied bytes agree
  with the supplied digest.
- The receipt records the collector's observations. It does not prove
  provider truth, correct reasoning, authorization, or business success.
- Without an anchor, truncation (deleting steps from the end and
  recomputing the root) is not detectable.

### Construction versions

This package uses these exact constructions (see `CONSTRUCTION_VERSIONS`
in the `verdicts` module):

- Merkle tree: `section-8.1-binary-merkle-v1`
- Step digest: `sha256-canonical-json-v1`
- Output commitment: `sha256-utf8-v1`
- Anchor proof: `aer1-anchor-proof-v1`

## Notes

- One listener observes every crew run in the process. Call `reset()`
  between runs if you want one receipt per run from a shared listener.
- `session_id` defaults to a fresh UUID per listener; pass your own to
  correlate receipts across runs.
- `verify_url` defaults to the AER-1 specification page; point it at
  your own verifier in production.
- If `final_answer` is omitted, `finalize()` uses the output captured
  from the crew kickoff completed event when available.

## 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:

1. Copy the receipt JSON your code produced
2. Paste it at https://zambo.dev/verify
3. 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/<id>.

## License

Apache-2.0
