LangSmith vs Langfuse

Choose LangSmith for a LangChain or LangGraph team that wants tracing and evaluation in the same daily workflow; choose Langfuse for a shared multi-framework platform or open-source self-hosting. The Langfuse vs LangSmith decision turns on 3 questions: which code you need to inspect, how failures become tests, and who must operate the data infrastructure.

LangSmith vs Langfuse: Which Should You Pick?

Pick LangSmith when improving an existing LangChain or LangGraph application is the main job. Pick Langfuse when you need a common observability service across applications or must self-host without an Enterprise software contract. Both cover tracing, evaluations, datasets, prompt management and monitoring. The difference is the workflow you want to standardize.

A trace records one application execution; its spans record the operations inside it, such as retrieval, a model call or a tool invocation. An evaluation, or eval, judges whether the behavior meets a defined standard. A dataset saves examples so you can repeat that check after changing the application.

The recommendations below use those practical criteria: instrumentation fit, the failure-to-test workflow, and operational responsibility. They are editorial judgments from documented capabilities, not measured speed or accuracy rankings.

Documentation and prices verified against both makers' live pages on 14 October 2026. Prices are USD. No hands-on deployment or performance test is claimed.

Langfuse vs LangSmith at a Glance

Both have the core features; the decisive differences are integration convenience, review workflow and hosting access. Start with this comparison, then use the sections below to check the requirement that could disqualify either option.

Capability references: LangSmith documentation, Langfuse tracing, and their evaluation, prompt and hosting guides linked in the relevant sections.

The price denominators differ. Langfuse counts traces, observations and scores as units; its allowance is not an allowance of complete application runs. LangSmith's included Plus traces are a shared total, not an extra allowance for each purchased seat. Use the makers' pricing pages for the full ladders and Langfuse's unit definition when estimating your own traffic.

For this choice, first establish whether the necessary workflow and deployment model are available. A cheaper subscription cannot solve a missing hosting requirement, and a more expensive one does not automatically produce better evaluations.

What Each Platform Does

LangSmith: A Connected Debugging and Evaluation Workspace

LangSmith is LangChain's proprietary platform for observing and improving agent applications. Its observability tools let you inspect individual runs and production metrics; its evaluation tools turn recorded failures into repeatable checks. The useful part for an engineering lead is the connection between those activities: the developer investigating a failed answer can preserve it for the next release. LangChain explicitly describes LangSmith as proprietary in its FAQ.

LangSmith suits a team whose engineers and reviewers will actively use that workspace. Its wall is commercial and operational: the open-source status of LangChain does not make LangSmith an open-source server, and private deployment requires the Enterprise self-hosting arrangement. Skip it as your default if an open-source backend is a procurement requirement.

Langfuse: A Shared Platform You Can Also Operate

Langfuse is an open-source LLM engineering platform for tracing, evaluation, prompt management and analytics. Its core can run in Langfuse Cloud or on your infrastructure. It is a strong default when a platform engineer needs consistent records across services without making their application framework the center of the observability decision. Its self-hosting pricing page lists the MIT-licensed core and the separately licensed Enterprise capabilities.

Langfuse's wall is the work needed to make shared instrumentation meaningful. Receiving spans does not by itself establish consistent user identifiers, prompt links, score definitions or release labels. And self-hosting transfers upgrades, storage and reliability work to you. A team without an infrastructure owner should evaluate the hosted service before treating the open-source deployment as its default.

On ownership, Langfuse itself states that ClickHouse acquired it, that the team is continuing to build Langfuse, and that it remains committed to open source and self-hosting. Corporate ownership and the rights granted by the software license are separate considerations. Langfuse's announcement.

Framework Fit and Tracing

LangSmith wins convenience for a LangChain-centered application; Langfuse is the stronger default for a shared, open-source observability service. Neither recommendation means the other product is incompatible with your code.

Langfuse vs LangChain

Langfuse observes an application; LangChain helps build it by connecting models, tools, data and application logic. You can use them together. Choosing Langfuse as an alternative to LangSmith does not mean replacing LangChain in the application.

Keep the framework decision separate from the tracing decision. If your application also has a substantial retrieval layer, the LlamaIndex vs LangChain comparison helps decide that layer without turning your observability choice into an unnecessary rewrite.

Langfuse LangChain Integration

Langfuse's documented LangChain integration captures model calls, tools and retrievers through callbacks, the hooks a framework invokes as work starts and finishes. This gives a LangChain shop a credible path to Langfuse without rebuilding the application's control flow. Langfuse integration guide.

