Langfuse

Langfuse is an open-source LLM engineering platform built for teams shipping AI applications to production. Founded in 2023 by three engineers out of Y Combinator's W23 cohort, it tackles a problem every AI developer hits within the first few weeks of production deployment: you have no visibility into what your LLM is actually doing. Langfuse gives teams structured observability, prompt management, evaluation pipelines, and dataset tooling in one platform, with a genuine MIT-licensed self-host option that runs on Docker, Kubernetes, or cloud-managed infrastructure. In January 2026, ClickHouse acquired Langfuse alongside a $400 million Series D, bringing substantial engineering resources to performance and enterprise reliability while keeping the open-source commitment and pricing unchanged.

The platform instruments AI applications via Python and TypeScript SDKs or through auto-instrumentation integrations with LangChain, LlamaIndex, OpenAI, Haystack, and 20+ other frameworks. Every LLM call, tool invocation, retrieval step, and user interaction becomes a structured trace with token counts, latency, cost attribution, and full input/output capture. From there, teams run LLM-as-judge evaluators, attach human annotation queues, manage versioned prompts with A/B testing, and benchmark across curated datasets. Langfuse Cloud runs on a ClickHouse-backed data layer introduced in v3 (December 2024), which handles hundreds of ingestion events per second without database bottlenecks. The GitHub repository has 26,300+ stars and ships releases continuously, with v3.171.0 landing in late April 2026.

What Langfuse actually does in April 2026

Langfuse sits between your application code and the LLM APIs you call, but not as a proxy. Unlike Helicone's URL-swap approach, Langfuse uses SDK-level instrumentation: your code explicitly creates traces and spans, and Langfuse captures the full execution tree. This gives you more control and more context, at the cost of more integration work upfront.

A single trace can contain dozens of nested observations: an outer agent span wrapping a retrieval call, an LLM generation, a tool execution, and a final formatting step. Each node records its own latency, token cost, and input/output. When something breaks at 2am, you pull the trace ID from your logs, open Langfuse, and have the complete decision tree in front of you rather than guessing from log fragments.

Beyond tracing, the platform covers three adjacent workflows that observability tools often omit:

• Prompt management: Store prompt templates with version history, promote versions across environments, and run A/B experiments. Changes stay out of source code and can be rolled back without a deployment.

• Evaluation: Run LLM-as-judge evaluators on sampled traces automatically, collect user feedback (thumbs up/down, star ratings), and route traces to human annotation queues for manual review.

• Datasets: Curate traces into structured test datasets and run regression benchmarks across prompt versions or model upgrades before shipping.

The March 2026 release shipped an observations-centric data model with a 10x improvement in dashboard load times, addressing a recurring complaint about UI responsiveness at higher trace volumes.

Where Langfuse sits versus LangSmith and Helicone

Three tools dominate this space, and the differences are architectural, not cosmetic.

LangSmith is LangChain's proprietary observability product. If your entire application stack is LangChain or LangGraph, LangSmith is genuinely zero-friction: set an environment variable, and automatic tracing covers all your chains without touching application code. The moment you step outside the LangChain ecosystem, that advantage disappears and you need manual instrumentation anyway. LangSmith is closed-source with no self-hosting option, which eliminates it for teams with data residency requirements. Free tier: 5,000 traces/month. Starter: $39/month.

Helicone takes the opposite architecture: a proxy that sits between your code and the LLM API. You redirect your base URL through Helicone's servers and add an API key header. Setup takes about 15 minutes and requires zero changes to application logic. The tradeoff is that all traffic passes through Helicone's infrastructure, which creates a third-party dependency on the critical path. Helicone's semantic caching feature (similar prompts return cached responses) can produce 20-40% cost savings on some workloads, which Langfuse does not offer. But Helicone lacks Langfuse's prompt versioning, A/B testing, evaluation pipeline, and dataset management. Free tier: 50,000 requests/month. Starter: $20/month.

