Langfuse vs LangSmith: a hands-on comparison for LLM observability

You ship an agent that works in a demo, then watch it break in production for reasons you can't see. A request touches a retrieval step, three model calls, and two tool invocations, and something returns the wrong answer. The debate over Langfuse vs LangSmith comes down to which platform gives you the clearest view into that execution path so you can find the failing step and fix it. In January 2026, ClickHouse closed a $400 million Series D and acquired Langfuse outright, folding the open-source observability platform into its analytics stack.

This guide compares the two across tracing, evals, prompt management, integrations, self-hosting, and pricing, then shows how the same trace-first thinking applies in a TypeScript agent stack.

What Langfuse and LangSmith are

Before comparing features, it helps to know what each product actually is, since they started from different points and are still shaped by that history.

What is Langfuse?

Langfuse is an open-source LLM engineering platform that combines tracing, prompt management, and evaluation in one workspace. It launched in 2023 as a framework-agnostic alternative to wiring up observability by hand. In January 2026, ClickHouse acquired the company alongside its $400 million Series D. The core platform stayed MIT-licensed and self-hostable, and Langfuse continues to run on ClickHouse's columnar database under the hood.

What is LangSmith?

LangSmith is the observability and evaluation platform built by LangChain Inc., the company behind the LangChain and LangGraph frameworks. It ships as a managed, closed-source product, though its client SDKs are MIT-licensed. As of May 2026, LangSmith's US Cloud tracing runs on SmithDB, a Rust-based data layer LangChain built in-house. Tracing is still deepest when your application runs on LangChain or LangGraph, though neither is required anymore.

Langfuse vs LangSmith: key takeaways

You want the short version before the deep dive, so here it is. Both platforms cover tracing, evaluation, monitoring, and prompt management competently. The real split is philosophical, and it maps cleanly to how your team is structured.

Langfuse is open-source, framework-agnostic, and built on OpenTelemetry from the ground up. It suits teams that mix frameworks, want to self-host, or need full control over their observability data. LangSmith is a managed suite from the LangChain team with polished dashboards, native alerting, and human-in-the-loop review. If your stack is already LangChain and LangGraph, it is the path of least resistance.

The following table summarizes where each platform leads before the detailed breakdown.

Maturity, lineage, and licensing

Your choice depends partly on where each tool came from and how it is licensed. Both launched in 2023, but they built very different communities. Langfuse leaned into open source and now sits at over 23,000 GitHub stars, with reported adoption at 19 of the Fortune 50.

LangSmith and the LangChain stack

You get the most from LangSmith when LangChain is already your foundation. It is the official observability platform for that stack, and tracing for LangChain and LangGraph applications is essentially automatic. The platform itself is proprietary, though the client SDKs are MIT-licensed.

That lineage is a genuine strength and a genuine constraint. Integration is seamless if you are LangChain-native, but both bring-your-own-cloud and self-hosted deployments require an enterprise license. You cannot inspect or modify the platform, which matters to teams with strict control requirements or HIPAA compliance obligations.

Langfuse as an open-source project

You own more of the stack with Langfuse. The core platform is MIT-licensed and self-hostable, with enterprise features under a separate license. It runs on ClickHouse as its analytics backend, which made the January 2026 acquisition a natural fit, and the maintainers have signaled no planned licensing changes.

Open source is the defining trait here. You can run Langfuse on Docker Compose for local development or deploy it on Kubernetes in production. That freedom comes with responsibility: you operate the infrastructure yourself, and the library of pre-built tutorials is still smaller than what LangSmith offers.

For organizations subject to HIPAA or similar data-residency regulations, self-hosting on your own infrastructure can simplify compliance.

What LLM observability means for agents and LLM applications

You can't debug an agent the way you debug a REST endpoint. Traditional monitoring watches HTTP status codes, CPU, and error rates. LLM observability goes deeper, capturing the runtime behavior of model calls, retrieval steps, tool invocations, latency, token usage, and output quality.

A single user request can fan out into a dozen operations, and any one of them can quietly produce a bad result.

Traces, spans, and structured logging

Your first requirement is a trace that mirrors the real shape of a request. A trace captures the full execution tree, and each unit of work inside it becomes a span with inputs, outputs, latency, and token counts. Model calls get specialized treatment because they carry parameters, token usage, and cost that plain function spans do not.

Structured logging turns that tree into something queryable. Instead of scanning flat log lines, you expand a parent span to see exactly which child operation ran, how long it took, and what it returned. That parent-child structure is what lets you pinpoint whether a slow response came from a retrieval step, a reranking call, or the model itself.

Evals, monitoring, and prompt management as the core loop

You need more than traces to keep an application healthy. Observability platforms combine three ongoing practices into one loop. Evaluation measures output quality through automated scoring or human review. Monitoring surfaces cost, latency, and error rates across live traffic. Prompt management versions and deploys prompts without a code change.

