AI Agent Observability: LangSmith vs Langfuse (2026)

AI Agent Observability: LangSmith vs Langfuse (2026)

Photo by Luke Chesser on Unsplash

Quick Answer: Langfuse if you want open source, self-hosting, or framework independence; LangSmith if you're deep in the LangChain/LangGraph ecosystem and want the tightest-integrated evals and agent debugging. Langfuse is MIT-licensed, self-hosts for the cost of a VM (Docker + Postgres + ClickHouse), and speaks OTel natively. LangSmith's cloud starts free (5k traces/month), then $39/seat plus usage; its self-hosted option is enterprise-tier only. At high trace volumes, self-hosted Langfuse is typically 5–10x cheaper than either SaaS.

On This Page

• Why Agent Observability Isn't Just APM
• Feature Comparison
• Open Source vs Proprietary
• Pricing at Realistic Volumes
• The LangChain Lock-In Question
• Self-Hosting Langfuse
• The Alternatives in One Paragraph
• Decision Matrix
• Frequently Asked Questions

Why Agent Observability Isn't Just APM

Traditional APM answers "which service is slow and which request threw a 500." Agent observability answers a harder question: why did the model decide that? An agent trace is a tree of LLM calls, tool invocations, retrievals, and routing decisions — each node carrying prompts, completions, token counts, cost, and latency. When an agent burns $4 in tokens looping on a broken tool call, Datadog shows you a healthy HTTP 200. An LLM trace shows you the seventh retry with the same malformed JSON argument.

The workload demands are different too:

• Payloads are huge — full prompts and completions, not status codes. Storage design (hello, ClickHouse) matters.
• Failures are semantic — the trace succeeded, the answer was wrong. That's why observability platforms bundle evals (LLM-as-judge scoring, datasets, regression runs) alongside tracing.
• Iteration is the point — traces feed datasets, datasets feed evals, evals gate prompt changes. The platforms compete on closing that loop, a workflow we map in our agent evaluation pipeline guide.

Feature Comparison

Honest summary: feature parity is ~90% for day-to-day work. LangSmith's edge is polish inside the LangChain universe — stepping through a LangGraph state machine in the trace view is genuinely best-in-class. Langfuse's edge is neutrality: native OTel means your OpenAI Agents SDK, Vercel AI SDK, LiteLLM proxy, or bare fetch calls all land in the same place with no framework commitment.

Open Source vs Proprietary

Langfuse is MIT-licensed at the core, with the whole platform (tracing, evals, prompt management, dashboards) self-hostable free and unlimited. A small set of enterprise features (SCIM, some compliance tooling, managed evaluator extras) sit behind a commercial license or their cloud. The repo sits north of 15k GitHub stars in 2026 and the project has become the default "own your LLM data" choice — the Grafana of the category.

LangSmith is proprietary SaaS first. Self-hosting exists but is gated to Enterprise contracts (Kubernetes deployment, typically five-figures-plus annually). For teams with data-residency requirements and no enterprise budget, that's a hard filter — prompts and completions are exactly the payloads compliance teams refuse to ship to third parties.

"The 2026 pattern is consistent: teams prototype on a SaaS trace viewer, then hit a compliance or invoice wall at scale and migrate to self-hosted OTel-native backends." — LLM infrastructure survey, Q2 2026

Pricing at Realistic Volumes

List prices as of mid-2026 (both vendors tweak regularly — verify before committing):

Worked example — a mid-size agent product doing 1M traces/month, 3 engineers:

• LangSmith: 3 × $39 + ~990k × $0.50/1k ≈ $612/mo at 14-day retention; extended retention on even 10% of traces adds ~$450 more.
• Langfuse Cloud: Pro at $199 + ~900k units overage ≈ $270–300/mo (multi-observation traces consume multiple units — heavy agent traces can 3–5x this).
• Langfuse self-hosted: a 4-vCPU/16 GB VM + ClickHouse storage ≈ $60–120/mo infra, plus your ops time.

The pattern: comparable at hobby scale, Langfuse cheaper in the mid-range, self-hosting dominant at high volume — if you're willing to run ClickHouse.

Photo by Alex Motoc on Unsplash

The LangChain Lock-In Question

