LangSmith vs Langfuse in 2026: An Honest Comparison

LangSmith vs Langfuse: The Comparison Table (as of October 2026)

We added Braintrust as a third column because many teams shortlist it alongside the other two.

Sources: LangSmith pricing, Langfuse pricing, Braintrust pricing, plus the docs pages linked in each section below.

Is Langfuse Open Source, and Is LangSmith?

This is the criterion that splits most teams, so be precise about it.

Langfuse. According to Langfuse's open-source page, everything outside the /ee folders is MIT-licensed, and that covers all product features, with no usage limits. The /ee modules ship as source but need a license key: project-level RBAC roles, protected prompt labels, data retention policies, audit logs, server-side data masking, SCIM and similar admin features. If you need those self-hosted, you are buying an Enterprise license.

LangSmith. The LangSmith SDKs are MIT-licensed on GitHub, but the platform is a commercial product. Self-hosted LangSmith is "an add-on to the Enterprise plan," per LangChain's docs.

What changed in 2026. ClickHouse acquired Langfuse (ClickHouse announced it on its own blog too). Langfuse's post says the product stays open source and self-hostable, that Langfuse Cloud keeps running as-is, and that there are no planned licensing changes.

Langfuse already stored traces in ClickHouse, so the technical fit is natural. If vendor stability is on your checklist, note that the acquisition puts a larger company behind the project; it does not, by itself, change your license terms.

Which One Is Easier to Self-Host?

Both self-hosted stacks look strikingly similar: ClickHouse for traces, Postgres for transactional data, Redis or Valkey for queues and caching, and blob storage for large payloads.

The differences are commercial and operational:

• Langfuse documents Docker Compose for local use and testing and Kubernetes (Helm) plus Terraform for AWS, GCP and Azure for production. You can run it on-premises, and its docs say internet access is optional. Cost is your infrastructure plus, optionally, an enterprise license.
• LangSmith self-hosting runs on Kubernetes via Helm or Terraform and requires an Enterprise contract. LangChain also offers a hybrid model: its cloud control plane with your own data plane for agent workloads; trace data stays in your VPC only when you self-host LangSmith.

If you need air-gapped or fully on-prem observability without a sales cycle, Langfuse is the simpler path. If you are already an Enterprise LangChain customer, LangSmith's hybrid model is a reasonable middle ground.

Does LangSmith Only Work With LangChain?

No, and this is the most common misconception in the SERP. LangSmith traces any code with the @traceable decorator (Python) or traceable wrapper (TypeScript), wraps the plain OpenAI client, and lists integrations for Anthropic, OpenAI Agents, Vercel AI SDK, CrewAI, Claude Agent SDK and PydanticAI. It also accepts OpenTelemetry traces from non-LangChain apps through an OTLP endpoint.

That said, the experience is deepest when you are on LangChain or LangGraph: tracing is automatic, Studio is built around LangGraph agents, and deployment through Agent Server is a natural next step. Interestingly, LangChain's docs now describe LangSmith Deployment as framework-agnostic too, with paths for Google ADK, Claude Agent SDK, Strands, CrewAI and AutoGen.

Langfuse starts from the opposite end. Its tracing is built on OpenTelemetry to "reduce vendor lock-in," and it lists 100+ integrations across frameworks, model providers, gateways (such as LiteLLM) and no-code agent builders, including LangChain and LangGraph.

Practical read: if you might change agent frameworks in the next year, instrument with OpenTelemetry regardless of which backend you pick. Both accept it, which keeps your switching cost low.

How Do Evaluations Compare: Datasets, Experiments, LLM-as-Judge and Human Review?

On paper, the two have converged. Both support:

• Datasets of test cases, which you can grow from production traces.
• Experiments that run an app version against a dataset and compare results.
• Offline evaluation before release and online evaluation on live traffic.
• LLM-as-a-judge, code-based checks, and human annotation queues. (Our guide to LLM-as-a-judge covers how to calibrate these judges.)

Where they differ:

If you need pairwise human preference testing, LangSmith has it out of the box. If you want a ready-made CI gate on eval scores, Langfuse's GitHub Action is the more direct route. For a broader map of the field, see the wider field of LLM evaluation tools.

Which Has Better Prompt Management?

Both are solid. LangSmith models prompts like code: each change is a commit with a diff, tags point to commits, and reserved staging and production tags go through a promotion flow with rollback history.

You pull by tag, for example client.pull_prompt("name:production"). It also has a public prompt hub of community prompts (which LangChain flags as unreviewed).

Langfuse versions prompts centrally, uses labels for environments, links prompt versions to traces so you can compare cost, latency and eval scores across versions, and caches prompts client-side in its SDKs so fetching them adds no request latency. Protected labels are an enterprise feature when self-hosting.

Tie, with a slight edge to LangSmith for teams who want git-style promotion and to Langfuse for teams who want prompt metrics tied to traces in the free tier.

How Does Pricing Compare?

The models are different, so compare against your own volume:

