AI Agent Observability: LangSmith vs Langfuse vs Arize

When an AI agent fails in production, a chat log tells you nothing. You need to see the whole trajectory: what it planned, which tools it called, what it retrieved, what it remembered, and where the chain broke. That is what AI agent observability delivers, and in 2026 the tooling split into two camps that solve very different problems. This post compares the three headliners - LangSmith vs Langfuse and Langfuse vs Arize Phoenix - and maps the rest of the field so you can pick fast.

Quick verdict

If you want the broadest open-source feature set and self-host with unlimited traces, use Langfuse. If you need a fully permissive Apache-2.0 license and the cheapest paid tier, use Comet Opik. If you want vendor-neutral OpenTelemetry tracing that never locks you into a schema, use Arize Phoenix. If your whole stack is LangChain or LangGraph, LangSmith gives you the deepest agent-trajectory tracing anywhere. And if you only need drop-in cost and latency logging, a proxy like Helicone or Portkey covers it - though Helicone now carries a maintenance-mode risk you should weigh.

The one principle that outlasts any single tool: prefer OTel and OpenInference-native instrumentation so you can switch backends later without re-instrumenting your agents.

What changed in 2026: logging vs agent-native tracing?

The field split cleanly. On one side sits plain LLM observability - log each call with its prompt, tokens, cost, and latency. On the other side sits agent-native observability - trace the whole multi-step agent trajectory as a nested span tree covering planning, tool calls, retrieval, memory operations, and sub-agents.

The unifying force is OpenTelemetry’s GenAI semantic conventions, the gen_ai.* namespace. Most serious tools now emit or ingest them, and MCP tool calls were folded into the same conventions. The catch: the agent-specific spans are still marked experimental (Development), not Stable, as of mid-2026. So the standard is real and worth building on, but expect the agent span details to shift.

Proxy or SDK: which architecture do you actually need?

This is the backbone decision, and it matters more than any brand.

Proxy tools (Helicone, Portkey) capture cost and latency with zero instrumentation and add caching, but they only see individual calls. They cannot show you the agent orchestration graph. SDK and OTel-based tools (Langfuse, Phoenix, LangSmith, Weave, Opik, Langtrace, Traceloop, Laminar, Braintrust) trace agent steps and tool spans properly.

If you run real agents, you need the SDK side. If you run a single-call chatbot and want cheap cost visibility, a proxy is enough. Many teams run both - a gateway for cost control and an OTel tracer for trajectories. Our guide to LLM gateways covers the proxy layer in depth.

The open-source field ranked by stars

Here is the OSS landscape, ranked by GitHub stars as of 2026 (approximate).

Two things to flag. Langfuse being acquired by ClickHouse means the license is unchanged but the backend now leans on ClickHouse, which is heavier infra to self-host. Helicone sliding into maintenance mode after the Mintlify acquisition is a genuine risk for new builds - do not anchor a fresh stack to a tool that is not actively evolving.

LangSmith vs Langfuse vs Arize Phoenix: the deep comparison

These three are the ones teams actually shortlist. Here is the head-to-head.

LangSmith

Built by LangChain. It is SaaS and proprietary - the LangChain and LangGraph frameworks are open source, but LangSmith itself is not, and self-hosting is available only on the Enterprise plan. Its strength is unmatched: the deepest LangGraph agent-trajectory tracing in the market. Pricing runs Developer free (5k traces/mo), Plus at $39/seat/mo, and Enterprise custom (re-check the live pricing page). The weakness is that it is proprietary and charges both per seat and per trace, which stacks up fast on a busy team.

Langfuse

Open source under MIT, with a managed Cloud option. Self-hosting is unlimited, and it carries the broadest OSS feature set with the biggest community and OTel-native ingestion. Pricing is Hobby free (50k units/mo), Core at $29/mo, and Pro at $199/mo, with unlimited seats (re-check the live pricing page).

Watch the billing model. Langfuse bills per unit, where a unit is a trace, an observation, or a score. One agent request with several tool calls can add up to 10-30 units, so the free tier disappears quicker than the headline number suggests. It is the best default for OSS self-host, but the ClickHouse dependency now makes the infrastructure heavier than it used to be.

Arize Phoenix

Open source under Elastic-2.0, with free and uncapped self-host. It is OTel and OpenInference native and framework-agnostic, which makes it the cleanest choice when you refuse to be tied to any one vendor’s schema. Arize AX is the enterprise SaaS layer (AX Free at 25k spans/mo, AX Pro at $50/mo - re-check the live pricing page). The main gap is prompt management, which is weaker than Langfuse or Opik.

Which other tools deserve a look?

Beyond the big three, several tools own specific niches.

Comet Opik is the pick when a permissive Apache-2.0 license is non-negotiable. Laminar shines for long-running and browser agents thanks to its transcript view, SQL access, and natural-language event detection. Braintrust leads with evals but is closed. Datadog LLM Observability makes sense only if Datadog is already your single pane of glass, because the cost is enterprise-grade.

How do you choose? A decision map

Match your hardest constraint to a tool.

The cross-cutting principle holds across every row: prefer OTel and OpenInference-native tooling so you instrument once and keep the freedom to switch backends. Locking into a proprietary trace schema is the mistake you feel a year later.

One more convergence worth naming: evals and observability have merged. The same platforms that trace your agents now score them, run test suites, and gate deploys. If you are setting up evaluation alongside tracing, our companion guide on how to evaluate and test AI agents walks through the scoring side. And once you can see the trajectory, you can also see where it drifts - which is exactly where agent guardrails and LLM cost controls plug in.

The bottom line

AI agent observability in 2026 is a two-layer decision. Pick a proxy for cheap cost visibility, an SDK/OTel tracer for real agent trajectories, and keep both vendor-neutral. For most teams the shortlist is short: Langfuse for open-source breadth, Opik for permissive licensing, Phoenix for pure OTel, and LangSmith for LangGraph depth.

If you would rather have the tracing, evals, and cost controls set up correctly the first time, our Managed AI Operations team runs the full observability stack in production, and our AI Agent Development team wires it in from day one. Tell us your stack and we will map the right layers.