Langfuse vs LangSmith: which to choose for LangChain and LangGraph agents

In this guide

• Langfuse vs LangSmith at a glance
• What is Langfuse, and is it part of LangChain?
• Langfuse pricing vs LangSmith pricing
• Self-hosting, regions and retention
• How each one traces a LangChain or LangGraph agent
• Evaluation, prompts and datasets
• Which one should you choose?
• Why a LangChain-based platform integrates Langfuse
• How Olano uses Langfuse
• Common mistakes

What is Langfuse, and is it part of LangChain?

Langfuse is an open-source platform for tracing, evaluating and managing prompts of LLM applications and agents. Its founders, Clemens Rawert, Max Deichmann and Marc Klingen, went through Y Combinator's Winter 2023 batch and built their engineering team in Berlin. On 16 January 2026 Langfuse announced that ClickHouse, Inc. had acquired it; ClickHouse's announcement says the core stays MIT-licensed and Langfuse Cloud keeps running as a standalone service. Its open-source build has no usage limits and runs the same code as the cloud.

Langfuse is not part of LangChain. LangChain's own comparison page says Langfuse "is a product by ClickHouse, and not part of the LangChain product suite". LangChain is the framework you build an agent with; Langfuse is one place to send its traces. The real choice is Langfuse vs LangSmith.

LangSmith is LangChain, Inc.'s platform for observability, evaluation and prompt engineering, now a suite: LangSmith Deployment runs agents, Studio visualises and debugs LangGraph graphs, and Fleet, Sandboxes, an LLM Gateway and Engine are metered separately. Its SDK is MIT-licensed; the platform is not open source.

Langfuse pricing vs LangSmith pricing

Langfuse charges per unit, counting every trace, observation and score, with no user fee on paid plans; Pro is US$199 a month with three years of history, and Enterprise is published at US$2,499 (pricing, billable units). LangSmith charges per seat and per trace, where a trace counts once however many steps it holds; one LangChain Standard Unit is US$1, and Enterprise is priced by quote (pricing). Which is cheaper depends on trace depth and how many people read traces.

Here the two cross at about 108 steps per turn. Langfuse is cheaper for shallow traces and many readers; LangSmith catches up as traces deepen, because its price does not grow with steps. Neither figure includes LangSmith Deployment, discounts or tax. Langfuse's own example (500,000 traces, five users) comes out at about one sixth of LangSmith's price; the arithmetic holds for the scenario it chose, so run yours.

Self-hosting, regions and retention

Langfuse self-hosts free under MIT; LangSmith only on Enterprise. Operationally they are close: both run on ClickHouse, Postgres, Redis and object storage.

Langfuse self-hosted (guide): Docker Compose is documented for a single VM "without high availability, scaling, or backups"; production means Kubernetes or cloud templates, air-gapped if needed. Enterprise SSO is in the free build; project-level roles, retention policies and audit logs need a paid licence. LangSmith self-hosted (overview) is a Kubernetes install with a licence key that, outside offline mode, is verified online; BYOC keeps data in your VPC while LangChain runs the control plane.

Regions. Langfuse Cloud runs in the US, EU and Japan (regions); LangSmith in the US, EU and APAC (regions FAQ). Neither moves an account between regions, so choose before launch. Retention. Langfuse plans limit how far back you can look but delete nothing without a retention policy (Pro or the self-hosted licence). LangSmith keeps base traces 14 days and extended ones 180.

Both record full inputs and outputs by default, and both let you strip them before sending: LangSmith's LANGSMITH_HIDE_INPUTS and anonymizers, Langfuse's masking hooks.

How each one traces a LangChain or LangGraph agent

LangSmith needs only environment variables; Langfuse needs a callback handler in the run's config. Both cover create_agent, raw LangGraph graphs and Deep Agents.

LangSmith

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-api-key>
# only outside the default US region, e.g. EU:
export LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com

Every LangChain and LangGraph run in the process is then traced with no code change (docs); LangSmith can also receive and emit OpenTelemetry.

Langfuse

# LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY and LANGFUSE_BASE_URL set in the environment
from langchain.agents import create_agent
from langfuse import get_client
from langfuse.langchain import CallbackHandler