Langfuse is framework-agnostic and requires explicit SDK instrumentation throughout your code. The setup investment is higher (a few hours vs. Helicone's 15 minutes), but the result is the most complete observability picture: nested spans, full agent execution trees, human feedback loops, and prompt lifecycle management. The self-hosting option is genuinely functional and has been a first-class deployment target since the project launched. One caveat: Langfuse uses its own tracing format rather than native OpenTelemetry, which has surfaced as a concern among teams standardizing on OTel across their stack.

"What we really loved about Langfuse was the open API. While many tracing tools require specific SDKs or wrappers, Langfuse's open API enabled us to build our own Golang client around it." - Walt Wells, Staff Software Engineer, Khan Academy, 2024

"We spend 60k+ every month on LLM calls, so having the backbone to debug when things go haywire has helped a lot." - punkpeye, Hacker News, December 2024

What the instrumentation and observability workflow reality looks like

In practice, Langfuse integration starts with a one-time SDK setup and a decision about how deeply to instrument your code. The simplest path uses auto-instrumentation with OpenAI or LangChain wrappers, where a few import-level decorators capture every LLM call without manual span creation. For custom agent loops or multi-step pipelines, you instrument explicitly: wrap each meaningful unit of work in a trace or span, attach inputs/outputs, and let the SDK handle batching and async upload.

Once traces flow in, the dashboard gives you per-model cost breakdowns, P50/P95/P99 latency, error rates, and user-level session views. The search is fast enough that debugging a specific user complaint is a minute's work: query by session ID, open the trace, and step through the execution tree.

The Langfuse Cloud version runs on the same ClickHouse-backed architecture introduced in v3, handling traffic spikes without ingestion pressure backing up to the API. The v3 architecture writes events to S3 immediately on receipt, queuing before database insertion, which means a database slowdown does not drop inbound traces.

Khan Academy's Khanmigo team illustrates the production workflow: after deploying Langfuse in April 2024 across 100+ users spanning 7 product teams and 4 infrastructure teams, support staff use Langfuse traces as their first debugging tool when a student reports a problem. Walt Wells, Staff Software Engineer at Khan Academy, noted the outcome directly: "Langfuse has enabled our developers to get extremely fast feedback." Khan Academy keeps average support resolution under 8 minutes by pulling the relevant session trace rather than reconstructing context from logs.

Who Langfuse is built for

Langfuse fits best when three conditions are true: the team is shipping LLM features to real users (not just evaluating models in notebooks), someone on the team owns LLM infrastructure, and data residency or open-source licensing matters either commercially or legally.

Practically, this means ML engineers and AI platform teams at companies building on top of LLMs rather than selling LLM API access itself. Langfuse is the right call for teams using mixed frameworks (LlamaIndex for retrieval, custom Python for agents, OpenAI for generation), because the framework-agnostic SDK covers the full stack without per-framework setup. It is also the right call for regulated industries (healthcare, finance, education) that cannot send production data to a third-party SaaS with no self-host option.

The ClickHouse acquisition strengthens the enterprise case: SOC2, ISO27001, and HIPAA compliance reports are available on the Pro plan, the team is backed by a company with deep infrastructure credibility, and the open-source commitment is more durable now that it is part of a well-funded organization rather than a seed-stage startup.

What Langfuse is not

Langfuse is not a zero-effort plug-and-play tool for developers who want a cost dashboard up in 15 minutes. If your entire use case is "how much am I spending on OpenAI," Helicone's proxy setup gets you there faster. Langfuse earns its integration investment when you need the full picture: nested execution trees, prompt versioning, evaluations, and human feedback, not just token counts.

Self-hosting is free but not simple. Langfuse v3 requires five services running in coordination: web container, worker container, ClickHouse, Redis/Valkey, and S3-compatible blob storage. Teams without existing ClickHouse infrastructure face real operational overhead. Independent estimates put medium-scale self-host total cost of ownership at $3,000-4,000/month including DevOps time, compared to $199-300/month for equivalent usage on Langfuse Cloud Pro. "Free" applies to the license, not the infrastructure.

Langfuse also does not offer semantic caching or LLM API cost-reduction features. If reducing API spend is the primary goal, that is Helicone's territory.

Skip Langfuse if you are: a solo developer running a weekend project without production users, a team already fully invested in LangChain who wants zero-configuration automatic coverage, or a company that needs OpenTelemetry-native tracing to integrate with an existing OTel collector infrastructure.