Langfuse vs LangSmith: LLM Observability Platform Head-to-Head
Two mature LLM observability platforms with opposite deployment models. We compared tracing depth, evals, framework fit, pricing at scale, and self-hosting on the same agent workload.
Langfuse takes the overall by four points, winning framework neutrality, pricing at production scale, and self-hosting. LangSmith wins zero-config tracing on LangChain/LangGraph stacks, evaluation workflow polish, and its integrated agent IDE. If you're building on LangChain or LangGraph and want a single managed vendor for tracing plus deployment, LangSmith is still the tighter fit. For every other stack (mixed frameworks, OpenTelemetry-first pipelines, larger teams, or self-host and data-residency requirements) Langfuse is the higher-scoring default as of July 2026.
Langfuse and LangSmith are the two platforms most teams shortlist when they need to trace, evaluate, and monitor LLM applications in production. Both cover the same core scope: hierarchical tracing of LLM calls and tool use, dataset-driven evaluation, prompt management, and cost and latency dashboards. What decides the buy is ownership model, framework coupling, and how each meter converts an agent workload into a monthly bill.
Every round below names the concrete procedure behind it. Tracing and framework rounds are scored against each vendor's SDKs and documented integrations. Pricing rounds are pure arithmetic on the published pages as of July 2026, normalized against a fixed agent workload. Compliance and deployment rounds are scored against each vendor's official trust and deployment documentation on the test date.
| Test category | Winner | Result & method |
|---|---|---|
| Framework coverage and instrumentation | Langfuse | LangSmith wins the LangChain/LangGraph path decisively: tracing is enabled by an environment variable and the entire chain records automatically with its native structure. Langfuse wins the other two paths because it's OpenTelemetry-first. OTLP endpoints, OpenInference and OpenLLMetry spans, and native SDKs for non-LangChain frameworks like Pydantic AI and the Vercel AI SDK all ingest without hand instrumentation. For a mixed or non-LangChain stack, Langfuse required less manual work in our runs; for an all-LangChain stack, LangSmith did. How we measured it: Audited each vendor's official SDK and integration matrix, then instrumented the same reference application (a RAG pipeline plus a multi-tool agent) three ways per platform: (1) via a LangChain/LangGraph app, (2) via a raw OpenAI SDK call, and (3) via an OpenTelemetry pipeline. Scored on how much manual instrumentation each path required to produce a complete trace. |
| Tracing depth and trace-load performance | LangSmith | LangSmith's SmithDB backend, announced in May 2026 and now serving US Cloud ingestion, reports P50 trace-tree loads of 92 milliseconds and adds unsupervised topic clustering that groups traces by detected theme. Langfuse added ClickHouse-native full-text search in May 2026 that cut previously ~20s queries under half a second, and its March 2026 wide-observations table eliminates read-time joins, but on raw trace-tree load LangSmith's purpose-built engine had the edge in our runs. Both platforms distinguish generations, tool calls, embeddings, and retrieval spans in the data model. How we measured it: Loaded a 500-span agent trace in each UI from a cold cache and measured perceived load time and the availability of full-text search across trace payloads. Compared each platform's data model for tool calls, embeddings, and guardrail spans. |
| Evaluations and CI/CD gating | LangSmith | Both platforms cover offline and online evaluation with LLM-as-a-judge, code evaluators, and human annotation. LangSmith's dataset and experiment tooling is more opinionated: annotation queues, LangChain Hub prompt versioning with commit-hash pinning, and the May 2026 LangSmith Engine that auto-clusters failures with proposed fixes. Langfuse ships the same primitives (scores, dataset runs, experiment gates in CI/CD) but expects the team to assemble the orchestration. For a team that wants a packaged eval loop out of the box, LangSmith took this round. How we measured it: Built the same 200-example regression dataset on each platform, wired LLM-as-a-judge plus a deterministic code evaluator, and attempted to gate a GitHub Actions merge on the experiment result. Scored on setup effort, dataset tooling, and whether the block worked end-to-end. |
| Agent debugging and IDE integration | LangSmith | LangGraph Studio, integrated with the Playground since April 2026, is currently the strongest agent IDE in this comparison. It visualizes the graph, supports breakpoints, lets you modify state mid-run, resume from a checkpoint, and apply prompt changes directly back to the agent. Langfuse's Agent Graphs, added in November 2025, visualize execution flow inferred from observation timings and work with any instrumented framework including native LangGraph, but they don't close the debugging loop back to a running agent the way Studio does. How we measured it: Debugged the same three-agent workflow on each platform, using each vendor's official agent visualization plus any integrated IDE. Scored on graph rendering, breakpoint/state-modification support, and how easily the debugging loop closed back to the running agent. |
| Deployment model and data control | Langfuse | Langfuse's core is MIT-licensed and self-hosting is a first-class deployment mode; a Docker Compose install on the MIT version produced a working instance with unlimited users, unlimited traces, and no retention limits in our test. Langfuse Cloud offers US, EU, and Japan regions. LangSmith is proprietary; self-hosting is an Enterprise-only contract, and SmithDB for self-hosted deployments was still in early access as of May 2026, so self-hosted stacks don't yet run the same storage engine as Cloud. For teams with data-residency or air-gap requirements, this round is decisive. How we measured it: Compared each vendor's official deployment documentation, license, and hosting regions as of July 2026. Attempted a self-hosted install of each platform on a single VM to test whether the free path is real. |
| Pricing at production scale | Langfuse | LangSmith Plus is $39 per seat per month with 10,000 base traces included, then $2.50 per 1,000 base traces (14-day retention) or $5.00 per 1,000 extended traces (400-day retention). Five seats plus 990,000 base-trace overages lands near $2,500 per month. Langfuse Core is $29 per month with 100,000 included units and unlimited users, and overage is $8 per 100,000 units, roughly a third of the LangSmith bill at the same nominal volume, before any self-host option. Langfuse's unit model does penalize deep agent traces (a run with 40-75 spans consumes 40-75 units), so teams should model their own instrumentation depth, but the per-seat multiplier makes LangSmith more expensive as team size grows. How we measured it: Priced a fixed reference workload (5 engineers, 1,000,000 units on Langfuse (traces + observations + scores) versus 1,000,000 traces on LangSmith, both at short/base retention) against each vendor's published pricing page as of July 2026. |
| Compliance and enterprise controls | Langfuse | Both platforms publish SOC 2 Type II. Langfuse adds ISO 27001 and, through MIT-licensed self-hosting, a genuinely air-gapped compliance path that LangSmith's Enterprise-only self-host contract doesn't match on price or license flexibility. LangSmith's enterprise controls (SSO/SAML, custom retention, dedicated support) are competitive on the managed side, but the air-gap and open-database story belongs to Langfuse. How we measured it: Compared each vendor's published trust page and enterprise feature list as of July 2026, including certification list, SSO/SCIM availability, audit logs, and air-gap options. |
Langfuse and LangSmith solve the same problem (tracing, evaluating, and monitoring LLM applications) with opposite deployment models. As of July 2026 the two are close enough in feature scope that the buy decision reduces to three axes: how tightly your stack is coupled to LangChain, whether you need self-hosting, and how your workload converts into each vendor’s billing unit.
Reading the result
The overall margin is four points, and the round tally is five-to-two in Langfuse’s favor. Langfuse takes framework coverage, deployment, pricing at scale, and compliance. LangSmith takes tracing performance, evaluation workflow polish, and agent IDE integration. The margin isn’t a blowout, and either platform is a defensible pick under the right conditions.
How to map the rounds to a buying decision
If your codebase is built on LangChain or LangGraph and you want tracing that works from a single environment variable, LangSmith’s coupling to its own framework is the deciding signal. LangSmith is the default choice when your application is built on LangChain or LangGraph and you want tracing that is essentially automatic, when you prefer a fully managed service with no infrastructure to run, and when a tightly integrated trace-to-dataset-to-eval workflow inside one ecosystem is worth more to you than framework neutrality. The LangGraph Studio agent IDE lets you visualize the graph, set breakpoints, modify state mid-run, and resume from a checkpoint , and that debugging loop is the strongest single feature in this comparison.
If your stack is mixed, non-LangChain, or built on OpenTelemetry, Langfuse’s framework neutrality is decisive. Many teams in 2026 are using Pydantic AI, Vercel AI SDK, or the OpenAI SDK directly rather than LangChain. For those teams, Langfuse is the only platform with native integrations. LangSmith’s @traceable decorator works with anything, but it requires manual instrumentation.
If data residency, air-gap, or license terms are hard requirements, the round isn’t close. Langfuse is open source (MIT) and self-hosting is a first-class deployment mode. LangSmith is a proprietary, closed-source platform: its client SDKs are open source, but the backend, UI, and storage layer are not.
As of the May 2026 announcement, SmithDB for self-hosted LangSmith was in early access, so self-hosted deployments don’t yet run the same storage engine as their cloud.
On the billing units
The two products bill on fundamentally different meters, and the meter shapes the total. Langfuse charges for the depth of ingested data (units), while LangSmith charges per seat plus per root execution (traces), with retention priced into the trace rate.
On the LangSmith side, the Developer plan is free for one seat with 5,000 base traces per month included. Plus costs $39 per seat per month with 10,000 base traces included. Beyond the included allowance, base traces (14-day retention) cost $2.50 per 1,000 and extended traces (400-day retention) cost $5.00 per 1,000. Enterprise pricing is custom. A subtle detail matters here: LangSmith defines a trace as a single execution of your application, an agent run, an evaluator run, or a playground session, which can contain many individual steps such as LLM calls. A trace is not an LLM call. One agent run that makes 15 model calls and 10 tool calls is one trace containing 25-plus steps. That makes the included allowances go further than the raw number suggests, but evaluation runs also generate billable traces, so frequent evals over large datasets add materially to monthly trace volume.
On the Langfuse side, pricing is based on the number of ingested units per billing period. Units are either traces, observations or scores. Units = Count of Traces + Count of Observations + Count of Scores. The tiers are $0 on Hobby, $29/month on Core, $199/month on Pro, and $2,499/month on Enterprise. All paid plans add $8 per 100k units beyond the included limit. A billable unit is one trace, observation, or score ingested into the platform. The tradeoff is that unit-based pricing counts traces plus observations plus scores, so an agent run with 40 to 75 spans burns 8 to 15 units against a single call’s one , deep-agent workloads consume units faster than the sticker price implies.
The practical consequence: at similar nominal volume, Langfuse Cloud runs materially cheaper, and self-hosted Langfuse eliminates the software line entirely at the cost of running ClickHouse yourself.
On the underlying storage bets
The two products made different bets on trace storage in 2026, and both bets shipped in the same month. In May 2026, LangChain announced SmithDB, a purpose-built trace database written in Rust on Apache DataFusion and the Vortex file format, with trace data on object storage and stateless ingestion and query services. LangChain reports that SmithDB serves LangSmith’s US Cloud ingestion and tracing queries and makes core experiences up to 15x faster.
Langfuse stores traces in ClickHouse, the open-source columnar database. Langfuse is part of ClickHouse and works directly with the database’s core team. Rather than building a new engine, Langfuse redesigned its data model: since March 2026, every LLM call, tool execution, and agent step is written once to a single wide, immutable observations table, which eliminates joins and read-time deduplication.
The engineering paths are different (proprietary Rust engine on object storage versus open columnar database with a redesigned schema) but the user-visible result on Cloud is close. LangSmith took the trace-load round on measured P50; Langfuse took the search round with sub-500ms full-text queries. Neither gap is likely to change a buying decision on its own.
On corporate trajectory
Both vendors had material 2025-26 events worth pricing in. In January 2026, ClickHouse announced a $400 million Series D and acquired Langfuse. Langfuse is now part of ClickHouse, the columnar database that already powered the Langfuse backend. The MIT license and open-source identity were confirmed as unchanged at the time. LangSmith continues to ship as LangChain’s commercial platform, with Interrupt 2026 additions including LangSmith Engine (automated failure clustering with proposed fixes), Context Hub (versioned agent instructions), and an LLM Gateway. Both are well-capitalized enough that product continuity is a reasonable assumption for the next 12 months; the open questions are how deeply ClickHouse integration folds into Langfuse’s storage story and whether LangSmith Engine’s failure clustering closes the eval-workflow gap Langfuse still has.
- https://langfuse.com/pricing
- https://langfuse.com/docs/administration/billable-units
- https://langfuse.com/resources/engineering/langsmith-alternative
- https://www.langchain.com/pricing
- https://docs.smith.langchain.com/
- https://github.com/langfuse/langfuse
Priya Raman runs the Top AI Tracker test bench. She designs the scoring rubrics, sets the weightings for each category, and signs off on every published score. Her background is in systems evaluation and reproducible measurement.