def order_status(order_id: str) -> str:
    """Look up the delivery status of an order."""
    return f"Order {order_id} is out for delivery."

agent = create_agent("anthropic:claude-sonnet-4-6", tools=[order_status])
agent.invoke(
    {"messages": [{"role": "user", "content": "Where is order 4711?"}]},
    config={"callbacks": [CallbackHandler()],
            "metadata": {"langfuse_session_id": "customer-4711"}},
)
get_client().flush()  # in a short script, send buffered spans before exit

Model and tool calls become observations under one trace, and langfuse_session_id groups a conversation (docs). The same config works for a raw LangGraph graph or a deep agent; other languages can send spans to the OTLP endpoint.

We ran both with LangChain 1.4.6, LangGraph 1.2.16, langfuse 5.0.2 and langsmith 0.14.11, a scripted fake model and a local stand-in for each backend: Langfuse exported OpenTelemetry spans; LangSmith posted runs with no callback in the code.

Evaluation, prompts and datasets

Both cover the core loop: datasets and experiments, LLM-as-a-judge and code evaluators, annotation queues, user feedback, and versioned prompts. LangSmith automates more around it: automation rules, Insights over production traces, Engine proposing fixes, and Tuned Evaluators (beta, US cloud).

Read each vendor's comparison with its date in mind. LangChain's, dated 22 April 2026, says Langfuse lacks alerting and online deterministic evaluators; Langfuse's docs now list alerts and code evaluators on every plan. Langfuse's page fairly credits LangSmith's one-variable LangChain integration.

Why a LangChain-based platform integrates Langfuse

Olano agents run on LangChain, LangGraph and Deep Agents, yet the tracing integration we ship is Langfuse, and Olano does not integrate LangSmith. Here is our reading of the documented facts against a deployment like ours: reasoning, not an internal decision record.

• The customer decides where conversations go. A deployment holds customer conversations, so whether traces leave it, and to which region, is their call: Langfuse offers EU, US or Japan, or a free server of their own.
• Many models, one record. Olano agents use 18+ model providers; a framework-neutral, OpenTelemetry-based store fits that.
• Readers, not seats. On Langfuse's paid plans, every admin who needs a trace can open one without a seat fee.
• Metadata first. Our integration sends a turn's structure without its text by default; with customer data, that matters more than the vendor.

What we give up: zero-code tracing, Studio and LangSmith's evaluation automation. LangSmith Deployment matters less: Olano runs its agents itself.

How Olano uses Langfuse

An admin can send every agent turn to a Langfuse project as one trace: the turn and each model and tool call under it, with timings, tokens and credits, grouped by conversation. It is off by default, set in Config → Observability (Langfuse), and agents cannot change it.

• Where. Langfuse Cloud (EU, US or Japan) or your own Langfuse server. Keys go into the vault, hidden from agents.
• What. Metadata only by default: structure, timings, tokens, model and tool names, and a pseudonym for the person, but no message or tool text. Full content adds the text. Either way, secrets become [secret].
• How much. A share of turns from 0 to 1, each traced whole, set for the deployment or per agent. If Langfuse is unreachable, the turn still goes ahead.
• Links, feedback, deletion. Admins get a Langfuse link under each traced reply; members do not. A thumbs vote on a traced reply becomes a user_feedback score. Deleting a conversation deletes its traces.

The limits: Langfuse bills you on its own pricing, or runs on your server; evals and prompts are set up in Langfuse itself; and with tracing on, turn data leaves the deployment. Details: the Langfuse tracing reference, the chat guide, our security page, and AI agent observability for the wider picture.

Common mistakes

• Comparing a price per trace with a price per unit. Count the observations in a typical trace first.
• Forgetting seats. LangSmith Plus bills every invited user; Langfuse Core and above do not.
• Assuming traces are kept. LangSmith base traces go after 14 days, and investigations often start later.
• Picking a region after launch. Neither vendor moves an account between regions.
• Running Langfuse's Docker Compose setup in production. It is documented for one VM without high availability or backups.
• Sending full conversations by default. Decide what customer data a trace may hold before the first one is sent.