Langfuse vs Braintrust vs Helicone: Agent Tracing Tools in 2026

Pick Langfuse if you want open-source, self-hostable agent tracing with prompts and evals in one tool, and pick Braintrust if running regression evals is the daily job. Treat Helicone as a proxy you keep, not one you adopt: it was acquired by Mintlify in March 2026 and now runs in maintenance mode. LangSmith is the seat-priced option that fits teams already on LangChain or LangGraph, and Arize Phoenix is the local-first tracer you can start with one command. Whichever you choose, export plain OpenTelemetry so the backend stays swappable.

Last updated: October 8, 2026

That last point matters more in 2026 than it did a year ago. Agent runs are now long trees of model calls, tool executions and sub-agent hand-offs, and four of the five tools here (Langfuse, Braintrust, LangSmith and Phoenix) accept OTLP traces directly. Helicone is the exception: it logs through its proxy or its own async SDK, with no documented OTLP endpoint. The OpenTelemetry GenAI semantic conventions now define names for exactly those agent steps, so the instrumentation you write once can feed any of those four backends. For why traces are the receipts that make agent evals trustworthy, see why agent evals need baseline receipts; for running the same traces locally before anything reaches a vendor, see local OpenTelemetry traces as agent receipts.

At a glance: pricing, self-hosting, and OTLP#

Prices are list prices from each vendor's pricing page on October 8, 2026. All five list a free tier, though Helicone Cloud has closed new signups.

Two caveats on reading that table. The units are not comparable: Langfuse bills "units", Braintrust bills processed gigabytes plus scores, LangSmith bills traces plus seats, and Arize bills spans. A single agent run can be one LangSmith trace but dozens of Langfuse units or Arize spans, so price a real week of your own traffic before comparing. And retention differs sharply on free tiers, from 7 days (Helicone) to 30 days (Langfuse).

Langfuse: open-source tracing, now on v4#

Langfuse's center of gravity is tracing, with prompt management and evals built on the same data. Its pricing page lists agent traces and graphs, session tracking, user tracking, token and cost tracking, SDKs for Python and JavaScript, native framework integrations, an OpenTelemetry path for other languages, and proxy-based logging via LiteLLM on every tier. On top of that it ships versioned prompts with a playground, datasets, experiments, LLM-as-judge evaluators and human annotation queues.

Two 2026 changes matter. First, ClickHouse acquired Langfuse in January 2026; the team's stated position is that Langfuse stays open source and self-hostable with no licensing changes planned. Second, Langfuse v4 shipped on August 17, 2026 with a denormalized, append-only observations table, so every LLM call, tool execution and agent step can be queried directly. Langfuse says initial table loads over large datasets drop from seconds to milliseconds. v4 also brings monitors for cost, quality and latency thresholds, deterministic code evaluators, and full-text search across observation inputs and outputs. Langfuse Cloud becomes v4-only on November 16, 2026, and the fast path needs Python SDK 4.7.0+ or JS/TS SDK 5.4.0+. Self-hosters have no forced cutover, and v3 gets security patches through January 2027.

Pricing: Hobby is free with 50k units a month, 30 days of data access and 2 users. Core is $29/month with 100k units included, then $8 per 100k units (graduated down to $6 per 100k above 50M), 90 days of data and unlimited users. Pro is $199/month with 3 years of data, a HIPAA-ready region and higher rate limits, with a $300/month Teams add-on for enterprise SSO and fine-grained RBAC. Enterprise starts at $2,499/month.

Self-host: the self-hosted plan is free under the MIT license, with "all core platform features and APIs". The self-hosting guide recommends Docker Compose for local use and testing, and Kubernetes via Helm or its AWS, Azure and GCP guides for production. A paid self-hosted Enterprise tier adds audit logs, project-level RBAC, data retention policies and management APIs.

OTLP: Langfuse receives traces on /api/public/otel over HTTP/JSON or HTTP/protobuf; gRPC is not supported yet. It maps incoming OTel attributes, including popular GenAI ones, onto its own data model.

Best for: teams that need data ownership or self-hosting, or want tracing, prompts and evals under one open-source roof.

Braintrust: evals first, tracing feeding them#

Braintrust starts from the other end. The eval loop is the product: run a scored comparison of a prompt or pipeline against a dataset, inspect the results, iterate, and promote the winner. Scores can come from LLM-as-judge, from Braintrust's open-source autoevals library, from custom code scorers, or from human review. Production traces feed the same loop: Braintrust's docs describe promoting traces from logs into a dataset, so a bad production response becomes a test case. The pricing page also lists Loop, a built-in agent that can run evaluations, generate test cases and iterate on prompts.

