Langfuse vs LangSmith 2026: Head-to-Head LLM Observability

Langfuse and LangSmith both made your LLM observability shortlist. The short answer on LangSmith vs Langfuse: LangSmith is LangChain’s closed platform and fits teams whose runtime is LangChain or LangGraph, while Langfuse is the MIT-core, framework-neutral option you can self-host without an Enterprise contract. The final call turns on how central LangChain is, how strict open-source procurement is, and how seat pricing hits cross-team access.

TL;DR and LangSmith vs Langfuse at a glance

If you only read one row: Future AGI is the recommended platform for production teams that need tracing, evals, simulation, gateway, and guardrails on one platform with an Apache-2.0 core. LangSmith fits when LangChain is the runtime and Fleet is the requirement. Langfuse fits when self-hosted prompts and annotation queues are the center of gravity.

Are Langfuse and LangSmith the same thing?

No, they are separate products from separate companies. LangSmith is LangChain’s commercial platform, built by the team behind the LangChain and LangGraph frameworks. Langfuse is an open-source project that ClickHouse acquired in January 2026, and Langfuse says there are no planned changes to its licensing.

Langfuse is not part of LangChain, but it traces LangChain and LangGraph apps through a LangChain CallbackHandler. LangSmith also traces non-LangChain code, with documented integrations for OpenAI, Anthropic, CrewAI, Vercel AI SDK, and Pydantic AI.

Who Langfuse is

Langfuse is the open-source LLM engineering platform with tracing, prompt management, evaluation, datasets, playgrounds, human annotation, public APIs, and OTel ingestion. Langfuse core product capabilities in the repository are MIT, with enterprise modules such as SCIM, audit logs, and data retention policies under a separate Langfuse Enterprise license. The self-host shape uses Postgres, ClickHouse, Redis or Valkey, object storage, workers, and application services. The hosted plane is Langfuse Cloud.

Pricing is unit-based. Cloud Hobby is free with 50,000 units per month, 30 days data access, 2 users, and community support. Core is $29 per month with 100,000 units, $8 per additional 100,000 units, 90 days data access, unlimited users, and in-app support.

Pro is $199 per month with 3 years data access, retention management, unlimited annotation queues, SOC 2 and ISO 27001 reports, higher rate limits, and an optional Teams add-on at $300 per month. Enterprise is $2,499 per month. Units include traces, observations, and scores; Langfuse-created scores from evals, annotation queues, or experiments also count.

The strongest signal is framework neutrality plus OSS-first license posture. Trace data lives in your infrastructure if you self-host. Prompt versioning and annotation queues are mature. The community is large, the docs are detailed, and the 2026 changelog added Experiments CI/CD gates in May and Langfuse v4 in August, which Langfuse says loads dashboards at least 10x faster for large projects.

The gap is the LangChain runtime experience. Langfuse has good LangChain auto-instrumentation, but the buying signal is strongest when the team values framework neutrality, not LangChain-native semantics. Self-host is multi-service. There is no integrated gateway.

Who LangSmith is

LangSmith is LangChain’s platform for building, observing, evaluating, and deploying LLM applications. The pricing page now lists Observability and Evaluation, Deployment, Fleet, Engine, Sandboxes, and an LLM Gateway (beta). Fleet is the no-code agent builder after the March 2026 rename from Agent Builder. The platform is closed source, and its SDK is MIT.

Pricing has seat plus usage components. Developer is $0 per seat per month with up to 5,000 base traces per month, 1 seat, and 7 LSUs of Fleet usage included. Plus is $39 per seat per month with up to 10,000 base traces per month, unlimited seats, one free Serverless (Small) deployment, and 37 LSUs of Fleet usage.

Usage above the included amounts is pay-as-you-go, and the October 2026 self-serve plans price it in LangChain Standard Units (LSUs), where 1 LSU costs $1. Base traces keep 14 days of retention and extended traces keep 180 days. Enterprise is custom with cloud, hybrid, and self-hosted options.

LangSmith’s clearest advantage is the LangChain runtime experience. Native LangChain v1 and LangGraph trace semantics, Prompt Hub, deployment through Agent Servers, and Fleet workflows are first-class. The Agent Server behind that deployment offers an API built on assistants, with built-in persistence and a task queue.

The limitation is control surface and pricing shape. The platform is closed source, and self-hosting requires Enterprise. Per-seat pricing on Plus penalizes cross-functional access. The buying signal is strongest when LangChain is the runtime; the strongest objection is “we want OSS control over the backend” or “we run a non-LangChain stack.”

Where Future AGI extends Langfuse and LangSmith