For a support assistant, inspect more than the final answer. Can you see the retrieved order, the tool arguments and the result that led to an incorrect refund response? A trace with only the outer request proves that logging works; it does not yet prove that the integration will help debug the failure.

Langfuse CallbackHandler

The CallbackHandler is the integration component that records LangChain execution events. In a pilot, attach it using the maker's current instructions and check that nested operations belong to the intended run. Also check that background export finishes in the runtime you deploy, particularly when requests run in short-lived processes.

Avoid copying an old integration snippet into a new deployment without checking SDK compatibility. The current documentation and the installed package must agree. The implementation goal is a complete, attributable execution record, not merely a green connection indicator.

Langfuse vs LangGraph

LangGraph orchestrates stateful agent workflows; Langfuse observes and evaluates their executions. LangSmith also integrates with LangGraph, including applications using LangChain modules or other SDKs. When LangChain modules are used, its guide enables tracing through environment configuration. LangSmith's LangGraph guide.

Choose LangSmith first when the same developers need to understand a graph run, inspect its model and tool activity, and feed failures into evaluations. For the distinction between the frameworks themselves, use LangChain vs LangGraph.

LangGraph Langfuse Tracing

Langfuse documents a LangGraph integration that adds trace metadata, scores and managed prompts through its LangChain integration. A graph-based application therefore does not force the purchase of LangSmith. Langfuse's LangGraph cookbook.

For a multi-framework platform, OpenTelemetry is useful because it standardizes how execution records travel. Langfuse's Python and JavaScript/TypeScript SDKs build on it, while other runtimes can export through OpenTelemetry. LangSmith also lists OpenTelemetry among its integrations. Langfuse OpenTelemetry guide, LangSmith integrations.

That common transport does not make every field interchangeable. Langfuse documents propagation of trace attributes to observations; plan how user IDs, sessions and release metadata reach the operations you will query. Test a real application path with your chosen instrumentation before declaring either backend a drop-in replacement.

Evaluations and Datasets: LangSmith Wins the Integrated Review Loop

LangSmith is the stronger default when your buying decision centers on moving a production failure through review, a reusable dataset and a release comparison. This is a workflow recommendation, not a claim that Langfuse lacks evaluations.

Both support offline evaluation, which tests a proposed change on saved examples, and online evaluation, which scores production behavior. LangSmith documents human review, code rules, model-based judges and pairwise comparisons. Langfuse documents datasets, experiments, human annotation, code evaluators, model-based judges and externally supplied scores. LangSmith evaluation, Langfuse evaluation.

For the refund assistant, a useful dataset contains the customer request, relevant order context and expected policy outcome. A code check can confirm that a required field exists. A human reviewer can judge whether the action follows policy. A model-based judge can screen for unsupported claims, but its score still needs comparison with human decisions.

This distinction prevents an expensive mistake: measuring fluent answers while missing incorrect actions. Define separate criteria for answer quality and tool behavior. Preserve difficult examples when the model produces a plausible answer for the wrong reason.

LangSmith's automation rules can route traces to datasets or annotation queues and trigger webhooks. That documented connection is why it gets the integrated-review recommendation. One implementation limit matters: separate rules poll independently. A webhook can fire before an evaluator has produced the score you expected it to contain. Establish that dependency through the downstream filter. LangSmith automation rules.

Langfuse is a good choice when you already own the evaluation runner and need a shared place for datasets, experiment results and reviewer scores. Its documentation also supports experiments in continuous integration, where a failed quality check can block a change. The deciding question is where reviewers will finish their work: within a connected product workflow, or around an evaluation process your engineers already maintain.

Prompt Management: Choose the Release Workflow

Langfuse gets the recommendation for a shared prompt service across applications; LangSmith gets it when prompt promotion belongs inside the same review workspace as your experiments. Both offer substantially more than a text editor.

Langfuse stores, versions and serves prompts centrally. Its SDK caches prompts, and its documentation connects version labels and trace links to deployment management and performance analysis. This fits an organization where domain experts maintain shared instructions used by different services. Langfuse prompt management.

LangSmith provides prompt commits, a Playground and explicit Staging and Production environments. Its management guide documents promotion, rollback history and prompt-owner controls. These are useful when the person editing an instruction should not automatically be the person promoting it to production. LangSmith prompt management.