For agent tracing, Braintrust accepts OpenTelemetry traces at https://api.braintrust.dev/otel with an Authorization bearer key and an x-bt-parent header that names the project or experiment. It converts incoming LLM calls into Braintrust LLM spans, which can then be saved as prompts and evaluated in the playground.

Pricing: Starter is $0/month with $10 of model credits, 1 GB of processed data (then $4/GB), 10k scores (then $2.50 per 1,000), 14-day retention and unlimited users, projects and experiments. Pro is $249/month with $100 of credits, 5 GB (then $3/GB), 50k scores (then $1.50 per 1,000), 30-day retention (extendable at $0.50/GB/month), custom charts and RBAC. Enterprise is custom.

Self-host: Braintrust is closed source. Its self-hosting docs say self-hosting is Enterprise-only and split: you run the data plane (API, PostgreSQL, Redis, object storage and the Brainstore query engine) in your own AWS, GCP or Azure account via official Terraform modules, while Braintrust hosts the UI, authentication and metadata. For data residency without operating the data plane yourself, the same docs point to a BYOC option in which Braintrust runs the deployment in your cloud.

Best for: teams whose real pain is "we ship prompt changes and cannot tell what regressed." For a deeper look at the eval layer alone, see our Braintrust vs Promptfoo vs DeepEval comparison.

Helicone: proxy-first, now in maintenance mode#

Helicone's pitch was integration friction, or the lack of it: change a base URL, add an auth header, and every request flows through its proxy with logging, cost tracking, caching, rate limits and automatic fallbacks. Teams that do not want a proxy in the hot path can use Helicone's async integration: the @helicone/async npm package (or helicone-async for Python) wraps your provider clients, uses OpenLLMetry instrumentation, and logs to Helicone off the critical path. Helicone's proxy vs async comparison notes the trade-off: the async path cannot offer the proxy's gateway tools such as caching and rate limiting. Sessions group multi-step agent runs. What Helicone does not document is an OTLP ingest endpoint, so unlike the other four tools here, a generic OpenTelemetry exporter cannot simply be pointed at it.

The 2026 news is structural. On March 3, 2026, Helicone announced it had been acquired by Mintlify. In the founders' words, the service will "remain live for the foreseeable future in maintenance mode", with security updates, new models, and bug and performance fixes continuing to ship. That is a reasonable reason to keep a working Helicone integration, and a weak reason to start a new one if you expect new agent-tracing features.

Pricing: Hobby is free with 10,000 requests, 1 GB of storage, one seat and 7-day retention. Pro is $79/month plus usage-based pricing, with unlimited seats, alerts, reports and one month of retention. Team is $799/month with 5 organizations, SOC 2 and HIPAA compliance and 3 months of retention. Enterprise adds SAML SSO and on-prem deployment. Check before planning around those tiers: Helicone Cloud's signup page now reads "Sign ups are disabled", so in practice they apply to existing accounts.

Self-host: the repository is Apache-2.0 and the self-hosting docs cover Docker and Kubernetes via Helm.

Best for: existing deployments that value the proxy's caching and cost controls. If what you mainly want is a gateway, compare it against the options in our self-hosted vs managed AI gateway guide.

LangSmith: seat-priced, deepest in the LangChain stack#

LangSmith is LangChain's tracing and eval platform, and it is no longer LangChain-only: it accepts OpenTelemetry traces at https://api.smith.langchain.com/otel with an x-api-key header, with EU, APAC and AWS US regional endpoints. The pricing page lists tracing, monitoring, online and offline evals, dataset collection, annotation queues and a prompt hub on every plan. Around it sit agent-specific products: Deployment for long-running agents, Fleet for no-code agents (every Fleet run is traced automatically), and Engine, which runs every 6 hours to cluster agent behavior into issues, diagnose failures and propose fixes with eval coverage. We covered the on-call pattern Fleet points at in LangSmith Fleet turns agent ops into on-call work.

Pricing: Developer is $0 for one seat with 5k base traces a month. Plus is $39 per seat per month with 10k base traces, then pay-as-you-go. Base traces keep 14 days of retention; extended traces keep 180 days for an extra fee. Engine, Fleet and Sandboxes are metered in LangChain Standard Units at $1 per LSU.

Self-host: Developer and Plus are cloud-only (US or EU). Enterprise adds a hybrid option (LangChain control plane, your data plane) and a fully self-hosted option in your VPC.

