Top 6 Agent Observability Platforms (2026): A Developer's Ranking

Most AI observability tools were built for single LLM calls. A prompt goes in, a completion comes out, and the trace is two spans deep. That model breaks the first time you deploy an agent that runs for ten minutes, calls fifteen tools, and decides its own control flow.

Agent observability is a different problem. The trace is 2,000 spans. The failure happens four tool calls deep. You need to know what the agent said, what the user said back, and which sub-step threw, without reading every span in order.

This article ranks the platforms that actually solve that problem in 2026. We rate them on six things: trace depth, agent-specific UX, replay and debugging workflows, OpenTelemetry support, self-hosting options, and pricing model.

1. Laminar. Open-source, OpenTelemetry-native, built specifically for long-running agents. Transcript view, Signals, SQL over traces, browser-agent session replay, agent rollout (debugger). Best pick for anyone running agents in production.
2. Langfuse. Strong open-source option (MIT). Best for prompt-centric workflows, evaluations, and dataset management. Trace model is solid but not agent-first.
3. LangSmith. Tight integration with LangChain and LangGraph. LangGraph Studio is a real advantage if you live in that ecosystem. Closed source. Self-host is Enterprise-only.
4. Arize Phoenix. OpenTelemetry-native, open-source, OpenInference semantic conventions. Good for evaluation-heavy teams already on Arize.
5. Weights & Biases Weave. Fits teams already on W&B. Decent trace view, strong eval harness.
6. Braintrust. Eval-first platform with tracing bolted on. Strong for teams whose primary bottleneck is regression testing.

If you only read one sentence: pick Laminar if you are debugging agents, Langfuse if you are iterating on prompts, LangSmith if you are committed to LangGraph, and Phoenix if your team is already on Arize.

A normal LLM observability tool logs prompts, completions, tokens, and latency. That is enough when your app is a single chain.

Agent observability has to handle four things that break simpler tools:

• Long traces. A research agent can run for 30 minutes and produce thousands of spans across LLM calls, tool calls, sub-agent invocations, and retries.
• Non-deterministic control flow. The agent decides which tool to call next. The trace shape is different every run.
• Nested causality. A failure at span 1,800 might be caused by a bad retrieval at span 42. You need to follow the chain, not just read linearly.
• Session continuity. Agents resume. A single "task" spans multiple process invocations. The trace model has to stitch them together.

Every tool below claims to support this. Some do.

Category: Open-source agent observability and debugging platform. License: Apache 2.0. Deployment: Cloud, self-hosted via Helm chart with hybrid data plane, on-prem Enterprise. Repo: github.com/lmnr-ai/lmnr.

Laminar was built from the start for long-running agents, not retrofitted from an LLM logging tool. Six platform surfaces:

• Transcript view. The default way to read a trace. Not a span tree. You see what the agent said, what the user said, and what each tool call did, rendered as a conversation. The span tree is still there when you want it.
• Signals. Natural-language outcome tracking. You write "agent asked the user for clarification and got a useful answer." Laminar extracts it as a structured event, backfills across history, and fires on every new trace that matches.
• SQL over traces. The query engine sits directly on your trace data. You can answer "how many runs called tool X more than five times" in one query. No dashboard-builder in the way.
• Full-text search over spans. Across millions of spans. Useful when you know a phrase the agent emitted but not which run.
• Realtime tracing. Traces stream in as the agent runs. You do not wait for a 20-minute run to finish to see what went wrong.
• Agent rollout (the debugger). Re-run an agent from any span in a captured trace. Change the prompt, swap the model, edit the tool call. Not replay-as-playback, but rollout-as-iteration.

Span-based, OpenTelemetry-native. Parent-child relationships are preserved through the full agent lifecycle. Browser-agent session replay syncs the agent's DOM state to spans, so you can see what the agent saw when it made a decision.

Native SDKs for Python and TypeScript. Auto-instrumentation for LangChain, LangGraph, CrewAI, AutoGen, Claude Agent SDK, Browser Use, OpenAI Agents SDK, Vercel AI SDK, and raw OpenAI / Anthropic clients. Because it is OTel-native, any OpenInference or OpenLLMetry instrumentation also works.

Data- and agent-step pricing with no seat fees. Free ships 1GB/month and 1,000 agent steps, 15-day retention. Hobby is $30/month (3GB, 5k agent steps, 30-day retention). Pro is $150/month (10GB, 50k agent steps, 90-day retention, unlimited seats and projects). Enterprise is custom with on-prem available. Data-volume pricing stays predictable as agent traces grow, and removing per-seat charges is unusual in this market.

• You only log single LLM calls and do not have nested tool use. Simpler tools will do.
• Your entire workflow is prompt versioning and you do not run agents. Langfuse and LangSmith are more specialized there.

