Langfuse vs Braintrust vs Helicone: Choosing an LLM Observability Stack in 2026

Last updated: July 30, 2026

Once an agent or LLM feature ships, the question stops being "does it work in the demo" and becomes "did last night's prompt edit quietly make it worse for 5 percent of users." That question needs traces, evals, and cost data, not vibes. Three names come up constantly when teams build that layer: Langfuse, Braintrust, and Helicone. They overlap heavily on paper - all three log traces, all three can run evals, all three track cost and latency - but they start from different centers of gravity, and that starting point matters more than the feature checklist once you are living in the tool daily.

This is a fair, sourced comparison: what each product is built around, how integration and pricing actually work, and a decision guide by team shape and workload. For the broader argument that evals need more rigor than a benchmark number, see why agent evals need baseline receipts; for the token-cost side of this problem specifically inside Claude Code, see Claude Code token burn and cache observability.

Langfuse: Open-Source Tracing as the Foundation#

Langfuse's center of gravity is tracing. The docs describe a data model of traces, observations (spans, generations, events), and scores, captured through SDKs for Python and JS/TS or native integrations with frameworks like LangChain, LlamaIndex, and the Vercel AI SDK, plus an OpenTelemetry-compatible ingestion path. On top of tracing it ships prompt management (versioned prompts with a UI-editable "playground"), datasets for regression testing, and both LLM-as-judge and human-annotation evaluation workflows, all built on the same trace data rather than a separate pipeline.

The project is fully open source (MIT-licensed core, github.com/langfuse/langfuse) and self-hostable via Docker Compose or a Helm chart for Kubernetes, which is the feature teams with data-residency requirements reach for first. The hosted version has a free Hobby tier, then flat-fee Core and Pro plans that include a monthly allotment of usage units with graduated overage pricing beyond that, and an Enterprise tier adding audit logs, SCIM, custom rate limits, and a support SLA - see pricing for current tier names and numbers, since usage-unit pricing changes more often than plan structure.

The honest read: Langfuse is the strongest pick when self-hosting or data ownership is a hard requirement, or when the team wants tracing and prompt management under one open-source roof without paying a per-request tax to a closed vendor. Its eval tooling is capable but was clearly built second, after tracing; teams whose primary daily workflow is running structured regression evals sometimes find Braintrust's eval loop more purpose-built.

Braintrust: Evals as the Primary Workflow#