Consider a policy prompt that changes which refunds require approval. Editing the text is easy. The consequential questions are whether production fetched the intended version, whether its evaluation passed and whether the previous version can be restored. A prompt change can alter product behavior even when the application code is unchanged.

Make your acceptance test include version identification in a trace and a deliberate rollback. Check how your application behaves when a prompt fetch fails or a cached version remains in use. Those are application responsibilities to verify, not reasons to assume either vendor guarantees every deployment pattern.

Do not move stable prompts out of version-controlled code simply because a dashboard exists. Central management earns its place when it gives editors a useful workflow and engineers a controlled release boundary.

Monitoring: LangSmith for Triage, Langfuse for Shared Analytics

LangSmith wins when an alert should start a review workflow; Langfuse is the better default when multiple services need consistent operational dashboards. Both document monitoring and alerts, so the presence of an alert checkbox should not decide the purchase.

LangSmith connects production metrics with trace investigation, online evaluations and automations. Langfuse provides dashboards and a metrics API for quality, cost, latency and volume, with threshold alerts. LangSmith observability, Langfuse metrics.

For an engineering lead, useful monitoring separates failure types. Slow retrieval calls for a different response from an unauthorized tool action; higher token usage calls for a different investigation from a declining quality score. Decide who owns each signal and which recorded example they will inspect when it fires.

Shared dashboards need shared definitions. If services attach different meanings to a score named success, the combined chart can look healthy while hiding incompatible outcomes. Define the score rubric, user and session identifiers, and release labels before comparing teams.

LangSmith automations also have a billing implication: retention-extension actions can upgrade matching traces when enabled. Review that setting alongside the review workflow. It is a reason to configure automations deliberately, not to avoid saving valuable failures. Automation retention behavior.

Open Source and Self-Hosting: Langfuse Wins Access

Choose Langfuse when self-hosting must be available without negotiating a proprietary platform license. Choose LangSmith Enterprise when you want its workflow on your infrastructure and accept the commercial arrangement. Both have a self-hosted route; only Langfuse offers the open-source core described here.

Langfuse's self-hosted pricing page includes core tracing, evaluations, prompt management and datasets under the MIT license. It also lists enterprise single sign-on (SSO), which uses your organization's identity provider, and role-based access control (RBAC), which assigns permissions through roles, in the open-source offering. More specific controls, including project-level RBAC, audit logs and data-retention policies, appear in the Enterprise offering. Check the particular control you need rather than treating “RBAC” as a complete procurement answer. Langfuse self-hosted plans.

LangSmith's own self-hosting page calls the offering an add-on to Enterprise and directs prospective users to sales for a trial license key. Its base installation includes observability, evaluation and prompt engineering; agent deployment is optional. You can therefore evaluate private LangSmith for these workflows without assuming you must also move agent execution there. LangSmith self-hosting.

Also distinguish full self-hosting from hybrid deployment. LangChain's pricing page describes hybrid as a SaaS control plane with a self-hosted data plane, while full self-hosting is self-managed in your environment. If your requirement covers management services as well as application data, have the architecture reviewed against that exact boundary.

The Operational Work You Inherit

Self-hosting Langfuse means operating its Web and Worker containers plus PostgreSQL, ClickHouse, Redis or Valkey, and object storage. Its own guide positions Docker Compose for local use and testing, without production availability, scaling or backups supplied by that setup. Langfuse deployment architecture.

The practical budget includes storage growth, upgrades, backups, recovery and someone responding when ingestion falls behind. LangSmith's private deployment likewise has application and storage services to operate. A commercial license does not remove those duties from a self-managed installation.

For a restricted environment, also map the evaluator and Playground model connections. Keeping the observability database private does not by itself establish where an evaluation sends its input. Langfuse explicitly documents optional model API or gateway connections; include those connections in the deployment design.

Do not self-host merely to avoid a small cloud subscription. Self-host because the control, inspection or deployment boundary is worth operating the system, and assign an owner before it becomes a production dependency.

Switching from LangSmith to Langfuse, or Back

The expensive part of switching is preserving the team's workflow and evidence, not changing the trace destination. Instrumentation is only one migration track.

Carry the dataset inputs, expected outcomes and score definitions first. Then recreate prompt versions and release references, evaluator configuration, reviewer access and dashboards. Decide explicitly which historical traces must remain searchable and which can stay in the previous system for their remaining retention period. Do not assume an exported record recreates the original interface, relationships or links.

OpenTelemetry can reduce instrumentation-specific work when both destinations understand the records you emit. It does not automatically migrate prompt identifiers, annotation queues, dataset references or a human review process. Treat those as application and workflow dependencies with their own acceptance checks.