Category: Open-source LLM observability and prompt management. License: MIT. Deployment: Cloud, self-host. Repo: github.com/langfuse/langfuse.

Langfuse has one of the most explicit data models in the space: traces, observations, sessions, scores. Observations are typed (generations, spans, events), which makes complex flows tractable if you structure your instrumentation correctly.

Strengths:

• First-class prompt management with versioning.
• Mature evaluation harness and dataset workflows.
• Full OTLP ingestion endpoint; works as a generic OTel backend.
• Free, MIT-licensed self-host with all core features.
• Agent graph view (beta) for LangGraph-style workflows.

Weaknesses relative to agent debugging:

• Trace UX is built around observations, not agent conversations. Reading a 2,000-span agent run is slower than in Laminar.
• No built-in SQL editor. Analysis is API-first.
• No natural-language signal extraction across history.
• Agent graph view is still beta.

Pricing: Cloud Hobby is free with 50k observations. Core is $29/month. Pro is $199/month. Enterprise is $2,499/month. Usage is counted in billable units (traces + observations + scores), so agents with many small spans can add up fast.

Category: LLM and agent observability from LangChain. License: Closed source. Deployment: Cloud, hybrid, self-hosted (Enterprise only).

If your stack is LangChain or LangGraph, LangSmith will give you the tightest out-of-the-box integration. One environment variable and every run is traced.

Strengths:

• LangGraph Studio. A real agent IDE. Visualize agent graphs, set breakpoints, modify state mid-trajectory, resume from a checkpoint. Nothing else in this list has a comparable purpose-built agent UI.
• LangSmith Deployment. Managed agent infrastructure with checkpointing, memory, and scaling.
• Full OpenTelemetry support (as of March 2026).
• Rich real-time dashboards, alerting, conversation clustering.

Weaknesses:

• Closed source. Self-hosting is an Enterprise-only add-on.
• Seat-based pricing ($39/seat/month on Plus) adds up for larger teams.
• Tightest fit is still LangChain and LangGraph. Teams on other frameworks get less.
• Trace retention tiering (14 days base, 400 days extended) complicates pricing.

Pricing: Developer plan is free with 5k base traces/month. Plus is $39/seat/month. Base traces cost $0.50 per 1k; extended traces (400-day retention) cost $2.50 per 1k.

Category: Open-source LLM tracing and evaluation, built on OpenTelemetry. License: Elastic License 2.0. Deployment: Self-host (pip install), Arize AX managed option.

Phoenix is the open-source side of Arize. It uses OpenInference, a set of OTel semantic conventions for LLMs that is widely adopted.

Strengths:

• OpenTelemetry-native with OpenInference conventions. Instrument once, send anywhere.
• Strong evaluation harness (Phoenix Evals).
• Good for notebook-first workflows; runs locally, spins up in Colab.
• Tight integration with Arize AX if you need production monitoring at enterprise scale.

Weaknesses:

• Trace UX is span-tree-first. Not built around agent conversations.
• Less purpose-built for long-running agents than Laminar.
• Commercial Arize AX has a different cost curve from open-source Phoenix. Plan ahead if you need to graduate.

Pricing: Phoenix open-source is free. Arize AX pricing is custom.

Category: LLM tracing, evaluation, and experiment tracking. License: Closed source. Deployment: Cloud, on-prem for enterprise.

If your ML team is already on W&B, Weave fits in the same console. Trace LLM calls, run evals, compare experiments.

Strengths:

• Native integration with existing W&B workflows.
• Strong eval framework with scorers and comparisons.
• Good for teams that evaluate models and agents on the same platform.

Weaknesses:

• Less agent-first than Laminar or LangSmith. Trace UX is borrowed from ML experiment tracking.
• Weak on realtime trace viewing during long agent runs.
• Closed source.

Pricing: Free tier with limited storage. Paid plans scale with trace volume and seats.

Category: LLM evaluation platform with tracing. License: Closed source. Deployment: Cloud, on-prem for enterprise.

Braintrust is eval-first. Tracing exists to feed the eval loop, not to stand alone.

Strengths:

• Mature experiment harness: structured scorers, comparisons, regression detection.
• Strong for teams whose primary bottleneck is "did our change break behavior X."
• Clean prompt playground that ties into eval sets.

Weaknesses:

• Not a debugger. You will not be faster at finding what broke in production.
• Lighter agent-specific UX.
• Closed source.

Pricing: Free tier available. Pro scales with usage; Enterprise is custom.

