# Langfuse vs LangSmith: Data Plane or Agent Loop?

> Choose Langfuse for an owned OTel data plane or LangSmith for a managed agent loop. Compare current pricing, retention and a five-case bake-off.

Source: https://dvnc.dev/blog/langfuse-vs-langsmith-production-observability

---

:::intro
Choose Langfuse when observability should be an OpenTelemetry-based data plane you can self-host and connect to your own platform. Choose LangSmith when you want a managed agent engineering loop that joins traces, evals, review and deployment. Do not choose either from a feature checklist: run the same representative traces through both and make retained evidence, denied actions and cost attribution pass first.
:::

## The verdict

Langfuse is the stronger default when telemetry ownership and portability are architectural requirements. Its SDKs are built on OpenTelemetry, its cloud plans do not charge by seat above the Hobby tier, and its open source edition can run in your own infrastructure without a Langfuse usage fee. That control is not free. A production self-hosted deployment means operating Postgres, ClickHouse, Redis or Valkey, object storage, the web application and its workers.

LangSmith is the stronger default when the team values one managed loop from trace to dataset, evaluator, review and agent deployment. LangChain and LangGraph still give it the shortest integration path, but the current product is not restricted to them. [LangSmith's observability documentation](https://docs.langchain.com/langsmith/observability) lists OpenAI, Anthropic, CrewAI, Vercel AI SDK, Pydantic AI and other integrations.

The dividing line is therefore not open source versus closed source, or framework-neutral versus LangChain-only. It is this:

> Do you want to own the observability data plane, or buy a managed agent engineering loop?

The answer can flip when security, deployment or review requirements change. A team may choose Langfuse Cloud for speed while keeping an OTel-shaped exit path. Another may choose LangSmith even outside LangChain because its managed evaluation and deployment loop removes more internal platform work than the coupling costs.

## What changed in this comparison

Two material facts changed after the first version of this page.

First, LangSmith's public pricing now describes compute and work in LangChain Compute Units, or LCUs, and stored or managed data in LangChain Storage Units, or LSUs. One LCU is priced at $1.50 and one LSU at $1.00. The old fixed figures for each 1,000 base or extended traces are no longer the current public model, so they should not drive a new budget.

Second, [LangSmith's current pricing page](https://www.langchain.com/pricing) says base traces retain for 14 days and extended traces retain for 180 days. The previous version of this article said 400 days. That claim is retired.

The important lesson is larger than a pricing correction. An observability choice needs a versioned commercial fact lock. Retention, included traces, ingestion limits and metering units change. Record the pricing date and keep your decision worksheet separate from vendor marketing pages so the next procurement review can see what assumption moved.

## Langfuse vs LangSmith in 2026

| Decision axis | Langfuse | LangSmith | Choose by |
|---|---|---|---|
| Data plane | Cloud or self-hosted open source; OTel-based SDKs and endpoint | Cloud on self-serve plans; cloud, hybrid or self-hosted on Enterprise | Who must control trace storage and exports |
| Engineering loop | Tracing, prompts, datasets, online and offline evals, annotation and metrics | Tracing, datasets, online and offline evals, review, Engine and managed deployment | Whether deployment and improvement should share one vendor loop |
| Commercial shape | Cloud plan plus ingested units; unlimited users on Core and above | Seats plus pay-as-you-go traces, LCUs and LSUs; custom Enterprise terms | Trace shape, retained evidence, reviewers and adjacent services |
| Operational burden | Low on cloud, substantial when self-hosted | Low on cloud; hybrid and self-hosted are Enterprise choices | Whether your team already operates a telemetry data plane |

Both products can trace agent runs, collect scores, build datasets and support online and offline evaluation. Neither product automatically gives you an acceptance policy, an authoritative business-state read-back or a release owner. Those remain application and operating-contract concerns.

## Choose Langfuse when the telemetry layer belongs to your platform

Langfuse's clearest advantage is control of the observability boundary. Its current Python and JavaScript or TypeScript SDKs use OpenTelemetry underneath, and other runtimes can send spans to its OTel endpoint. That makes it easier to standardize identifiers and attributes across model calls, retrieval, tool use and ordinary service telemetry.

Its cloud economics are also legible. [Langfuse pricing](https://langfuse.com/pricing) lists a free Hobby plan with 50,000 units per month, 30 days of data access and two users. Core is $29 per month with 100,000 included units, 90 days of data access, unlimited users and additional usage at $8 per 100,000 units before volume discounts. Pro is $199 per month with 100,000 included units and three years of data access.

The unit is not a request. [Langfuse defines billable units](https://langfuse.com/docs/administration/billable-units) as:

```text
monthly units = traces + observations + scores
```

An agent request with one root trace, eight child observations and three stored scores creates 12 units. That is illustrative arithmetic from the published definition, not a production traffic estimate. Model your own fan-out and evaluation sampling before multiplying by requests.

Self-hosting replaces the Langfuse Cloud bill with infrastructure and operating work. The [documented production architecture](https://langfuse.com/self-hosting) includes web and worker containers, Postgres, ClickHouse, Redis or Valkey, and S3 or compatible blob storage. Choose it when data location, network isolation or platform integration justifies that system. Do not choose it merely because the license price is zero.

Langfuse is also no longer just a trace viewer. Its [evaluation workflow](https://langfuse.com/docs/evaluation/overview) covers live and offline evaluation, datasets, experiments, manual review and CI experiments that can fail a job when a threshold regresses. The remaining question is whether your team wants to assemble that workflow around its own release process.

## Choose LangSmith when the improvement loop should be managed together

LangSmith's advantage is the amount of the agent engineering lifecycle it can hold in one managed system. Traces can become dataset examples. Offline evaluators can gate a release. Online evaluators can monitor live traffic. Annotation queues can add human judgment. Managed deployment and adjacent services can share the same commercial and operational control plane.

Its current self-serve entry points are [Developer at $0 per seat per month](https://www.langchain.com/pricing), with one seat and up to 5,000 base traces per month, and Plus at $39 per seat per month, with up to 10,000 base traces per month and unlimited seats. Plus includes one small serverless deployment. Additional work and data are metered through traces, LCUs and LSUs, so use the live calculator instead of copying an old per-trace figure into a yearly forecast.

Retention needs an explicit policy. Base traces live for 14 days and extended traces for 180 days. A useful default is to keep high-volume traces in the short window, then promote only evidence with durable learning value: failures, human-reviewed runs, release examples and traces tied to a disputed business effect. That is a DVNC operating recommendation, not a LangSmith guarantee.

LangSmith's managed surface creates coupling, but coupling is not automatically bad. If the same team owns LangGraph applications, release evaluation and managed deployment, the common loop may reduce integration failure. If the company wants one OTel data plane across many services, or needs self-hosting without an Enterprise commercial relationship, that same coupling may be the reason to choose Langfuse.

## Run a two-tool bake-off before procurement

A dashboard tour will not tell you which product can support your operating contract. Use the same representative traces and acceptance rules in both systems. A one-day technical bake-off can be enough to expose the hard gaps, provided the cases are real and the verdict is withheld until reconciliation.

Start with one run contract. The [agent monitoring playbook](/blog/ai-agent-monitoring-production-playbook) goes deeper, but the minimum record should look like this:

```json
{
  "run_id": "stable-business-run-id",
  "tenant_id": "privacy-safe-tenant-ref",
  "release": "agent-2026-10-01.1",
  "workflow": "support-refund-review",
  "model": "provider-and-model-id",
  "tool_policy": "policy-v7",
  "evaluator_set": "refund-gate-v4",
  "approval_state": "not-required|pending|approved|rejected",
  "intent_receipt": "write-request-ref",
  "provider_receipt": "provider-acceptance-ref",
  "authoritative_state": "observed|uncertain|divergent",
  "terminal_outcome": "accepted|rejected|handoff|failed"
}
```

Then run the same five cases through both candidates:

1. A normal accepted run with model, retrieval and tool spans.
2. A denied action that must remain denied and visible.
3. A human approval that binds the exact proposal and reviewer decision.
4. A provider timeout after an accepted write, producing an uncertain outcome until read-back.
5. A release regression that must fail the offline evaluation gate.

Score the products on evidence rather than interface preference:

- **Completeness:** Can every run be joined to release, tenant, policy, evaluator and final outcome?
- **Negative evidence:** Can denied actions and stopped branches be distinguished from missing telemetry?
- **Reconciliation:** Can the trace link intent, provider acceptance and authoritative retained state without pretending they are the same event?
- **Portability:** Can the team export enough data and identifiers to investigate an incident outside the vendor UI?
- **Retention:** Which cases remain queryable for the incident and audit windows the workflow requires?
- **Cost attribution:** Can usage, evaluator work, human review and terminal outcomes be joined at one stable run boundary?
- **Operations:** Who owns dropped spans, ingestion backlog, migrations, access control and vendor outage behavior?

Do not average these criteria into a decorative score. Mark hard requirements as pass or fail, then price only the candidates that pass. If neither can distinguish an uncertain write from a confirmed business effect, fix the application contract before choosing a platform.

The broader [agent observability platform comparison](/blog/ai-agent-observability-tools-production) is useful if both candidates fail a hard constraint. Keep this page's decision narrow: Langfuse versus LangSmith for the workflow you can actually test.

## The decision rule

Choose Langfuse when you need an OTel-based telemetry layer that can remain separate from the agent runtime, when self-hosting is available without an Enterprise platform license, or when unlimited cloud users and usage-unit pricing fit the team better than seats. Budget for the actual self-hosted system, not just the license.

Choose LangSmith when the managed trace, evaluation, review and deployment loop removes work your team would otherwise have to build, and when its seat, trace, LCU and LSU model can be forecast from representative traffic. LangChain and LangGraph make the path shorter, but they are not prerequisites.

Choose neither until the application emits a stable run contract and reconciles external effects. Observability explains what the agent attempted. Your source system still decides whether the business effect happened.

::::faq
:::faq-item{q="Is LangSmith only for LangChain?"}
No. LangSmith currently documents integrations with OpenAI, Anthropic, CrewAI, Vercel AI SDK, Pydantic AI and other stacks. LangChain and LangGraph still offer the shortest native path, but they are not a product boundary.
:::

:::faq-item{q="Can Langfuse be self-hosted for production?"}
Yes. Production self-hosting means operating the Langfuse web and worker containers plus Postgres, ClickHouse, Redis or Valkey, and object storage. The open source edition has no Langfuse usage fee, but the infrastructure and operational labor are real costs.
:::

:::faq-item{q="Which is cheaper, Langfuse or LangSmith?"}
There is no honest universal answer. Langfuse Cloud meters plans and traces, observations and scores. LangSmith meters seats, traces, compute and storage units. Compare both with your trace fan-out, evaluation sampling, retention policy, reviewers and self-hosting labor.
:::

:::faq-item{q="Can Langfuse or LangSmith replace application audit records?"}
No. A trace can record intent, tool activity and a provider response, but an external write is complete only after authoritative read-back confirms retained state. Keep business-effect reconciliation in the application contract.
:::
::::

:::summary
- Langfuse is the better default when observability should be an OTel-based, self-hostable data plane owned by your platform.
- LangSmith is the better default when a managed trace, evaluation, review and deployment loop removes meaningful internal work.
- Current LangSmith pricing uses traces, LCUs and LSUs, and extended traces retain for 180 days.
- Price representative trace shapes and retained evidence, not requests alone.
- Withhold the verdict until denied actions, uncertain writes and release regressions pass the same bake-off.
:::

::card{href="/services/ai-agent-rescue" title="Start the AI Agent Rescue" description="Turn incomplete traces and uncertain side effects into one observable run contract with release gates, reconciliation and accountable handoff."}
