Langfuse vs LangSmith: the real split, and what all three still miss

You are picking the stack that will watch your agent in production, and the shortlist has settled to three names: Langfuse, LangSmith, and Braintrust. Every comparison you have read agrees on the surface. Three capable trace viewers, three eval runners, three dataset stores. The line that forks the decision is a single line in a license file, and it is the one your finance and security teams will ask about in month three: can we run this ourselves, and who holds the trace data?

Choose Langfuse when you want an open-source, self-hostable default: its core is MIT-licensed and stayed that way after ClickHouse acquired it in January 2026.¹ Choose LangSmith when your agent already lives in LangChain or LangGraph and you want a managed platform wired natively into both. Choose Braintrust when evaluation is your center of gravity and you will pay for the tightest dataset-scorer-experiment loop. All three record scores and run LLM judges. None of them ships the test that tells you whether a pass rate moved for real (a confidence interval on the rate, a paired significance test on the delta), so gate whichever you pick with a statistical eval. Skip that last step and you will ship a model swap because the number went from 82% to 85%, with no idea whether that is signal or the same run resampled.

Who owns the trace data: Langfuse is MIT, LangSmith and Braintrust self-host only on enterprise plans

Start with the fact that survives the next release of any of these tools. Langfuse ships an MIT-licensed core, and you can self-host every core capability (tracing, evaluations, prompt management, datasets, playground, and annotation) at production scale for free. The only exception is a set of enterprise features in the repository’s ee folder, which carry a commercial license.² When ClickHouse acquired Langfuse on January 16, 2026, the license did not move: the product stays MIT and self-hostable, and Langfuse already ran on ClickHouse under the hood, which is why the acquisition changed the org chart and not the terms.¹

LangSmith sits on the other side of that line. It is a proprietary, closed-source SaaS built by the LangChain team. You get managed cloud, bring-your-own-cloud, and a self-hosted option, but the self-hosted path unlocks only with an enterprise license key.³ Braintrust is proprietary too, with a twist worth pricing in: it runs on its own storage engine, Brainstore, and self-hosting is a hybrid enterprise deployment where you run the data plane in your own cloud while Braintrust hosts the control plane.⁴

If a security review or a data-residency rule is going to land on this decision, it lands here, before anyone opens a single trace.

Langfuse, LangSmith, and Braintrust converge on tracing and evals more than their landing pages admit

Feature-by-feature, the gap is narrower than the marketing implies. All three ingest OpenTelemetry spans, so you are not locked into a proprietary tracer to get data in.⁵⁶ All three run LLM-as-judge evaluators, store datasets, and support human review or annotation. Langfuse and LangSmith both carry prompt management with versioning; Braintrust centers its whole product on the eval loop instead. On what an eval actually scores versus what a trace records, all three draw the same line: the span proves the run finished, the eval scores whether the answer was right.

Because the wire format is OpenTelemetry, the same exporter points at any of the three by changing one endpoint and one auth header:

# One OpenTelemetry exporter; swap the endpoint and the auth header per platform.
export OTEL_EXPORTER_OTLP_ENDPOINT="https://<platform-otlp-host>/otel"
# Auth scheme differs by platform: Langfuse takes Basic auth (base64 of public:secret),
# LangSmith an x-api-key header, Braintrust a Bearer token.
export OTEL_EXPORTER_OTLP_HEADERS="<platform auth header>"
# Repoint those two lines at Langfuse, LangSmith, or Braintrust; your app code stays put.

Coupling and SDK reach

Where they genuinely diverge is coupling and SDK reach. LangSmith is authored by the LangChain team, so it has the deepest native integration with LangChain and LangGraph: a LangChain or LangGraph app is traced with almost no instrumentation code, where the other two want an OpenTelemetry exporter wired up. It stays framework-agnostic through OpenTelemetry and ships SDKs for Python, TypeScript, Go, and Java.⁷