Best for: teams already building on LangChain or LangGraph, and teams that want deployment, tracing and evals from one vendor.

Arize Phoenix: local-first and OTel-native#

Phoenix is Arize's open tracing and eval tool, and it is the only one on this list designed to run on your laptop first. The official quickstart starts it with one command and serves the UI at http://localhost:6006:

uvx arize-phoenix serve

(Command copied from the Phoenix docs.) Phoenix is built on OpenTelemetry, accepts OTLP traces, and uses the OpenInference instrumentation for auto-instrumenting frameworks (LlamaIndex, LangChain, DSPy, Mastra, the Vercel AI SDK), providers (OpenAI, Bedrock, Anthropic) and languages (Python, TypeScript, Java). Traces capture model calls, retrieval, tool use and custom logic; evals can be LLM-based, code-based or human labels; prompts can be versioned and replayed against real spans.

Pricing: Phoenix itself is free to self-host on Docker or Kubernetes. Its license is the Elastic License 2.0, which permits self-hosting but not reselling Phoenix as a managed service. Arize's managed product, Arize AX, has a free tier (25k spans a month, 1 GB, 15-day retention), AX Pro at $50/month (50k spans, 10 GB, 30-day retention), and AX Enterprise with custom limits and a self-hosted option. AX lists agent trajectory visualizations and trace-level evals of agent trajectories.

Best for: developers who want to see agent traces locally today, and teams that want an OTel-native tool with a managed upgrade path.

The OpenTelemetry GenAI conventions are the real hedge#

The OpenTelemetry GenAI semantic conventions now live in their own repository, open-telemetry/semantic-conventions-genai, after moving out of the main semantic-conventions docs. They define spans, metrics and events for GenAI clients, MCP and provider-specific behavior. For agents, the agent spans spec names the operations that make up an agent trace:

• invoke_agent for an agent invocation, with the span named invoke_agent {gen_ai.agent.name} when the name is known
• execute_tool for each tool call, including refinements for loading agent skills
• create_agent, invoke_workflow and plan for agent creation, multi-agent workflows and planning steps
• attributes such as gen_ai.provider.name (required), gen_ai.agent.name, gen_ai.conversation.id, gen_ai.usage.input_tokens and gen_ai.usage.output_tokens

Every one of those is still marked Development, not stable, and names do move. That is why backends map attributes rather than require an exact schema; Langfuse says so explicitly in its OTel docs. The practical rule: instrument against these conventions, export OTLP, and keep the backend a configuration choice. Switching from Phoenix on a laptop to Langfuse or LangSmith in production should be an endpoint and a header, not a rewrite.

What we run: OTLP from instrumentation.ts#

This site follows that rule. Its Next.js instrumentation.ts registers @vercel/otel at server boot, before any model provider is imported, so AI SDK spans inherit the global tracer. Registration only happens when OTEL_EXPORTER_OTLP_TRACES_ENDPOINT or OTEL_EXPORTER_OTLP_ENDPOINT is set and OTEL_SDK_DISABLED is not true; without an endpoint, nothing is exported. The standard OTEL_* variables choose the exporter and sampler, the service name defaults to developers-digest-site, and every span carries the deployment environment and the git commit as resource attributes.

The main chat route, the agent runtime, artifact runs, scheduled tasks and app builds opt into AI SDK telemetry through a small helper that defaults to metadata only: recordInputs and recordOutputs are false, so prompts and completions never leave the process. The installed AI SDK still tags its model spans with gen_ai.request.model and gen_ai.usage.input_tokens/gen_ai.usage.output_tokens, alongside its own ai.toolCall.* attributes for tool steps. It labels the provider with the older gen_ai.system attribute, while the current GenAI registry requires gen_ai.provider.name, which is a live example of why attribute mapping on the backend matters. Long-running work (artifact runs, scheduled tasks and app builds) also sets gen_ai.conversation.id on its spans, so every step of one run groups together.

Because the export is vendor-neutral OTLP, any of the four OTLP-native tools above (Langfuse, Braintrust, LangSmith or Phoenix) can be pointed at by changing the endpoint and auth header, and nothing in application code knows which one is listening. Helicone would need its own SDK or proxy instead.

Decision guide#