Braintrust starts from the opposite direction: the eval loop is the product, and tracing/logging support it. The core workflow is Eval() - run a scored comparison of a prompt or pipeline against a dataset, inspect results in the UI, iterate, and promote the winner. Scoring functions can be code-based (deterministic assertions), LLM-as-judge (with Braintrust's own autoevals library), or human review, and Braintrust computes statistical significance between eval runs rather than just a raw score delta, which matters when the underlying model is non-deterministic.

Production logging and tracing exist and integrate with the same eval surface: a production trace can be pulled directly into a dataset to become a regression test, closing the loop from "user hit a bad case" to "now it is permanently covered." Braintrust also ships a proxy/gateway for routing across model providers with response caching. It is closed-source; pricing is usage-based (data processed, token volume, and eval-score overages) with a free Starter tier and a custom Enterprise tier adding SSO and higher data-retention limits.

The tradeoff is the mirror image of Langfuse in most respects, but not on self-hosting itself: Braintrust's self-hosting docs describe a split control-plane/data-plane deployment (you run the data plane in your own AWS/GCP/Azure account via Terraform, Braintrust hosts the control plane and UI) plus a "bring your own cloud" option, so full data residency is possible without running the whole stack yourself the way Langfuse's Docker/Helm self-host does. It is not open source, so vendor lock-in on the platform layer itself is still a real consideration, and pure logging/proxy use cases pay for eval infrastructure they may not touch daily. But for teams whose actual pain is "we ship prompt changes and have no idea if they regressed," Braintrust's dataset-and-eval loop is the more direct path to an answer.

Helicone: A Drop-In Proxy for Logging and Cost#

Helicone's center of gravity is integration friction, or the lack of it. The most common setup, per the quickstart, is changing a base URL to route calls through Helicone's proxy and adding an auth header - no SDK required, works with the OpenAI, Anthropic, and other provider SDKs unmodified. That proxy position gives Helicone request/response caching, rate limiting, and API key management for free alongside logging, since it sits directly in the request path rather than receiving traces asynchronously. For teams that do not want a proxy in the hot path, Helicone also supports async logging via SDK or OpenTelemetry.

Feature-wise it covers cost and latency dashboards per model/user/session, prompt versioning, and evaluators (including LLM-as-judge and integration with external eval frameworks), plus session grouping for multi-step agent traces. It is open source (github.com/Helicone/helicone) and self-hostable, with a hosted free Hobby tier (capped monthly requests) and paid Pro/Team/Enterprise tiers layering usage-based overages for requests and storage on top of a flat monthly base - see pricing for current numbers, since plan pricing changes more often than the proxy architecture.

The honest read: Helicone is the fastest to bolt onto an existing app that just needs logging, cost attribution, and caching without restructuring code around an SDK, and the proxy model gives operational features (rate limiting, caching) the other two do not offer natively. Its eval and prompt-management surfaces are real but thinner than Braintrust's dataset-driven workflow or Langfuse's integrated prompt versioning, so teams that outgrow "log and monitor" into "systematically test every prompt change" often end up pairing Helicone's proxy with a dedicated eval tool, or migrating.

Decision Guide#

• Self-hosting or data residency is a hard requirement - Langfuse or Helicone are the simpler path; both are open source and Docker/Helm deployable end to end. Braintrust can meet data-residency needs too via its split control-plane/data-plane deployment or bring-your-own-cloud option, but it is closed source and the setup is more involved than a single Docker Compose file.
• The daily pain is "did this prompt change regress anything" - Braintrust's Eval() and dataset workflow is the most direct fit, with statistical comparison built in rather than bolted on.
• The goal is to add observability to an existing integration with minimal code change - Helicone's proxy (change the base URL) is the lowest-friction start; add the eval and prompt layers later if needed.
• The team wants one open-source system covering tracing, prompt management, and evals without picking three vendors - Langfuse is the broadest single surface, at the cost of each individual piece being slightly less deep than a specialist tool.
• Cost is the primary lens (not just eval quality) - Helicone's proxy position gives the most direct per-request cost and caching story; Langfuse and Braintrust both report cost but do not sit in the request path by default.

None of these are mutually exclusive in practice - it is common to see Helicone or an OTel collector doing the logging/proxy layer while Braintrust or Langfuse's eval surface handles regression testing on top of the same trace data. Pick the one whose primary workflow matches the problem that is actually costing the team time this quarter, not the one with the longest feature list.

FAQ#

Is Langfuse actually free to self-host, or does it require a paid license?#

The Langfuse core is MIT-licensed and the self-hosted deployment is free to run; some enterprise features (advanced RBAC, certain SSO providers) are gated behind a commercial license on top of the open-source core. Check the current self-hosting docs for which features require a license key.

Can Braintrust be self-hosted?#

Partially. Braintrust is not open source, but it supports a split deployment where you run the data plane (API, database, storage) in your own AWS, GCP, or Azure account via Terraform while Braintrust hosts the control plane and UI, plus a "bring your own cloud" option for teams that want the deployment to live in their infrastructure. See the self-hosting docs for current requirements and which plans include it, since this is a more involved setup than Langfuse or Helicone's single-container self-host.

Does using Helicone's proxy add latency to every LLM call?#

Helicone's proxy adds a network hop, but it is designed to sit close to model provider endpoints and the added latency is typically small relative to LLM inference time itself; Helicone also publishes an async-logging integration path for teams that want to avoid a proxy in the hot path entirely. Benchmark it against your own latency budget rather than trusting a generic claim, since egress region and provider both affect the number.

Do I need all three of these tools?#

Usually not to start. Most teams begin with whichever tool matches their most acute pain (cost visibility, regression testing, or unified tracing) and add a second tool later once the first workflow is solid. Running all three from day one is common only in larger organizations where different teams already standardized on different tools before consolidating.

How do these compare to LangSmith?#

LangSmith is LangChain's own observability and eval product, tightly integrated with the LangChain and LangGraph ecosystem specifically. Langfuse, Braintrust, and Helicone are all framework-agnostic and work equally well with raw SDK calls, LangChain, or any other orchestration layer.

Continue Reading#

• AI Agent Eval Tools Compared: Braintrust vs Promptfoo vs DeepEval - eval tools specifically, rather than full observability platforms
• Self-Hosted vs Managed AI Gateways: A Decision Guide - the gateway layer that often pairs with observability
• Prompt Management Tools Compared - prompt versioning and management tools