• LangSmith charges per seat plus traces. Developer is free for one seat with up to 5k base traces a month; Plus is $39 per seat per month with up to 10k base traces and unlimited seats; Enterprise is custom. Overage is pay-as-you-go. Base traces are retained 14 days; upgrading to extended traces (180 days) costs extra. Agent deployments are metered separately.
• Langfuse Cloud charges per usage unit, not per seat. Hobby is free (50k units, 2 users, 30-day access); Core is $29 a month and Pro $199 a month, each with 100k units and unlimited users, then $8 per 100k units. Pro raises data access to 3 years. A $300/month Teams add-on brings SSO and fine-grained RBAC; Enterprise starts at $2,499 a month. Self-hosting the MIT core costs nothing in license fees.
• Braintrust meters processed data and scores: Starter is free, Pro is $249 a month, Enterprise is custom.

Rule of thumb: large teams with modest trace volume tend to find per-unit pricing (Langfuse) cheaper than per-seat pricing; small teams with heavy trace volume should model both. Retention is often the hidden cost: 14 days of base traces on LangSmith is short if you debug incidents weeks later.

What About Data Residency and Compliance?

Langfuse Cloud offers US, EU and JP regions, plus a HIPAA-ready region on Pro and Enterprise. SOC 2 Type II and ISO 27001 reports are listed on Pro and Enterprise, with a DPA on every plan.

LangSmith SaaS runs in GCP US, EU and APAC regions, plus AWS US (since April 2026), per its cloud docs.

LangChain's docs state SOC 2 Type 2, HIPAA and GDPR compliance and point buyers to its Trust Center and an infosec review in Enterprise procurement. Ask for the reports directly.

For strict data sovereignty, both offer self-hosting in your VPC; only Langfuse offers it without an enterprise contract.

Where Is Each Genuinely Stronger?

LangSmith is stronger when:

• You build on LangChain/LangGraph and want zero-config tracing plus Studio for debugging.
• You want one vendor for tracing, evals, prompt promotion and managed agent deployment.
• You want automated trace analysis (Insights clusters usage patterns and failure modes) and mature alert routing (PagerDuty, Slack, webhook, Dynatrace).

Langfuse is stronger when:

• Open source matters: MIT core, full features self-hosted, fork-friendly.
• You need on-prem or air-gapped deployment without an enterprise deal.
• You run mixed frameworks and want OpenTelemetry-first instrumentation.
• You have many users and want usage-based, not seat-based, pricing and long retention.

Braintrust is worth a look when evaluation-led workflows and experiment comparison are the center of your process and you are comfortable with a hosted control plane.

How Do You Migrate Between LangSmith and Langfuse?

There is no one-click migration either way, but the switching cost is lower than it used to be:

• Instrument with OpenTelemetry. Both backends accept OTLP traces, so an OTel-instrumented app can point at either, or both during a trial.
• Run both in parallel for a week. Compare trace fidelity for your agent's tool calls and nested spans before cutting over.
• Export datasets. Move your eval datasets (inputs and reference outputs) via each tool's SDK; they are the asset that matters most.
• Re-create evaluators, not scores. Judge prompts and code checks port easily; historical scores generally do not.
• Move prompts last. Switch your prompt-fetch calls once the new backend's labels or tags mirror your environments.
• Plan for retention. Archive what you need from the old tool before its retention window drops it.

The Pre-Release Gap Neither Tool Is Built to Close

Both tools are observability and evaluation platforms. Their unit of work is the trace and the dataset: they record what your app did, then score inputs, outputs and trajectories with judges, code and humans.

That is essential, and it is what you want watching production. Our explainer on agent observability goes deeper on that side.

To be fair, both can run evaluations before release. Offline experiments run your app against a dataset, Langfuse's GitHub Action can fail a pull request on a score regression, and both document multi-turn simulation with LLM-simulated users via openevals. So the gap is not "they only work after release."

The gap is narrower and more specific. Neither is designed as a pre-release gate where agents exercise your agent's workflows end-to-end and verify the side effects, meaning what actually changed in files, tool calls and real state, rather than grading the transcript or the trace.

A simulated conversation scored by an LLM judge tells you whether the reply read well. It does not tell you whether the refund was actually issued once, to the right account, or whether the agent called a tool it should never have touched.

That job is what we call Agent Assurance, and TestMu AI delivers it through Rook, a CLI. Based on our product page and docs, Rook:

• Discovers your agent from a repo, PRD or docs, and asks connected MCP servers which tools they actually expose.
• Generates functional, non-functional and adversarial scenarios, with adversarial cases (prompt injection, tool misuse, data exfiltration and more) on by default.
• Runs your agent through an invoke profile you supply (HTTP endpoint or shell command, among others) and observes file changes, artifacts and tool calls.
• Judges each criterion read-only and returns Pass, Fail or Unable to Verify, with quoted evidence. Unverifiable criteria are excluded from the pass rate and reported as a separate figure, the assurance gap, so a high pass rate can't hide low coverage.
• Gates CI through headless commands such as rook run --json and rook report --json, with published recipes for GitHub Actions, Jenkins and Argo CD.

Two honest caveats. Rook is pre-alpha, and the writes it makes during a run are real and not rolled back, so point it at staging. And it is not a replacement for LangSmith or Langfuse; it has no production tracing.

The model we recommend is observe and assure: Rook gates the release, LangSmith or Langfuse watches production, and failing production traces flow back into new pre-release scenarios. (For conversational chat, voice, phone and video agents, our sibling product Agent Testing covers the Human-to-Agent side.) You can read why we built Agent Assurance for the longer argument.

Pick your observability platform with the table above, then request early access to Rook to add the pre-release gate in front of it.

LangSmith vs Langfuse Decision Checklist