LangSmith alternatives in 2026: Langfuse vs LangSmith, and what else to consider

The best LangSmith alternative depends on why you are leaving. As of November 2026: to self-host for free, Langfuse, or Opik if you want Apache-2.0 all the way down; for an eval-first workflow with experiments at the center, Braintrust; to standardize on OpenTelemetry, Arize Phoenix; for an open-source platform built around agents, Laminar; for teams already on Databricks, MLflow. If you are leaving Langfuse instead, the same list applies in reverse, with LangSmith on it.

Most of the time the comparison people actually run is Langfuse vs LangSmith, so this post starts there: what each costs, what you can host yourself, how long your traces live, and what each does better. Then it covers the other alternatives, what moving off LangSmith takes, and the one job neither platform is built for.

A disclosure: I build EvalShift. It is not a LangSmith or Langfuse replacement, and it appears here only in the section on what both platforms leave to you. Every claim about another tool links to that tool's own pricing page or docs, checked in November 2026.

Why teams look for a LangSmith alternative

LangSmith is a good product, and none of the reasons people leave are that it stopped working. They are almost always one of four:

1. +Seats. The Plus plan is $39 per seat per month ↗. That is cheap for three engineers and expensive once product managers, reviewers and domain experts all need to open traces.
2. +Self-hosting. Self-hosted LangSmith is an add-on to the Enterprise plan ↗. If traces must stay in your own infrastructure and you are not ready for an Enterprise contract, LangSmith is not an option.
3. +Retention. Base traces are kept for 14 days. Extended traces are kept for 180 days and cost more. Anyone who wants to look at last quarter's production behaviour has to plan for that.
4. +A proprietary platform. The evaluator libraries, openevals and agentevals, are MIT, but the platform is not. Some teams want the option to fork, audit or run the whole thing themselves.

One reason that comes up and does not hold: LangSmith is not LangChain-only. It ingests OpenTelemetry ↗ and traces the OpenAI, Anthropic and Vercel AI SDKs and plain code. If that is the only reason you are looking, you may not need to move.

What LangSmith does well

Worth listing before replacing it, because an alternative has to cover what you actually use:

• +The deepest LangChain and LangGraph integration of any platform, including LangSmith Deployment, a runtime for agent workloads. Most alternatives here do not deploy agents at all.
• +Experiments with a baseline. The comparison view marks each example that improved or regressed against the experiment you pick as the baseline, and pairwise evaluators score two outputs head to head.
• +Agent evaluators. agentevals ↗ matches a trajectory against a reference in strict, unordered, subset or superset mode, or has an LLM judge it; openevals adds multi-turn user simulation.
• +Evals as tests. Datasets run as pytest, Vitest or Jest tests, so a failing assertion fails CI.
• +Online evaluators and annotation queues for scoring live runs and routing them to reviewers.

Langfuse vs LangSmith

Both trace production, run evals on datasets and live traffic, manage prompts and route traces to human reviewers. The differences are in licensing, hosting and how you are billed.

Sources: Langfuse pricing ↗, Langfuse self-hosted pricing ↗, LangSmith pricing ↗, LangSmith self-hosting ↗.

Pricing: seats vs data points

The two bill on different meters, so the list prices do not compare directly.

LangSmith charges per seat plus per trace. One trace is one request end to end, however many model and tool calls it contains. Beyond the included traces it is pay-as-you-go, and upgrading a trace from 14-day to 180-day retention costs extra. The per-trace rate has moved during 2026, so price your own volume on LangChain's pricing page ↗ rather than trusting a number from a comparison post, this one included.

Langfuse charges no seats, but it counts every tracing data point ↗: the trace, each observation inside it, and each score. An agent request with ten model and tool calls and two evaluator scores is 13 units, not one. Beyond the included 100k, units cost $8 per 100k up to 1M, then $7 per 100k up to 10M.

A worked example, for 100,000 agent requests a month at 13 units each and five people who need access:

• +Langfuse Core: 1.3M units. $29, plus $72 for the units from 100k to 1M and $21 for the 300k above that: about $122 a month, any number of users, 90 days of data.
• +LangSmith Plus: $195 for five seats, plus 90,000 traces beyond the included 10k at the current pay-as-you-go rate, kept for 14 days unless you pay to extend them.

Two things move this a lot. Langfuse gets more expensive per request the more spans an agent emits, and sampling traces before they leave the app cuts both bills. LangSmith gets more expensive with every person you add.

Self-hosting: free vs Enterprise