A controlled migration can follow this sequence:

1. 1

   Inventory the behavior you depend on

   List trace fields, prompt references, datasets, evaluator rubrics, reviewer queues, alerts and exports. Give each an owner and an acceptance condition. Preserve the meaning of the data, not just its field names.

2. 2

   Compare a representative application path

   Use a small traffic sample or staging workload that includes successful and failed runs. Check parent-child relationships, tool arguments, prompt versions and user/session attribution in the destination. If you temporarily send to both systems, account for duplicated storage and export work.

3. 3

   Move the review and release process

   Recreate the dataset and evaluator workflow. Have the intended reviewer judge the same examples and confirm that score meanings agree. Exercise prompt promotion, rollback and the alert-to-investigation path.

4. 4

   Retire the previous dependency deliberately

   Cut over only after the required workflow works. Retain historical access for the agreed period, remove obsolete credentials and exporters, and update incident instructions so engineers know where to look.

Stay on LangSmith if the current evaluation and review loop works and the proposed switch only changes where identical traces appear. Stay on Langfuse if your common schema and evaluation process already serve the organization, unless LangSmith solves a specific task that users cannot finish efficiently today. Switching needs a workflow benefit or a deployment requirement that survives the migration effort.

Frequently Asked Questions

What is the difference between LangSmith and LangGraph?

LangGraph is a framework for orchestrating stateful agents. LangSmith is the separate platform used here for tracing, evaluation, datasets, prompt work and monitoring. Building with LangGraph does not require choosing LangSmith as your observability backend; Langfuse also documents a LangGraph integration.

Is LangSmith paid?

LangSmith has a free Developer plan and paid Plus and Enterprise offerings. The starting amounts and included trace allowances are in the comparison table above. Seats and usage are separate considerations, and self-hosting belongs to the Enterprise arrangement. Use the linked pricing page for a current quote.

Is Langfuse free to use?

Yes. Langfuse offers a limited free cloud Hobby plan and a free MIT-licensed self-hosted core. Running that core still requires infrastructure and operations. Its paid cloud and self-hosted Enterprise offerings cover different requirements, so check the feature you need in the corresponding plan table.

What are the alternatives to langfuse?

LangSmith is the direct alternative evaluated here. Favor it when its tracing-to-evaluation workflow is the reason to change. If your requirement is an open-source backend, its proprietary Enterprise self-hosting offer does not meet that same requirement.

What are the key differences between LangSmith and Langfuse?

The largest differences are the proprietary versus open-source platform, access to self-hosting, the seat-versus-unit cloud billing model, and how your reviewers use the evaluation workflow. Both provide tracing, online and offline evaluations, datasets, prompt management, monitoring and OpenTelemetry integration. Feature presence alone does not choose the winner.

Can LangSmith be self-hosted?

Yes. LangChain describes self-hosted LangSmith as an Enterprise add-on and offers a trial license through sales. Its base private installation includes observability, evaluation and prompt engineering. This is distinct from freely running the open-source LangChain or LangGraph libraries.

What are some free alternatives to LangSmith?

For the capabilities compared here, Langfuse is a free alternative through its limited cloud plan or open-source self-hosted core. Compare the practical requirements: a cloud allowance, an operated private deployment and an Enterprise support arrangement are different purchases.

What is the best self-hosted software?

For this LLM tracing and evaluation decision, Langfuse is the stronger default when open-source access is mandatory. LangSmith Enterprise can be a better fit when its review workflow is already central to your team. Neither is the best choice for every software category or every operations team.

How much does LangGraph cost?

LangChain states that the LangGraph library is MIT-licensed and free to use. Model calls, infrastructure and optional commercial platform services are separate. Do not interpret LangSmith's subscription or tracing prices as a license charge for the LangGraph library. LangChain's FAQ.

Your Next Engineering Decision

Choose the platform where your engineer and reviewer can complete the failure-to-release task under your hosting constraints. Next week, take a representative application failure, identify the operation responsible, preserve its expected outcome, evaluate a proposed fix and verify the prompt version that reaches production.

Write down the unresolved work after that exercise. For LangSmith, confirm the commercial and private-hosting requirements. For Langfuse, confirm the instrumentation schema and the operational owner. Those remaining obligations tell you more than a feature checklist.

Get the AI Business Workflow Audit Checklist to identify the workflow, owner and release controls before expanding your production tooling.