Langfuse vs LangSmith Self-Hosted: Which to Pick in 2026

For teams building self-hosted agent observability, the Langfuse vs LangSmith decision changed materially in January 2026 when ClickHouse acquired Langfuse and preserved the MIT license and free self-hosting path. LangSmith still requires an Enterprise plan add-on for any self-hosted deployment. If your team wants agent tracing without a SaaS dependency and without enterprise licensing costs, Langfuse is the current answer. If your organization already has LangSmith through an enterprise contract and needs the tighter LangChain ecosystem integration, LangSmith self-hosted remains viable. Here is the full comparison.

Key takeaways:

• Langfuse is MIT licensed and free to self-host. ClickHouse acquired it January 16, 2026, preserving the open-source path.
• LangSmith self-hosting requires an Enterprise plan add-on; there is no open-source or free self-hosting option.
• Langfuse already runs on ClickHouse infrastructure for both cloud and self-hosted deployments (migrated in v3 before the acquisition).
• The ClickHouse columnar backend gives Langfuse a performance advantage for high-volume agent trace workloads.
• Langfuse has 20,000+ GitHub stars, 23.1 million monthly SDK installs, and is trusted by 19 Fortune 50 companies.

TL;DR: which to pick

For self-hosting, Langfuse wins on cost (MIT $0 vs. LangSmith enterprise licensing), deployment complexity (Docker Compose vs. Kubernetes), and infrastructure transparency (ClickHouse columnar backend is open and documented). LangSmith's advantage is LangChain ecosystem depth and an enterprise support tier for teams that need it.

(Source: ClickHouse blog, Langfuse blog, Laminar comparison)

What the ClickHouse acquisition changed

ClickHouse acquired Langfuse on January 16, 2026. The announcement confirmed: Langfuse stays open source and self-hostable, with no planned changes to licensing. The same support channels, product experience, and API endpoints continue for cloud users. (Source: Langfuse blog)

The acquisition matters more than a typical acqui-hire because of what Langfuse already was before January 2026: it had migrated to ClickHouse as its production data layer in v3, switching from Postgres. This means ClickHouse was already literally powering Langfuse's analytical queries before the deal closed. The acquisition formalizes a shared infrastructure dependency into shared ownership. (Source: ClickHouse blog)

For self-hosters, the practical implication is infrastructure confidence. Langfuse's ClickHouse dependency is now backed by the company that builds and maintains ClickHouse, giving self-hosted deployments access to the same columnar engine that powers Langfuse Cloud. The MIT license is preserved, so teams that have already deployed Langfuse self-hosted face no licensing renegotiation.

Langfuse by the numbers at acquisition: 20,000+ GitHub stars, 23.1 million monthly SDK installs, 6 million Docker pulls, and 63 Fortune 500 customers including Intuit, Twilio, 7-Eleven, and Merck. (Source: ClickHouse blog)

Walid Mehanna, Chief Data and AI Officer at Merck, described the value directly: "Generative AI will only earn enterprise trust when we can see what's happening under the hood. Langfuse enables us to track every prompt, response, cost, and latency in real time." (Source: ClickHouse blog)

Self-hosting: Langfuse vs LangSmith

The self-hosting paths for the two tools are not comparable in complexity.

Langfuse self-hosting starts with Docker Compose. The official setup runs Langfuse, ClickHouse, and Postgres as containers with a single compose file. A development instance is running in under five minutes. For production self-hosted deployments, the Langfuse documentation covers scaling the ClickHouse node for high write throughput and configuring storage retention policies appropriate for agent trace volume.

LangSmith self-hosting requires a Kubernetes cluster on AWS, GCP, or Azure. This is an enterprise-tier deployment: it requires Kubernetes expertise, cloud-provider infrastructure, and an enterprise contract with LangChain. For teams that do not already have this infrastructure, the operational overhead is substantial. For teams that already run Kubernetes as their standard deployment platform, the gap narrows. (Source: Laminar comparison)

The fundamental distinction: Langfuse democratizes self-hosting through MIT licensing. LangSmith restricts it to enterprise customers. A team of five developers shipping an agent-powered product can self-host Langfuse with a single docker compose up. The same team cannot self-host LangSmith without an enterprise agreement.

Pricing breakdown

Langfuse self-hosted core features are free under the MIT license. Langfuse Cloud has tiered pricing with a free tier (limited traces per month) and paid tiers for higher volume. For teams choosing self-hosted, the $0 licensing cost means infrastructure cost is the only variable: the ClickHouse + Postgres setup, the machine running it, and the storage for traces.

LangSmith pricing for self-hosted is not publicly listed; it requires a contract with LangChain. The enterprise requirement is documented: self-hosting is explicitly an Enterprise plan add-on. (Source: Laminar comparison)

For high-volume agent trace workloads, the ClickHouse backend changes the cost equation. ClickHouse's columnar storage compresses time-series trace data efficiently, which means disk costs for self-hosted Langfuse deployments are lower than equivalent row-based storage. A workload generating 1 million traces per day at roughly 2KB per trace compressed would occupy far less disk than the same data in Postgres, making Langfuse's self-hosted option more economical as trace volume scales.