Criterion	Winner	Why
Agent-specific UX	Laminar	Transcript view, Signals, agent rollout, browser-agent session replay. Built for this.
LangGraph integration	LangSmith	LangGraph Studio is genuinely the best agent IDE available today.
Open-source self-host	Langfuse / Laminar (tie)	Langfuse is MIT. Laminar is Apache 2.0 with a Helm chart and hybrid data plane. Both free to run.
OpenTelemetry support	Laminar / Phoenix (tie)	Both OTel-native from day one. Phoenix uses OpenInference conventions.
Prompt management	Langfuse	Mature versioning, caching, and team workflows.
Evaluation	Braintrust / Langfuse (tie)	Purpose-built eval harnesses with scorers and comparisons.
Pricing predictability	Laminar	Data-volume pricing tracks actual payload, not trace counts.

Answer these in order. Stop at the first yes.

1. Are you committed to LangGraph and want an agent IDE? → LangSmith.
2. Are you debugging long-running agents in production and need realtime traces, Signals, and rollout? → Laminar.
3. Is your primary pain prompt versioning and evaluation, not agent debugging? → Langfuse (OSS) or Braintrust (commercial).
4. Do you need OpenInference and already run Arize for ML observability? → Phoenix.
5. Is your team already on W&B? → Weave.

Matters if you self-host, run in air-gapped environments, or want to own your data.

Platform	OSS license	Self-host
Laminar	Apache 2.0	Yes, Helm chart, hybrid data plane, on-prem
Langfuse	MIT	Yes, all features
Phoenix	Elastic 2.0	Yes
LangSmith	Closed	Enterprise only
Weave	Closed	On-prem for enterprise
Braintrust	Closed	On-prem for enterprise

Matters if you already have an OTel pipeline or do not want to marry a specific vendor.

• Native OTel from day one: Laminar, Phoenix.
• Full OTLP endpoint: Langfuse, LangSmith (as of March 2026).
• Works via OpenLLMetry / OpenInference: most of the above, with varying fidelity.

If vendor neutrality matters, instrument once with OpenLLMetry or OpenInference and switch backends later without re-instrumenting.

We built Laminar because none of the existing tools solved our own problem: debugging a 30-minute browser agent that failed at minute 18, with no idea which of 2,000 spans to look at first.

The transcript view was the first thing we built. It is the thing most tools still do not have. Signals came next, because the failure mode you care about today is not the one your dashboards captured a month ago. Agent rollout came last, because "replay" is not enough when you want to change a prompt mid-run and see what would have happened.

If you are running agents in production, these three primitives are your day-to-day reality. Other tools can do pieces of this. None put them together in one product. That is the bias, and we think it is the right one.

Start with the free tier: 1GB of traces, 1,000 agent steps, 15-day retention. Instrument one agent. If you do not see the difference in the first hour, come back and tell us why.

Try Laminar free · Read the docs · Star on GitHub

Agent observability is the practice of capturing, inspecting, and debugging the full execution of an AI agent, including every LLM call, tool call, retrieval, and sub-agent invocation. It differs from classical LLM observability because agent runs are long, non-deterministic, and deeply nested. Good agent observability gives you a readable transcript of what the agent did, structured signals for the outcomes that matter, and a way to re-run the agent from any point.

Laminar (Apache 2.0) is the best open-source agent observability platform for long-running agents in production. Langfuse (MIT) is the best pick if prompt management and evaluation are your core workflow rather than agent debugging. Phoenix (Elastic 2.0) is strong for teams already on Arize or using OpenInference.

APM tools like Datadog and New Relic can ingest OpenTelemetry spans, but they are built for service-level metrics, not conversational traces. They do not render agent runs as conversations, do not support natural-language signal extraction over LLM content, and do not support agent rollout. If your agent is more than one LLM call deep, a purpose-built tool saves hours.

LangSmith is the better pick if you are committed to LangChain or LangGraph and want LangGraph Studio. Laminar is the better pick for everyone else: it is open-source, OpenTelemetry-native, framework-agnostic, and built specifically for long-running agents.

Laminar is optimized for agent debugging: transcript view, Signals, SQL over traces, agent rollout, browser-agent session replay. Langfuse is optimized for prompt management and evaluation: versioned prompts, typed observations, a mature eval harness. Both are open-source. Pick Laminar if you are debugging production agents; pick Langfuse if your workflow centers on prompt iteration. See our full Laminar vs Langfuse comparison.

Laminar, Langfuse, LangSmith, and Phoenix all accept OpenTelemetry traces natively or via OTLP. Weave and Braintrust have partial OTel support. If vendor neutrality matters, instrument with OpenLLMetry or OpenInference and you can switch backends without re-instrumenting.

Pricing models vary. Laminar charges by data volume and agent steps with no per-seat fees (Free: 1GB and 1k steps; Hobby: $30/month; Pro: $150/month for 10GB and 50k steps). Langfuse charges by billable units (traces + observations + scores). LangSmith charges per seat plus per trace. For agents with large traces, data-volume pricing is usually the most predictable.

Last updated: April 2026. Verify features and pricing against each vendor's current documentation before committing.