• Self-hosting or data residency is a hard requirement: Langfuse is the simplest full self-host (free, MIT, Docker Compose to Helm). Phoenix is the lightest. Braintrust and LangSmith both offer it, but only on Enterprise.
• The daily pain is "did this prompt change regress anything": Braintrust's dataset, scorer and experiment loop is the most direct fit.
• You are on LangChain or LangGraph and want deploy, trace and eval from one vendor: LangSmith, priced per seat.
• You want to see agent traces locally this afternoon: Phoenix with uvx arize-phoenix serve, then move the same OTLP export to a managed backend later.
• You already route traffic through Helicone: keep it while it works, but plan the next tracing layer on OTLP rather than on proxy-specific features, given the maintenance-mode announcement.
• You cannot decide yet: instrument with OpenTelemetry and the GenAI conventions now. It is the one choice that does not lock you in.

None of these are mutually exclusive. A common split is a gateway or proxy for routing and cost controls, plus Langfuse, LangSmith or Braintrust for traces and evals on the same OTLP stream. Prompt versioning is the other layer teams often split out; see our prompt management tools comparison.

FAQ#

Is Langfuse still open source after the ClickHouse acquisition?#

Yes. Langfuse's announcement says it stays open source and self-hostable with no licensing changes planned, and the self-hosted plan remains free under MIT with all core platform features. Code under the repository's ee/ directories is licensed separately, and a paid self-hosted Enterprise tier adds audit logs, project-level RBAC and data retention policies.

Is Helicone shutting down?#

No. Helicone said in March 2026 that its services remain live "for the foreseeable future in maintenance mode", with security updates, new models, and bug and performance fixes continuing. Maintenance mode is a signal not to expect major new features, and Helicone Cloud's signup page now says sign ups are disabled, so it is better suited to existing users than new agent-tracing projects.

Can Braintrust or LangSmith be self-hosted?#

Both, on Enterprise plans only. Braintrust runs its data plane in your AWS, GCP or Azure account via Terraform while it hosts the UI and control plane. LangSmith Enterprise offers a hybrid model (its control plane, your data plane) or a fully self-hosted install in your VPC.

Which of these tools accept OpenTelemetry traces?#

Four of the five accept OTLP directly: Langfuse at /api/public/otel over HTTP, Braintrust at api.braintrust.dev/otel, LangSmith at api.smith.langchain.com/otel, and Phoenix, which is built on OTLP. Helicone does not document an OTLP endpoint; it logs through its proxy or through its @helicone/async SDK, which uses OpenLLMetry instrumentation. Instrumenting with OpenTelemetry keeps the backend swappable among the four.

Are the OpenTelemetry GenAI semantic conventions stable?#

Not yet. The agent span conventions, including invoke_agent, execute_tool and gen_ai.conversation.id, are marked Development in the semantic-conventions-genai repository. Use them, but expect attribute names to change and rely on backends that map attributes rather than require exact names.

Sources#

• Langfuse Cloud pricing and self-hosted pricing
• Langfuse v4 changelog, August 17, 2026
• Langfuse OpenTelemetry integration docs
• ClickHouse acquires Langfuse (GitHub announcement)
• Langfuse self-hosting guide and repository
• Braintrust pricing
• Braintrust OpenTelemetry docs
• Braintrust self-hosting docs and BYOC docs
• Braintrust autoevals and dataset docs
• Helicone pricing
• Helicone is joining Mintlify, March 3, 2026
• Helicone OpenLLMetry async integration and proxy vs async comparison
• Helicone Cloud signup page
• Helicone self-hosting docs and repository
• LangSmith pricing
• LangSmith OpenTelemetry tracing docs
• Arize Phoenix docs, repository and OpenInference
• Arize AX pricing
• OpenTelemetry GenAI semantic conventions repository
• OpenTelemetry GenAI agent spans spec
• AI SDK telemetry docs

Continue Reading#

• Local OpenTelemetry Traces Are Agent Receipts - run the same OTLP traces locally before choosing a vendor
• AI Agent Eval Tools Compared: Braintrust vs Promptfoo vs DeepEval - the eval layer on its own
• LangSmith Fleet Turns Agent Ops Into On-Call Work - what agent traces look like as an operations loop
• Claude Code Token Burn and Cache Observability - cost tracing for a coding agent
• Self-Hosted vs Managed AI Gateways: A Decision Guide - the routing layer that often sits next to tracing
• Who Bought Your LLM Observability Tool? - Langfuse, Promptfoo, Galileo, Traceloop, Helicone and Humanloop: who owns them now and how to stay portable
• LLM Observability and Evaluation Tools Compared - Langfuse, Braintrust and Helicone beside 17 other tracing and eval tools: who changed hands, prices in each vendor's own unit, every value quoted