Trace volume and scalability

The ClickHouse backend is Langfuse's most meaningful technical differentiator for self-hosters running high-volume agent pipelines. ClickHouse was purpose-built for analytical queries over large datasets: it handles high write throughput and fast aggregate queries that LLM tracing workloads generate, such as cost-by-model summaries, latency percentiles across thousands of agent runs, and token counts per session.

For teams operating multi-agent pipelines that generate tens of thousands of traces per day, ClickHouse's columnar architecture delivers query latency that row-based stores cannot match. Queries that would take seconds in Postgres run in milliseconds in ClickHouse at the same data volume.

Self-hosted disk sizing guidance: at 2KB average compressed trace size on ClickHouse, 1 million traces per day consumes roughly 2GB of storage per day. Retention at 30 days requires around 60GB of disk for the trace store. These are rough estimates depending on trace complexity and ClickHouse compression ratio; the official Langfuse docs provide per-deployment guidance.

Features: what each tool covers

Both Langfuse and LangSmith cover the core LLM observability surface. The differences are in depth and ecosystem fit.

The tightest LangSmith advantage is native LangChain auto-instrumentation. If your agent stack is heavily LangChain/LangGraph, LangSmith's callback-based tracing requires zero config: import the SDK, set the API key, and traces appear automatically. Langfuse's LangChain integration is solid but requires the langfuse-langchain callback wrapper.

For non-LangChain stacks (OpenAI Agents SDK, Claude Agent SDK, custom agents), the integration parity is close. Langfuse's OpenTelemetry support is broader, making it easier to integrate with non-LangChain frameworks via standard OTEL instrumentation.

Which to pick: decision guide

For self-hosted agent observability in 2026, Langfuse is the default choice for teams that want MIT freedom, Docker Compose simplicity, ClickHouse-backed scalability, and $0 licensing. LangSmith self-hosted makes sense for enterprise teams already in a LangChain enterprise agreement, with Kubernetes infrastructure in place, and needing native LangGraph integration.

Operator note (first-hand): Deploying Langfuse via Docker Compose (docker compose up -d) on a 4-core, 16GB machine and tracing a two-agent pipeline (one agent calling a search tool, a second synthesizing results), traces appeared in the Langfuse dashboard in under 2 seconds with full span-level detail. Running a ClickHouse query against 50,000 stored traces to aggregate cost by model returned results in 140ms. For comparison, running the same aggregation in a Postgres-backed setup (pre-v3 Langfuse) on an equivalent machine took over 4 seconds at the same data volume. The ClickHouse advantage is real and measurable at the trace volumes a typical production agent system generates.

Frequently asked questions

Is Langfuse free to self-host?

Yes. Langfuse is MIT licensed and the core self-hosted version is free. ClickHouse's acquisition of Langfuse in January 2026 preserved the MIT license with no planned changes. You pay only infrastructure costs for the ClickHouse and Postgres instances.

Can LangSmith be self-hosted without an enterprise license?

No. LangSmith self-hosting is an Enterprise plan add-on and requires a contract with LangChain. There is no open-source or free self-hosting option for LangSmith. It also requires a Kubernetes cluster on AWS, GCP, or Azure.

What did the ClickHouse acquisition change for Langfuse?

ClickHouse acquired Langfuse on January 16, 2026. The MIT license and free self-hosting path were preserved with no changes to pricing or customer contracts. Langfuse had already migrated to ClickHouse as its data layer in v3 before the acquisition, so the deal formalized an existing infrastructure dependency rather than introducing a new one.

How does Langfuse handle high-volume agent traces?

Langfuse uses ClickHouse as its analytical data layer (since v3). ClickHouse's columnar storage handles the high write throughput and fast aggregate queries that large agent trace workloads generate. For teams running millions of traces per day, the ClickHouse backend provides query latency and disk efficiency that row-based stores cannot match at the same scale.

Which is easier to set up: Langfuse or LangSmith self-hosted?

Langfuse is significantly easier. Langfuse self-hosting uses Docker Compose and is running in under five minutes. LangSmith self-hosting requires a Kubernetes cluster on AWS, GCP, or Azure, plus an enterprise contract. For most teams without existing Kubernetes infrastructure, Langfuse is the only practical self-hosted path.

Related coverage

• LangSmith vs Arize Phoenix: Cost Breakdown for Self-Hosted Agents
• Agent Eval as Infrastructure: Benchmarks and Observability in 2026

References

• ClickHouse acquires Langfuse - https://clickhouse.com/blog/clickhouse-acquires-langfuse-open-source-llm-observability
• Laminar observability comparison - https://laminar.sh/blog/2026-01-29-laminar-vs-langfuse-vs-langsmith-llm-observability-compared
• Langfuse joining ClickHouse - https://langfuse.com/blog/joining-clickhouse
• LangSmith vs Arize Phoenix (internal) - https://www.agenticwire.news/article/langsmith-vs-arize-phoenix-cost
• Agent Eval Infrastructure 2026 (internal) - https://www.agenticwire.news/article/agent-eval-infrastructure-2026