The short answer
Tools for verifying AI agent work fall into three kinds. Tracing tools record what the agent did while it ran, for the team that ran it: the pick here is Langfuse, free to self-host, with LangSmith close behind for LangChain teams. Evaluation tools score whether the output was any good: the pick is Promptfoo, free and local. Receipt systems save a record at execution that anyone can check afterwards, with no account: the pick is Zambo. If the only person who ever needs to believe the work is you, a tracing tool is enough. The moment a client, an auditor, or a second AI has to believe it, the record has to live outside your dashboard, and that is the difference this page scores. The step-by-step method behind the receipt score is verify an AI agent's run history: recompute the record, do not reread the summary.
Why this question is harder than it looks
Every tool on this page uses the word verify, and they mean different things by it. A tracing tool verifies work the way a flight recorder verifies a flight: it shows the operator what happened, in detail, inside the operator's own systems. An evaluation tool verifies work the way an exam verifies a student: it scores outputs against tests and thresholds. A receipt system verifies work the way a receipt verifies a purchase: a fixed record, saved when the thing happened, that the other party can check without the seller's permission.
Confusing the three is how teams end up well instrumented and still unable to prove anything: every record sits inside an account the client does not have, in a system the operator can edit.
The receipt test: five questions
Every tool is scored on the same five questions. They are the questions a client, an auditor, or a second AI would ask of any record you hand them.
- Captured at execution? The record was written when the work ran, not reconstructed afterwards from logs or screenshots.
- Checkable by a stranger? Someone with no account and no relationship to you can run the check and get a verdict.
- Portable? The record lives outside the vendor's dashboard, as a link or a file that keeps working if you cancel the subscription.
- Offline recompute? The check can be rerun locally, from an open format, without calling the vendor's servers.
- Acceptance recorded? When the client accepts or flags the work, that decision lands on the record itself, not in a separate email thread.
| Tool | At execution | Stranger check | Portable | Offline recompute | Acceptance recorded |
|---|---|---|---|---|---|
| Zambo | Yes | Yes | Yes | Yes | Yes |
| Langfuse | Yes | No | Partly | No | No |
| LangSmith | Yes | No | Partly | No | No |
| AgentOps | Yes | No | Partly | No | No |
| Arize Phoenix | Yes | No | Partly | No | No |
| W&B Weave | Yes | Partly | Partly | No | No |
| Braintrust | Yes | No | Partly | No | No |
| Promptfoo | No | Partly | Yes | Yes | No |
| DeepEval | No | Partly | Yes | Yes | No |
| OpenTelemetry | Yes | No | Yes | No | No |
Read the table by job, not by winner. Tracing tools sweep the first column and lose the rest because their records are built for the operator. Evaluation tools fail the first column because they test work rather than witness it. The receipt row is the only one built around the last four columns, and the sections below say what each tool is genuinely best at.
The ten tools, scored
1. Zambo: the receipt system
Zambo, the verifiable work layer for AI, runs the work itself: 153 tools behind one MCP endpoint at zambo.dev/mcp, usable by any AI client that speaks MCP. Every call saves its result at execution and mints a verifiable AER-1 receipt carrying the inputs, the saved result, the time, and a digest over that result. Multi-step jobs close as a workflow whose root binds the step receipts; a handover packages a job for a client whose Accept or Flag decision is recorded on the record. The receipt format is an open draft, currently draft-zambo-aer1-24, with a public conformance kit, so the check does not depend on Zambo staying in business or staying honest: the open-source aer1-verify tool recomputes the digest locally. Best for: proving a finished job to a client, an auditor, or another AI. Not ideal if: you want span-level debugging of your own runs; pair it with a tracing tool. Price: free daily allowance on the endpoint, Day Pass $0.99 for 24 hours, Pass $29 a month. Checking a receipt is always free.
2. Langfuse: open-source tracing and evaluation
Langfuse records traces, prompts, and scores for LLM applications, and its core is MIT-licensed open source, which makes it the tracing tool a team can fully own. It self-hosts for free, and the hosted cloud starts with a free Hobby tier covering 50,000 units a month; Core is $29 a month. Since January 2026 it has been part of ClickHouse, with the project staying open source. Its records live in your Langfuse instance: checking them means access to that instance. Best for: teams that want tracing, prompt management, and evaluation in one self-hostable stack with no per-seat pricing. Not ideal if: the person checking the work is outside your team. Price: free self-hosted; cloud Core $29 a month.
3. LangSmith: the deepest tracing and evaluation loop
LangSmith is LangChain's platform for tracing, evaluating, and monitoring LLM applications, and for teams building on LangChain or LangGraph it is the most complete loop on this page: step-level traces, datasets, annotation queues, and online evaluators. The Developer tier is free for one seat with 5,000 base traces a month; Plus is $39 per seat per month. The records live in LangSmith workspaces, so the audience for a LangSmith trace is whoever holds a seat. Best for: LangChain and LangGraph teams debugging complex agents and running continuous evaluation. Not ideal if: your stack is framework-neutral, or your checker is a client rather than a colleague. Price: free Developer tier; Plus $39 per seat per month.
4. AgentOps: agent-first observability and replay
AgentOps was built specifically for agents: it records sessions across frameworks such as CrewAI, AutoGen, and LangChain, and its signature feature is replay, stepping back through a session to watch where a run went wrong, alongside cost tracking per run. The Basic tier is free up to 5,000 events; Pro starts at $40 a month. Sessions live in the AgentOps dashboard, which keeps the record an operator's tool. Best for: watching multi-agent runs back and finding the step where behaviour diverged. Not ideal if: you need a record a client can check without your dashboard. Price: free Basic tier; Pro from $40 a month.
5. Arize Phoenix: OpenTelemetry-native analysis
Phoenix is Arize's open-source observability and evaluation tool, built on OpenTelemetry and the OpenInference conventions, so traces arrive in an open format rather than a proprietary one. It is source-available under the Elastic License 2.0 and free to self-host with no feature gates, which makes it a favourite for notebook-driven analysis of retrieval and agent behaviour. The hosted Arize AX platform adds a free tier at 25,000 spans a month and Pro at $50 a month. The records are yours in a way dashboard-only tools do not match, but they are still telemetry for your team, not records addressed to a checker. Best for: OpenTelemetry shops and data-science-style debugging of RAG and agent runs. Not ideal if: you need to hand proof to someone outside the team. Price: free to self-host; AX Pro $50 a month.
6. Weights & Biases Weave: tracing inside the experiment platform
Weave brings tracing and evaluation into Weights & Biases, the experiment-tracking platform many ML teams already run, so an agent's calls sit next to the models and datasets that produced them, with lineage from experiment to production trace. It has a free tier, and paid plans run from roughly $50 per user per month. W&B reports can be shared by link, which earns Weave the only Partly in the stranger column among the dashboards, but a shared report is a view of the operator's data, not an independently checkable record. Best for: teams already on W&B who want agent traces in the same place as training and evaluation. Not ideal if: you are not in that ecosystem. Price: free tier; paid from about $50 per user per month.
7. Braintrust: evaluation-first release gating
Braintrust treats evaluation as the centre of the workflow: datasets, scorers, and experiments that gate releases, with production traces flowing back into datasets. It is the strongest pure evaluation platform here for teams shipping LLM features. The Starter tier is free with 1 GB of processed data and 10,000 scores a month; Pro is $249 a month. Its records are experiments and logs inside your Braintrust organisation. Best for: product teams who need scoring discipline and CI gating before an AI feature ships. Not ideal if: the budget is small, or the record has to convince an outsider. Price: free Starter tier; Pro $249 a month.
8. Promptfoo: free local evaluation and red teaming
Promptfoo is an open-source, MIT-licensed command-line tool for evaluating and red-teaming LLM applications. It runs test suites locally and in CI, compares prompts and models side by side, and probes for security failures, with results stored as files you own. It is free, and in March 2026 it became part of OpenAI, with the tool remaining open source. Because it is a testing tool, it witnesses nothing about production work: it reports how a system performs on tests you wrote, not what a specific run did last Tuesday. Best for: pre-release evaluation and red teaming at zero cost. Not ideal if: you need records of real runs after release. Price: free and open source; Enterprise pricing is custom.
9. DeepEval: pytest-style metrics for Python teams
DeepEval is an open-source, Apache-2.0 evaluation framework that makes LLM testing look like unit testing: more than 50 research-backed metrics, from faithfulness to hallucination, asserted in a pytest-style suite that can fail a build. The framework is free to run locally; the hosted Confident AI platform adds dashboards, dataset management, and monitoring on paid plans after a free tier. Like Promptfoo, it scores outputs against expectations rather than witnessing production runs, so its records are test results: portable, rerunnable, and exactly as strong as the tests behind them. Best for: Python teams who want metric-driven quality gates in their existing test workflow. Not ideal if: you need proof of what a production agent did. Price: free and open source; hosted platform paid.
10. OpenTelemetry: the open standard underneath
OpenTelemetry is not a product but the vendor-neutral standard for traces, logs, and metrics that most tools on this page ingest, with semantic conventions for generative AI still maturing toward stability. Instrumenting with it makes telemetry portable between backends, from Langfuse and Phoenix to Grafana and Datadog. Two honest limits follow. It records nothing by itself: a backend has to collect the spans. And a span is telemetry in your own pipeline, with no digest a stranger can recompute and no acceptance state. Best for: keeping observability portable and avoiding lock-in at the instrumentation layer. Not ideal if: you expect it to prove work to anyone; pair it with a backend for analysis and a receipt system for proof. Price: free, open standard.
Side by side
| Tool | Category | What it records | Who can check it | Free entry | Starting price |
|---|---|---|---|---|---|
| Zambo | Receipts | Per-call record with digest; workflow roots; client acceptance on handovers | Anyone with the link, no account | Free daily allowance; verifying is free | Day Pass $0.99; Pass $29/mo |
| Langfuse | Tracing + evaluation | Traces, prompts, scores in your instance | Anyone you give instance access | Self-host free; Hobby cloud free | Core $29/mo |
| LangSmith | Tracing + evaluation | Step-level traces, datasets, evaluator scores | Workspace seat holders | Developer tier free, 5,000 traces/mo | Plus $39/seat/mo |
| AgentOps | Agent observability | Session recordings, events, cost per run | Dashboard account holders | Basic free, 5,000 events | Pro from $40/mo |
| Arize Phoenix | Tracing + evaluation | OpenTelemetry spans and evaluation results | Whoever can reach your deployment | Free to self-host | AX Pro $50/mo |
| W&B Weave | Tracing + evaluation | Calls, traces, evaluations with experiment lineage | W&B users; reports shareable by link | Free tier | About $50/user/mo |
| Braintrust | Evaluation | Experiments, scorer results, production logs | Organisation members | Starter free, 10,000 scores/mo | Pro $249/mo |
| Promptfoo | Evaluation + red teaming | Test runs and probe results as local files | Anyone you hand the files to; anyone can rerun | Free, open source | Free; Enterprise custom |
| DeepEval | Evaluation | Metric scores from test suites; hosted runs in Confident AI | Anyone you hand results to; anyone can rerun | Free, open source | Free; hosted platform paid |
| OpenTelemetry | Standard | Spans, logs, metrics in an open format, collected by your backend | Whoever runs your backend | Free, open standard | Free; backend costs vary |
A notable omission, on purpose: Helicone was a popular LLM logging proxy, but since its acquisition by Mintlify in March 2026 it has been in maintenance mode. For a new setup, pick a tool with a future.
Which tool for which job
| Job | Pick | Why |
|---|---|---|
| Prove one job to a client | Zambo receipt and handover | The client checks the record themselves, and their acceptance is recorded on it |
| Debug a failed run | Langfuse, LangSmith, or Phoenix tracing | Step-level spans show which call slowed, cost, or broke |
| Score output quality | Promptfoo or DeepEval in CI; Braintrust hosted | Metrics and scorers turn quality into a gate, not an opinion |
| Prepare records for an auditor | Zambo receipts | The auditor gets links and recomputes digests instead of needing your logins |
| Check work across two AIs | Zambo | One endpoint and one receipt format, whichever AI ran the call, so the checking procedure never changes |
| Verify before payment | Zambo handover with client Accept | Payment follows the accepted state on the record, not a claim in a message |
Worked evidence: check a real job yourself
Claims about checkability should be checkable. On October 15, 2026, two live_price calls ran under one session and the job was closed as a workflow. Step 1, receipt 5eec3b86-9a88-45fc-8581-ad0685f7ff2b, recorded BTC $82,356.00 USD at 22:03:37 UTC. Step 2, receipt d79f7426-7f69-49b0-8dc9-00455db27725, recorded ETH $2,459.51 USD at 22:03:39 UTC. The closing workflow record binds the two steps under one root, which has been recomputed independently from the two step receipt ids alone, using the construction in Section 8.1 of the AER-1 draft, and matched the served root exactly. Run the five checks a reader can run on any receipt:
- Open the link. The receipt page loads with no account and shows the saved result and the time it ran.
- Run the verifier. Put the receipt id into zambo.dev/verify; the check recomputes the digest over the saved result and reports whether the record matches what was saved at execution.
- Recompute the set. For a multi-step job, recompute the closing root from the step receipt ids. Adding, dropping, reordering, or swapping a step changes the root.
- Recompute offline. The open-source aer1-verify tool runs the same digest check locally against the open format, with no call to Zambo's servers.
- Read the decision. On a handover, the record itself carries the client's decision. This handover sits in the accepted state, recorded when the client accepted it, next to the steps it covers.
What the check establishes is narrow and exact: the saved result is the result that was saved when the call ran, unchanged since. It does not claim the answer was right. Judging rightness is the evaluation tools' job, which is why this page scores them as complements rather than rivals. The fuller anatomy of a record like this lives in the AI agent audit trail, piece by piece, and the audit procedure for a whole workflow is in the agentic workflow audit guide.
How to verify any tool's claim, in four moves
Whatever tool you pick from this page, including the one this site publishes, run these four moves on its records before you rely on them.
- Ask who can check it. If the honest answer is anyone with a login to our dashboard, the record serves the operator, and the checker needs permission from the party being checked.
- Ask when it was written. A record reconstructed after the fact can be edited before anyone sees it; a record saved at execution cannot be quietly backfilled into a better story.
- Recompute something yourself. Take one record and run the check with your own hands. Prefer a check you can run offline from an open format, like aer1-verify does for AER-1 receipts, over a verdict only the vendor's server can give.
- Ask where acceptance lives. If the client's yes sits in an email while the record sits in a dashboard, the two will drift apart under dispute. Acceptance recorded on the record itself, as on a handover, keeps the decision and the evidence in one place. The step-by-step checking loop is set out in how to verify an AER-1 receipt.
Frequently asked questions
What tools exist to verify AI agent work?
Three kinds. Tracing tools record what an agent did while it ran: Langfuse, LangSmith, AgentOps, Arize Phoenix, and Weights and Biases Weave are the established names, and OpenTelemetry is the open standard many of them ingest. Evaluation tools score output quality before and after release: Promptfoo, DeepEval, and Braintrust. Receipt systems save a record at execution that anyone can check afterwards: Zambo is the one built around that job, and every call run through it leaves a verifiable AER-1 receipt. Most teams end up with one from the first two kinds for themselves, and receipts for the people who have to trust the work from the outside.
What is the best free tool to verify AI agent work?
It depends on the job. For testing prompts and models before release, Promptfoo is free, open source, and runs locally. For tracing your own runs, Arize Phoenix and Langfuse both self-host for free. For proof a client can check, Zambo's public verifier is free with no account, and work run through the Zambo MCP leaves receipts from the free allowance that comes with the endpoint.
What is the difference between a trace and a receipt?
A trace is the operator's own recording: spans and logs written into a dashboard the operator controls, visible to people the operator gives access to. It is excellent for debugging and proves nothing to an outsider, because the operator could edit or delete it. A receipt is a record saved at execution with a digest over the saved result, published at a link anyone can open. Anyone can recompute the digest and confirm the record matches what was saved when the work ran.
Can a client check my AI agent's work without an account?
With a tracing or evaluation dashboard, generally no: the record lives inside your account, and checking it means being given access to your workspace. With a receipt, yes: the check is a public page. The client opens the receipt link, the verifier recomputes the digest over the saved result, and the page reports whether the record is exactly what was saved at execution. No account, no dashboard, no screenshots.
What should I look for when choosing a tool to verify AI agent work?
Run the receipt test on it. Was the record captured at execution, or can it be reconstructed later? Can a stranger check it without an account? Does the record live outside the vendor's dashboard, as a link or a file you control? Can anyone recompute the check offline, from an open format? And is the client's acceptance recorded on the record itself? Tracing and evaluation tools score well on depth and analysis. Receipt systems score well on the five questions, because the five questions are what they are for. The format those receipts follow is the AER-1 receipt standard, one shared format any implementation can emit and any verifier can check.
Do I need both a tracing tool and a receipt system?
Often, yes, because they answer different questions. A tracing tool answers your questions about your own runs: where the agent slowed down, what it spent, which step failed. A receipt answers someone else's question about one finished job: is this the work that actually ran, unchanged? Teams that serve clients usually trace for themselves and hand over receipts, the same way a builder keeps a work diary and still gives the customer an invoice.