These pieces reinforce each other. A trace flags a regression, an eval quantifies how bad it is, and prompt management lets you roll out a fix and confirm it worked. When you compare Langfuse vs LangSmith, you are really comparing how each platform assembles this loop and how much of it works out of the box.

Feature comparison

You care most about how these platforms behave day to day. The choice between them shows up in the details of each capability, so this section walks through tracing, monitoring, evaluation, and prompt management, including how you actually set up and run each one.

Tracing depth and structure

Your traces need to reflect the real execution path, and both tools deliver that with different vocabulary. Langfuse models a trace as a collection of observations. A span is a unit of work like a function call or a retrieval step, a generation is a specialized span for a model call with token counts and cost, and an event is a single point-in-time marker. Langfuse added Agent Graphs in late 2025, which infer a multi-step agent's execution graph directly from span timing and nesting, so you get a visual flow diagram without instrumenting it by hand.

LangSmith uses a run tree model native to the LangChain Expression Language. A parent run might be an entire agent execution, with child runs for tool calls, prompt formatting, model calls, and output parsing. As of May 2026, LangSmith's US Cloud tracing runs on SmithDB, a purpose-built Rust data layer that dropped trace tree load times to roughly 92 milliseconds at the median.

Because Langfuse is built on OTEL natively, it can stitch together distributed traces across microservices and ingest anything that emits OTEL spans, which gives it an edge in flexibility.

Real-time monitoring and alerting

You need to see the big picture, not just individual traces. Langfuse provides real-time analytics dashboards for cost, latency, and quality scores, which you can filter by user, session, or prompt version. A native full-text search feature, added in 2026, cut searches that used to take close to 20 seconds down to under half a second.

Its native alerting is limited, so you subscribe to trace events via webhooks or build custom alerts on the metrics API. Teams running RAG pipelines can track retrieval latency separately from generation latency, which helps isolate bottlenecks.

LangSmith is the more turnkey option here. Every project gets pre-built dashboards for trace counts, error rates, token usage, cost, and tool latency. Native alerting lets you define a condition like more than a five percent error rate over five minutes, then send notifications to Slack, email, or a webhook. There is also an insights view for anomaly detection.

Evaluation workflows, online and offline

Both platforms support offline evaluation against curated datasets and online evaluation attached to live production traces, and both link every score back to the originating trace.

You start LangSmith evaluation with a dataset of inputs paired with expected outputs or success rules. After uploading, you run different prompt versions against the set and see how each change moves performance. Evaluators can be automated model-based judges, custom functions, or human reviewers, and every run links automatically to its prompt version, model configuration, and traces. LangSmith ships richer built-in evaluator types, including exact match and gold-standard comparison, plus annotation queues and few-shot correction, where human-labeled fixes feed back into the evaluator's own calibration.

Langfuse gives you several evaluation paths: prompt experiments, LLM-as-a-judge, and manual annotation. Managed evaluators ship with tuned prompts for common metrics like hallucination and toxicity, while custom evaluators let you pick the model and set the parameters yourself. In 2026, Langfuse added Code Evaluators, letting you write a Python or TypeScript function directly in the UI for deterministic checks like schema or regex validation, with no judge-model call and no token cost. Pairing that with Langfuse's GitHub Actions integration turns evaluation into a deploy gate: a workflow fails automatically if experiment scores drop below a threshold, instead of surfacing the regression after it ships.

Prompt management and playground tooling

Both tools treat prompts as version-controlled assets you edit, test, and deploy from a UI, separate from your application code, so you can change a prompt without a deployment.

You create a LangSmith prompt in its UI or SDK, built on LangChain's ChatPromptTemplate, and test it in a playground with a model-based assistant for revising instructions. Saving commits a SHA-based version, which you tag with labels like “prod” or “beta.” From the SDK, calls like client.push_prompt() and client.pull_prompt() fit cleanly into CI/CD pipelines. The Prompt Hub doubles as a community library that Langfuse does not replicate.

Langfuse's console mirrors that workflow: open the prompts area, create a prompt, and test it in a playground with model settings, tags, and side-by-side output comparison. Versioning uses plain integers instead of commit hashes. From the SDK, create_prompt uploads a template and can immediately label a version as “production,” while get_prompt fetches the live version and compiles it with your variables at runtime, caching locally after the first fetch to avoid adding latency. Langfuse offers deeper standalone prompt management for multi-framework stacks, while LangSmith wins on fast, eval-linked iteration for LangChain teams.

Integration capabilities and SDK support

You want observability that fits your stack rather than dictating it. This is where the framework-agnostic versus native split becomes concrete, and where it matters most if you're building outside LangChain and LangGraph entirely.

Framework and SDK breadth

LangSmith's native SDKs cover Python, TypeScript, Go, and Java. Beyond LangChain and LangGraph, it integrates with AutoGen, CrewAI, and Semantic Kernel, and for anything else you wrap functions with a @traceable decorator.