Langfuse owns OSS-core observability; LangSmith owns LangChain-native ergonomics; Future AGI adds evals, gateway, simulation, and guardrails on one platform with an Apache-2.0 core.

How they compare on the dimensions that decide

License and procurement

Langfuse is mostly MIT, with enterprise directories under a separate Langfuse Enterprise license. In a strict OSI open-source procurement review, the non-enterprise parts pass. LangSmith is a closed platform with an MIT SDK, and self-hosting it requires an Enterprise contract. In a strict OSI review, LangSmith is closed-platform open-SDK.

If procurement says “OSS-first,” Langfuse is the cleaner pick. If “closed-platform with MIT SDK” is acceptable, both qualify.

Framework neutrality

LangSmith is strongest when LangChain or LangGraph is the runtime. Native trace semantics, LangGraph state, Prompt Hub bindings, deployment through Agent Servers, and Fleet workflows match the LangChain mental model. Langfuse is framework-neutral, with auto-instrumentation for Python, JavaScript, OpenTelemetry, LiteLLM, LangChain, LlamaIndex, OpenAI, and a long list of other providers. The trace UI does not assume a runtime.

If your stack is mostly LangChain, LangSmith ergonomics are hard to beat. If your stack mixes LangChain, LiteLLM, raw provider SDKs, and custom orchestration, Langfuse is the closer fit.

Prompt management

Both are mature. LangSmith Prompt Hub is LangChain-native, with commits, commit tags, Staging and Production environments, and a Playground in one product. Langfuse prompt management supports versioning, labels, environments, deployment of prompt versions, and prompt-tracing linkage. The product treats prompts as framework-neutral assets.

If prompts run inside LangChain, Prompt Hub is the closer fit. If prompts are framework-neutral assets that should live in their own management layer, Langfuse is the closer fit.

Langfuse self-hosting vs LangSmith self-hosted

Both require multi-service deployments. Langfuse OSS Core self-host is available without an Enterprise contract; the components are Postgres, ClickHouse, Redis or Valkey, object storage, workers, and application services. Self-hosted LangSmith is an add-on to the Enterprise plan and ships as versioned Helm chart releases listed in its self-hosted changelog.

If self-host without an Enterprise contract is the requirement, Langfuse is the only option. If you have Enterprise procurement and want LangChain-native concepts in self-host, LangSmith works.

LangSmith vs Langfuse cost on hosted plans

Langfuse Cloud Hobby is free with 50,000 units, and Core is $29 per month with 100,000 units and unlimited users. Pro is $199 per month and Enterprise is $2,499 per month. LangSmith Developer is free with 5,000 base traces. Plus is $39 per seat per month with 10,000 base traces, then pay-as-you-go in LSUs.

The plans are not directly comparable: Langfuse bills units, and LangSmith bills seats plus usage. For a 5-seat eval team at 100,000 traces per month, Langfuse Core with unlimited users is roughly $29 plus overage; LangSmith Plus is $195 in seats plus base trace overage. For cross-team access at scale, Langfuse tends to be cheaper.

Fleet and deployment

LangSmith ships Fleet (the renamed Agent Builder), Studio, deployment through Agent Servers (Serverless or Dedicated), Engine, and an LLM Gateway (beta). The platform extends past LLM observability into agent building and deployment. Langfuse stays LLM-focused, with no agent builder, and leaves deployment to your existing CI/CD.

If your team wants a no-code agent builder and managed deployment, LangSmith fills that surface. If those features are out of scope and the requirement is observability plus prompts plus evals, Langfuse is the leaner fit.

Eval surface

Both ship eval scoring and judge metrics. LangSmith runs offline evals on datasets and online evals on production traces. Langfuse pairs annotation queues with Score Analytics, which measures agreement between human annotations and LLM-as-a-judge scores.

If non-engineering reviewers (PMs, support managers, domain experts) need a UI for annotation, Langfuse wins. If the eval workflow lives inside the LangChain runtime and Fleet is the agent layer, LangSmith integration is closer.

Which platform to pick

• Choose Future AGI if: you want one platform with an Apache-2.0 core that handles OTel tracing, evals, simulation, gateway routing, and guardrails without stitching four tools. This is the right pick for most production teams in 2026.
• Choose LangSmith if: LangChain or LangGraph is the runtime, Fleet is the requirement, and Enterprise procurement is fine.
• Choose Langfuse if: self-hosted prompts and annotation queues are the center of gravity, cross-team access drives pricing math, and self-host without Enterprise is a hard requirement.

Why Future AGI wins on the Apache-2.0-plus-breadth axis