LangSmith works fine without LangChain — set LANGSMITH_TRACING=true, wrap functions in @traceable, done. But its gravity is real: the deepest features (LangGraph Studio integration, agent trajectory debugging, one-click eval runs on graph nodes) assume the LangChain stack. If your team builds on LangGraph, that integration alone justifies the bill.

The strategic risk runs the other direction: if you might leave LangChain — for the OpenAI Agents SDK, Pydantic AI, or hand-rolled MCP-based agents — an OTel-native backend keeps instrumentation portable. Traces emitted via OpenTelemetry conventions (now the de facto standard for GenAI spans, with MCP tool-call semantics converging on it through 2025–2026) can be pointed at Langfuse, Phoenix, or even Grafana Tempo by changing an endpoint, not your code.

Rule of thumb: instrument with OTel semantics regardless of which backend you buy. Vendor choice then stays reversible.

Self-Hosting Langfuse

The v3+ architecture has three moving parts: the Next.js web/API container, an async worker, and storage — Postgres (metadata) plus ClickHouse (traces/analytics) plus Redis and S3-compatible blob storage for large payloads.

# Evaluation deployment in ~5 minutes
git clone https://github.com/langfuse/langfuse.git
cd langfuse
docker compose up -d
# Web UI on :3000 — create org, project, API keys

Instrumenting an app (OpenAI drop-in, no framework required):

from langfuse.openai import OpenAI  # drop-in wrapper

client = OpenAI()  # LANGFUSE_PUBLIC_KEY / SECRET_KEY / HOST from env
resp = client.chat.completions.create(
    model="gpt-5.2-mini",
    messages=[{"role": "user", "content": "Summarize this incident report..."}],
    name="incident-summarizer",  # trace name in Langfuse
)

Production notes: run Postgres and ClickHouse on real disks (traces grow fast — budget 1–2 KB per observation compressed), put the web container behind your SSO proxy, and use the Helm chart for K8s. Plan ClickHouse TTLs for retention from day one; deleting a billion rows later is no fun. For the VM itself, our self-hosted AI stack guide covers sizing and backup patterns that apply directly.

The Alternatives in One Paragraph

Phoenix (Arize) — open-source, OTel-native, strongest on eval science and embedding-drift analysis; pairs with Arize AX for enterprise. Helicone — proxy-based one-line setup, excellent for cost tracking and caching at the gateway layer, lighter on deep agent traces. Braintrust — eval-first platform beloved by product teams for CI-style regression gating of prompt changes, with tracing growing around it. W&B Weave, OpenLLMetry/Traceloop, Datadog LLM Observability — viable when you're already paying for the parent platform. None change the headline calculus: Langfuse for open/self-hosted, LangSmith for LangChain-native depth.

Decision Matrix

Related Reads

• Self-Host LLM Break-Even: When Does It Make Financial Sense?
• Prompt Injection Attacks on AI Agents: Defense Guide 2026

Key Takeaways

• Choose Langfuse for open-source flexibility, self-hosting, or framework-agnostic observability (native OTel support); pick LangSmith if deeply embedded in LangChain/LangGraph for tight evals and agent debugging integration.
• Self-hosted Langfuse (MIT-licensed) is 5–10x cheaper at high trace volumes than LangSmith SaaS or its enterprise self-hosted tier, but requires managing Postgres, ClickHouse, and Redis infrastructure.
• Instrument with OpenTelemetry semantics from day one to keep backend options reversible—switching between Langfuse, Phoenix, or other OTel-native platforms later only requires an endpoint change.
• LangSmith’s cloud pricing scales steeply: $39/seat + usage fees (e.g., ~$600/month for 3 engineers and 1M traces), while Langfuse Cloud’s Pro tier ($199/month) or self-hosting (~$60–120/month infra) offers lower mid-to-high-volume costs.
• Agent traces generate 2–10 KB per LLM observation (5–50 observations per trace); plan for 25–500 GB/month at 1M traces—use ClickHouse TTLs and sampling (e.g., 100% errors, 10% successes) to control storage costs.
• LangSmith’s deepest features (LangGraph Studio debugging, trajectory views) assume LangChain; if migrating to OpenAI Agents SDK or custom MCP-based agents, Langfuse’s OTel-native backend avoids lock-in.