Self-hosting is where the two differ most. Langfuse says you can self-host all core features for free ↗ without limits, including enterprise SSO and organization-level RBAC. A paid enterprise license adds project-level RBAC, data retention management, audit logs, server-side data masking and SCIM.

Free does not mean small. A production Langfuse deployment is two application containers plus Postgres, ClickHouse, Redis or Valkey, and S3-compatible blob storage ↗. Docker Compose is fine for trying it on one VM; for production the supported paths are Kubernetes with Helm or the AWS, Azure and GCP guides. Budget for running ClickHouse, which is the part most teams have not operated before.

Self-hosted LangSmith runs on Kubernetes with a Helm chart, or Terraform, and needs an Enterprise plan with a license key.

Which to pick

Choose Langfuse when traces must stay in your infrastructure, you want an open-source platform you could fork, many people need access, or you want more than 180 days of history.

Choose LangSmith when you build on LangChain or LangGraph and want deployment in the same platform, you want trajectory evaluators and multi-turn simulation ready-made, or a small team would rather pay per seat than run ClickHouse.

EvalShift vs LangSmith and EvalShift vs Langfuse go dimension by dimension through each platform's evals, data handling and CI.

Other LangSmith alternatives

Braintrust

Braintrust ↗ is the alternative for teams whose day revolves around experiments rather than traces. You define an Eval() with a dataset, a task and scorers, and compare experiments row by row, each change marked as an improvement, a regression or a trade-off. Trace-level scorers read the whole agent trace, scoring rules evaluate production logs online, and an eval-action ↗ posts results on a pull request. It has the widest SDK coverage: TypeScript and Python, plus Go, Java, Ruby and C#.

Pricing is per data, not per seat: the free Starter plan has unlimited users, 1 GB of processed data and 10k scores a month with 14 days of retention; Pro is $249 a month with 5 GB, 50k scores and 30 days. Self-hosting, including a hybrid mode, is on Enterprise, so it does not solve the self-hosting problem any better than LangSmith.

Choose it when you are leaving LangSmith because of seats, not hosting, and your team works in experiments.

Arize Phoenix

Phoenix ↗ is built on OpenTelemetry and the OpenInference conventions, so instrumentation is portable to any OTel backend if you move again. It runs LLM-judged evals, datasets and experiments, with prebuilt evals for agents' tool selection and tool invocation, and self-hosts with pip, Docker or Helm.

The license is the Elastic License 2.0 ↗: source-available, free to run yourself, not OSI open source. Arize AX is the commercial product, with a free tier and Pro at $50 a month.

Choose it when OpenTelemetry is your standard and you want to own the tracing layer.

Opik

Opik ↗, from Comet, is Apache-2.0 and the full platform is free to self-host. It has 43 built-in metrics, including Trajectory Accuracy, Agent Task Completion and Tool Correctness, a pytest integration, online evaluation rules for production traces, and guardrails for PII and prompt injection. The cloud has a free tier, and Pro starts at $19 a month.

Choose it when you want what Langfuse offers under a permissive license with no enterprise folder, and agent metrics you do not have to write.

Laminar

Laminar ↗ is an Apache-2.0 observability platform built for AI agents. Its OpenTelemetry-based SDK instruments common AI libraries, an evals SDK and CLI run locally or in CI, and "signals" let you describe agent behaviour in plain language and get alerted when runs match it. It is written in Rust, searches span text, and starts locally with docker compose up.

Choose it when you trace long-running agents and want an open-source tool built around them rather than around single LLM calls. It is younger than the others here, so check its integrations against your stack first.

MLflow

MLflow ↗ added GenAI tracing and evaluation to the ML platform many data teams already run: mlflow.genai.evaluate() with built-in judges, scorers from DeepEval, Ragas and Phoenix, and judges on incoming production traces. It is Apache-2.0 and free to self-host; Databricks runs the managed version.

Choose it when your organization already tracks models in MLflow or works in Databricks, and another vendor is a harder sell than another feature.

Two to check before you adopt

• +Helicone is a gateway-first observability tool under Apache-2.0. It announced in March 2026 that it had been acquired by Mintlify. Check the project's current status before building on it.
• +W&B Weave moved into CoreWeave with the rest of Weights & Biases; CoreWeave's docs describe Agent Lens, in public preview, as its successor.

Langfuse alternatives

The reasons teams leave Langfuse mirror the reasons they leave LangSmith:

• +Running it. Self-hosting is free, but Postgres, ClickHouse, Redis and blob storage are four stateful systems to operate. Teams that wanted "free" often wanted "free and small". Phoenix and Laminar are lighter to try; Langfuse Cloud or LangSmith remove the operations entirely.
• +Enterprise features on a self-hosted instance. Project-level RBAC, audit logs, data retention management and server-side masking need a paid license. Opik has no enterprise folder.
• +Ready-made agent evaluators. Trajectory checks in Langfuse are code you write. LangSmith's agentevals, Opik's agent metrics and Phoenix's tool-calling evals ship them.
• +An experiment-first workflow. If your team lives in the experiment comparison rather than the trace view, Braintrust is built around it.
• +Units add up for agents. Every observation and score is billed, so a long agent run is many units. LangSmith bills per trace, Braintrust per GB and score.

Moving off LangSmith

Live tracing moves in a day; history and habits take longer.

1. +Instrumentation. If your app sends OpenTelemetry spans, repoint the exporter: Langfuse, Phoenix and Laminar are built on OTel. If it uses LangChain's built-in LangSmith tracing, swap to the new tool's LangChain integration.
2. +Datasets. Recreate them in the new tool from your source files or through its SDK. Langfuse accepts CSV upload, the SDK, or adding any production observation to a dataset.
3. +Evaluators. openevals and agentevals are MIT-licensed packages of evaluator functions, so a trajectory match you rely on can keep running from your own test code.
4. +History. Existing traces stay in LangSmith until their retention runs out. Pull anything you will need through the SDK before then.
5. +Run both for a couple of weeks and compare what each shows for the same requests before you switch the old one off.

What neither platform is built for

LangSmith, Langfuse and every alternative above answer "what is production doing?" and "how does this dataset score?" well. The question they leave to you is narrower: if I swap the model under this agent, does it still call the same tools with the same arguments, and is the difference in scores real or noise?

Their experiment views show two runs side by side and mark the examples that moved. None of their docs describe a significance test on the difference. That is the job EvalShift does: it runs your captured production cases through both models, scores tool calls and trace rules on both sides, tests each difference for significance, and fails the pull request when the migration policy says the candidate is not safe to ship.

It runs alongside whichever platform you keep, LangChain apps included: the SDK writes captures to disk, independent of where your traces go. EvalShift vs LangSmith and EvalShift vs Langfuse show where each fits, and all comparisons include Promptfoo and DeepEval.

How to choose

Then instrument one real agent with your top two, send them the same traffic for a week, and compare the trace views, the eval setup and the bill. The best LLM evaluation tools covers the evaluation frameworks, as opposed to platforms, that pair with whichever you choose.

FAQ

What is the best LangSmith alternative? It depends on why you are leaving. Langfuse for self-hosted, open-source tracing and evals; Opik for the same under Apache-2.0; Braintrust for an experiment-first workflow without per-seat pricing; Arize Phoenix for OpenTelemetry-native tracing; Laminar for open-source agent observability; MLflow for teams on Databricks.

Is Langfuse better than LangSmith? For self-hosting, licensing and large teams, usually yes: Langfuse is MIT-licensed, self-hosts for free and charges no seats. LangSmith is stronger for LangChain and LangGraph users, ready-made agent trajectory evaluators and agent deployment, and needs no infrastructure of your own.

Is Langfuse free? The open-source version is free to self-host with all core features and no usage limits; some enterprise features need a paid license. Langfuse Cloud has a free Hobby tier with 50k units a month, 30 days of data and two users, and paid plans start at $29 a month.

Can you self-host LangSmith? Only on the Enterprise plan, where self-hosting is an add-on deployed on Kubernetes with Helm or Terraform. The Developer and Plus plans are cloud only.

What is the best open-source alternative to LangSmith? Langfuse (MIT, except its ee folders), Opik (Apache-2.0), Laminar (Apache-2.0) and MLflow (Apache-2.0). Arize Phoenix is source-available under the Elastic License 2.0.

What is the best Langfuse alternative? LangSmith if you would rather not operate infrastructure and build on LangChain; Opik for a fully Apache-2.0 platform with agent metrics; Braintrust for an experiment-first workflow; Phoenix or Laminar for a lighter self-hosted setup.

Does LangSmith only work with LangChain? No. It traces the OpenAI, Anthropic and Vercel AI SDKs and plain code, and ingests OpenTelemetry spans. Its integration with LangChain and LangGraph is the deepest, but it is not required.

Keep reading

• +The best LLM evaluation tools: frameworks and platforms compared by the job they do.
• +EvalShift vs LangSmith and EvalShift vs Langfuse: where a pre-merge gate fits next to each platform.
• +Build a golden eval suite from production traffic: turning the traces any of these platforms collect into test cases.