The other two carry the SDK spread instead of the framework tie. Langfuse is OpenTelemetry-first and framework-neutral, with Python and JS/TS SDKs plus drop-in integrations for the OpenAI SDK, LiteLLM, LlamaIndex, and Haystack, so it treats LangChain as one integration among many.² Braintrust has the broadest SDK spread of the three (Python, TypeScript, Go, Ruby, Java, C#, and Kotlin) and the most opinionated core, built on its own storage engine, though it exposes standard SQL and JSON or Parquet export through its API.⁸

The practical split is coupling: if you are deep in LangChain or LangGraph, LangSmith’s native advantage is worth the proprietary trade; if you want the option to leave, Langfuse’s OpenTelemetry-first, MIT stance keeps your data portable.

Braintrust vs Langfuse: the eval-first platform against the open-source default

Braintrust is a proprietary, eval-first platform; Langfuse is the MIT-licensed, self-hostable observability default. The two optimize for different jobs. Braintrust’s strongest surface is the dataset-scorer-experiment loop: if your daily work is defining scorers, running experiments over labeled sets, and comparing model versions on those scores, Braintrust’s loop is the most tightly integrated of the three. You pay for it two ways. The core is closed source, so you run on Braintrust’s proprietary engine rather than a stack you own, and portability rests on its export API rather than storage you control.⁴⁸ And the pricing runs through a free Starter tier, a paid Pro tier, and custom Enterprise, metered on data processed, number of scores, and retention.⁹

Langfuse answers a different question. Its gravity is observability plus prompt management, delivered under an MIT license you can run yourself, which makes it the default when data ownership and freedom from lock-in outrank a marginally slicker eval UI; its evals are capable. Langfuse Cloud meters on usage units (traces, observations, and scores), with a free Hobby tier and free self-hosting; the catch on self-hosting is operational, since you now run and scale a ClickHouse deployment yourself.⁹

Where TruLens fits for RAG evaluation

If RAG evaluation is the specific job, a fourth open-source option belongs on the shortlist: TruLens. Like a dedicated eval harness such as OpenAI Evals, TruLens is code-first and framework-neutral, and it centers on feedback functions, the programmatic scorers you attach to a RAG chain. Its signature is the RAG triad: context relevance (did retrieval pull the right passages), groundedness (is the answer supported by them), and answer relevance (does it address the question). Developed by TruEra and now part of Snowflake, it is open source and composable, so you can run it alongside whichever tracer you pick.¹⁰

Its scope is the honest limit. TruLens is a focused evaluation library, lighter on production tracing, dashboards, and team workflows than Langfuse, LangSmith, or Braintrust. The common pattern is to pair it: one of the three platforms for tracing and storage, TruLens for RAG-triad scoring on top.

Langfuse, LangSmith, or Braintrust: which should you pick?

Three questions settle it: do you need to own and self-host your trace data, does your stack already run on LangChain or LangGraph, and is a tight scoring loop your daily work? The table maps each answer to a platform and the catch that rides with it.

That table routes the platform choice. It does not close the reliability question, because all three rows share the same blind spot.

What all three store, and what none of them computes

Each of these platforms will happily store a pass rate and draw it on a chart. When your eval suite reads 82% on Monday’s run and 85% on Tuesday’s, the dashboard shows a green up-arrow. What none of the three documents is the test that clears that three-point move against the noise: their eval docs describe score storage, side-by-side run diffs, and per-case regression flags, and none computes a confidence interval on a pass rate or a paired significance test on the delta for you.¹¹ That is a statistics question their trace stores are not built to answer.

Answering it takes two things a logging tool does not ship:

1. A confidence interval on each pass rate, because a rate measured over 40 runs and one measured over 400 carry very different uncertainty, and the width of that interval is what the eval confidence interval captures.
2. A paired test on the delta, because the two runs scored the same items, so the right question is whether the difference between them is statistically significant rather than whether two independent bars look different.

A green eval number is only as honest as the test behind it, the same trap that lets a benchmark look healthy while measuring the wrong thing.

The layer above the dashboard is where reliability actually lives. A single pass rate samples reliability once; the lane’s name for measuring it properly is reliability@k, the suite-level aggregate of per-task pass^k that asks whether an agent clears the bar on all k attempts. Getting there means measuring agent reliability past a single pass rate, and trusting the judge that produced those scores in the first place, which is its own discipline once you read what LLM evals are and are not. Langfuse, LangSmith, and Braintrust are all good at recording the inputs to that analysis. They do not run the analysis.