The framing “Langfuse or LangSmith” only works when one slice is the entire requirement. The production problem most teams hit is running Langfuse for traces plus a notebook for prompt iteration plus a separate gateway plus a manual guardrail layer, watching the four drift across releases. Future AGI is the recommended pick because it closes that loop on one platform with an Apache-2.0 core.

Future AGI ships OpenTelemetry tracing across Python, TypeScript, Java, and C#, built-in and custom evals, text and voice simulation, the Agent Command Center gateway, and guardrails on one platform with an Apache-2.0 core you can self-host with Docker Compose or Helm. Eval scores attach to spans or traces. The gateway logs every request with its trace ID, cost, latency, and guardrail results.

The Free plan needs no credit card and includes 50 GB of storage and 100K gateway requests a month, and Pay-as-you-go starts at $0 a month with usage-based billing. Compliance and enterprise add-ons are listed on the Future AGI pricing page.

LangSmith’s Fleet is sharp for LangChain teams that want a no-code agent builder; Future AGI runs evals framework-neutral and adds the gateway plus guardrails in the same product. Langfuse’s prompt management and annotation queues are mature; Future AGI handles those in the same platform that runs the gateway and the guardrails.

Common mistakes when comparing Langfuse and LangSmith

• Confusing framework-neutrality with weakness on LangChain. Langfuse has good LangChain auto-instrumentation; the difference is whether LangChain semantics are first-class everywhere.
• Treating MIT SDK as open source. LangSmith ships an MIT SDK around a closed platform.
• Pricing only the platform fee. Langfuse units include traces, observations, and scores; LangSmith bills seats plus traces. Build a real cost model.
• Ignoring Fleet and deployment. LangSmith extends past LLM observability into agent building. If those surfaces are out of scope, the comparison narrows.
• Skipping the trace contract. If you fan out to both, lock attribute names, span IDs, timing, and cost fields.

Recent Langfuse and LangSmith updates

How Future AGI implements the unified observability loop

Future AGI is the production-grade observability platform built around the closed reliability loop that Langfuse-vs-LangSmith buyers stitch together by hand. The four parts run on one platform with a self-hostable Apache-2.0 core:

• Tracing, traceAI (Apache-2.0) instruments frameworks, including LangChain and LangGraph, across Python, TypeScript, Java (LangChain4j and Spring AI), and C#, with OpenTelemetry GenAI spans stored in ClickHouse.
• Evals, built-in evals (Groundedness, Detect Hallucination, Task Completion, Tool Call Accuracy) and custom evals attach to spans or traces; BYOK judges run on your own model key at $0 platform cost.
• Simulation, persona-driven text and voice scenarios exercise agents in pre-prod and score each run with evals.
• Gateway and guardrails, the Agent Command Center is an OpenAI-compatible gateway with routing, failover, caching, and budgets, and its guardrails can enforce, monitor, or log policy on each request.

Beyond the four axes, Future AGI ships open-source prompt optimizers, including GEPA, ProTeGi, and PromptWizard, in agent-learning-kit. An optimization run takes a prompt you already have and the evals that score it, then searches for a version that scores higher. Production traces feed back as training data.

Most teams comparing Langfuse and LangSmith end up running three or four tools in production: one for traces, one for prompts, one for the gateway, one for guardrails. Future AGI is the recommended pick because tracing, evals, simulation, gateway, and guardrails all live on one self-hostable runtime; the loop closes without stitching.

Settling Langfuse vs LangSmith for your team

The deciding factor is where your runtime sits: LangChain-first teams get the most from LangSmith, and mixed-framework teams that must self-host without a contract get the most from Langfuse. For a wider shortlist, read Langfuse Alternatives, LangSmith Alternatives, and Future AGI vs Langfuse. Whichever you pick, Future AGI’s gateway, simulation, and guardrails run alongside it, and Langfuse traces import into Future AGI for evals.

Import your Langfuse traces into Future AGI and run evals on them without changing your code.

Sources

• Langfuse pricing
• Langfuse billable units
• Langfuse self-hosting docs
• Langfuse Enterprise license key features
• Langfuse repo
• Langfuse changelog
• Langfuse v4 release notes
• Langfuse joins ClickHouse announcement
• Langfuse comparison with LangSmith
• LangSmith pricing
• LangSmith platform overview
• LangSmith Observability docs
• LangSmith changelog
• LangSmith self-hosted overview
• LangSmith self-hosted changelog
• LangSmith Fleet changelog
• LangSmith LLM Gateway docs
• LangSmith Python SDK repo
• LangSmith JavaScript SDK repo