Langfuse is framework-agnostic by design. It ships native integrations for LangChain, LangGraph, LlamaIndex, AutoGen, Haystack, and Semantic Kernel, plus thin wrappers for the raw OpenAI and Anthropic SDKs. That neutrality makes it a natural pick when your stack spans several frameworks and you want to avoid vendor lock-in. Its MCP server expanded in 2026 to cover 15 tool categories, so an agent running inside Claude Code, Cursor, or a similar MCP client can query Langfuse's own data programmatically.

OpenTelemetry and self-hosting

LangSmith is no longer LangChain-only for tracing. It now supports OpenTelemetry through the langsmith[otel] package, enabled with the LANGSMITH_OTEL_ENABLED environment variable, so teams outside the LangChain ecosystem can send traces without the @traceable decorator. Its deepest, zero-configuration tracing still concentrates in LangGraph.

Self-hosting is the sharper contrast. Langfuse is self-hostable for free, running on Docker or Kubernetes with ClickHouse behind it. LangSmith requires an enterprise license for both self-hosted and bring-your-own-cloud deployments, and its SmithDB backend for self-hosted customers was still in early access as of mid-2026. If data residency, HIPAA compliance, or full infrastructure control is a hard requirement, that difference likely settles the decision.

Where Mastra fits for TypeScript agent observability

You can treat observability as a bolt-on, or you can build it into the framework from the start. Mastra is an open-source TypeScript framework for AI agents, built on Vercel's AI SDK and extended with workflows, evals, and observability.

Every agent run produces a trace: a tree of spans showing which model ran, what tokens flowed in and out, how long each step took, and where a failure occurred. You inspect these traces in Studio during local development, then export them to Langfuse, LangSmith, or another OTEL-compatible platform in production.

The eval system runs LLM-as-a-judge scoring alongside that same tracing pipeline, and model routing reaches 90+ providers through one interface. Mastra is a younger project with a smaller community than either platform here, and it is not the right fit for Python-first teams.

Build your first traced agent with Mastra.

From experiments to production applications

You feel the real difference between these tools when you move from prototype to production. In early experiments, either platform gets you tracing and a playground within an afternoon. The pressure arrives later, when you are running thousands of requests a day and need to catch drift before it reaches users.

At that stage, LangSmith's native alerting and pre-built dashboards reduce the setup you carry, which suits teams that want a self-contained monitoring loop. Whether you frame it as LangSmith vs Langfuse or the other way around, the choice depends on how much infrastructure you want to own.

Langfuse rewards teams willing to assemble a bit more, giving you open data, OTEL portability, and no licensing ceiling as volume grows. Either way, instrument early rather than retrofitting observability after something breaks.

Pricing: Langfuse vs LangSmith

You should map pricing to how your team scales, because the two models diverge quickly. Langfuse is usage-based on its cloud tiers and free to self-host with unlimited usage. LangSmith is seat-based plus trace-based, which rewards small teams and gets more expensive as headcount and evaluation volume grow.

The table below lays out the published tiers so you can estimate your own costs.

One billing detail is easy to miss. LangSmith traces start on a 14-day base retention, but that automatically upgrades to 400-day extended retention the moment a trace receives feedback, triggers a run rule, or enters an annotation queue, which quietly raises the bill on any workflow that evaluates production traffic. On the Langfuse side, self-hosting economics have their own caveat: a medium-scale deployment can run several thousand dollars a month in infrastructure, which can exceed the equivalent managed cloud tier at mid-market scale. Free to self-host does not always mean cheapest to operate.

When to use which

You do not need a universal winner here, you need the one that fits your stack and your operating model. Both platforms are strong, and either will serve you well if matched to the right situation. The decision usually comes down to two questions: how committed are you to LangChain, and how much do you value open source and self-hosting?

Choose LangSmith if you build primarily with LangChain and LangGraph and want native alerting, polished dashboards, and human-in-the-loop annotation queues without extra setup. The Monte Carlo engineering team, which runs a production system with hundreds of sub-agents on LangGraph, has cited zero-setup tracing as the reason it standardized on LangSmith rather than assembling OpenTelemetry instrumentation by hand.

Choose Langfuse if your team is framework-agnostic, prefers usage-based pricing, or needs self-hosted observability with no licensing restrictions on the core platform. Data residency requirements and existing ClickHouse infrastructure both point toward Langfuse.

Wrapping up

Langfuse and LangSmith solve the same problem from opposite ends: one prioritizes open, portable, self-hosted observability, the other prioritizes a polished, managed experience wired deep into LangChain and LangGraph. Match the tool to your framework commitment and your appetite for running infrastructure, and if you're building the agent framework itself rather than the observability layer around it, Mastra folds tracing into the runtime instead of bolting it on afterward.