AI Agent Evaluation Tools Compared: LangSmith, Langfuse, Phoenix and Potato

Tools for evaluating AI agents come in two kinds. Observability platforms, including LangSmith, Langfuse, Arize Phoenix, Braintrust and Opik, trace an agent in production and let reviewers attach scores to runs and spans. Annotation tools such as Potato start from the human study: several reviewers per trace, labels on each step, and a measure of how well the reviewers agree. The two work together. Keep tracing where you already trace, export the runs you want judged, and run the study in the annotation tool.

An agent trace, or trajectory, records each step an agent took: its reasoning, the tools it called and what they returned. Human evaluation can score the whole run, label each step, or compare two runs side by side. An LLM-as-a-judge scores traces automatically, and needs human labels to be checked against. See How to Evaluate AI Agents.

This page covers agent and LLM evaluation. Annotation Tools Compared covers every data type on one page.

Which agent evaluation tools are worth comparing?

Self-hosting and price, for the tools in our capability matrix:

What each platform does with human scores

LangSmith's annotation queues support rubric feedback keys, a configurable number of reviewers per run, pairwise queues, and reviewers who cannot see each other's feedback.

Langfuse defines scores through score configs and routes traces, observations and sessions to reviewers through annotation queues. In its community forum, users reported in November 2025 that two people still could not annotate the same trace independently in a queue, and the workaround discussed there is a separate score config for each annotator (discussion #4348). Langfuse can compute Cohen's κ between a human score and an LLM-judge score, two series at a time.

Arize Phoenix gives human, LLM and code annotations one structure, with annotation configs that keep labels consistent across reviews. Annotated spans can be exported to a dataset for experiments or for building an evaluator aligned with human judgement.

Braintrust attaches human review scores to logs and experiments. Its documentation notes that hiding a score from some reviewers declutters the review screen and is not an access control, since any reviewer can reveal all scores.

Comet Opik puts traces and threads into annotation queues that can be shared with subject-matter experts by link, in a review screen built for non-technical reviewers.

W&B Weave records human feedback through human annotation scorers, created in the UI or through the API.

We found no statistic for agreement between human reviewers in the annotation documentation of LangSmith, Langfuse, Phoenix, Braintrust or Opik, checked in August and September 2026. Each collects human judgements as scores. Labelbox and Scale AI sell agent-evaluation data as managed services, which is a different purchase: they supply the reviewers too.

Where Potato differs

• Traces from many frameworks. Converters read 15 formats: ReAct, OpenAI, Anthropic, LangChain (which covers LangSmith exports), Langfuse, multi-agent logs from CrewAI, AutoGen and LangGraph, SWE-bench, SWE-Agent, Claude Code, Aider, WebArena, Mind2Web and other browser recordings, MCP, OpenTelemetry and ATIF.
• Labels on each step. The trajectory_eval scheme records whether each step was correct, an error type from a hierarchical taxonomy, a severity, and a running score. The same labels are the training data for process reward models.
• Multi-agent structure. Reviewers edit an interaction graph, mark the critical path, attribute a failure to an agent and a step, and review handoffs. Langfuse's Agent Graphs view renders a multi-agent run as a graph for debugging, but reviewers cannot annotate it. See Evaluating Multi-Agent Systems.
• Agreement between reviewers. Each trace can go to several reviewers who cannot see each other's labels, and inter-annotator agreement is reported. Judge calibration compares an LLM judge with blind human labels. See How to Measure Agreement Between an LLM Judge and Human Annotators.
• Coding and computer-use agents. Unified diffs with syntax highlighting, terminal output, and review comments anchored to lines. Computer-use runs show screenshots with click grounding. See Coding Agent Evaluation and Evaluating Computer-Use Agents.

Moving traces into Potato

Export the runs you want reviewed from your observability tool, then convert them:

python -m potato.trace_converter \
  --input langfuse_traces.json \
  --output data/traces.jsonl \
  --input-format langfuse

LangSmith run exports use --input-format langchain. If a framework is not on the list, --auto-detect picks a converter from the field names.

A step-level review task in Potato

annotation_schemes:
  - annotation_type: trajectory_eval
    name: step_evaluation
    description: "Evaluate each step for correctness and mark any errors."
    steps_key: steps
    error_types:
      - {name: reasoning, subtypes: [logical_error, factual_error, planning_error]}
      - {name: execution, subtypes: [wrong_tool, wrong_args, api_error]}
    severities:
      - {name: minor, weight: -1}
      - {name: major, weight: -5}
    show_score: true

See Annotating Agent Trajectories for how to design the error taxonomy.

What Potato does not do for agents

• It is not a production monitoring service. It has a tracing SDK with OpenTelemetry export, but no hosted cloud and no dashboards built for latency and cost across production traffic. It is self-hosted only.
• It supplies no reviewers. Bring your own, or recruit them on Prolific.

Frequently asked questions

What is the difference between LangSmith and Langfuse for human review?

Both attach human scores to traces and spans through annotation queues. LangSmith is proprietary, can be self-hosted on its Enterprise plan, and supports several reviewers per run and pairwise queues. Langfuse is MIT-licensed and free to self-host, and in its forum users report that two people cannot yet score the same trace independently in a queue. Neither documents an agreement statistic between human reviewers.

Is there an open-source alternative to LangSmith for agent evaluation?

For tracing and scoring, Langfuse (MIT) and Comet Opik (Apache-2.0) are open source and free to self-host. For human evaluation studies, with several reviewers per trace, per-step labels and agreement, Potato is open source and free. Potato reads LangSmith and Langfuse exports, so it can run alongside either.

How do I measure agreement between human reviewers of agent traces?

Give each trace to at least two reviewers who cannot see each other's labels, then compute Cohen's κ for two reviewers or Krippendorff's α for more, per question. Step-level labels need matching by step first. Inter-Annotator Agreement Explained covers the choice of coefficient.

Can I use Potato with traces from LangSmith or Langfuse?

Yes. python -m potato.trace_converter converts LangSmith run exports with --input-format langchain and Langfuse exports with --input-format langfuse. Keep production tracing where it is and bring the traces you want judged into Potato.

Further reading

• Annotation Tools Compared, for every data type on one page
• Potato vs LangSmith and Langfuse for Agent Evaluation
• Text Annotation Tools Compared
• Audio Annotation Tools Compared
• Image Annotation Tools Compared
• Video Annotation Tools Compared
• World Model and Robot Episode Evaluation Tools Compared