Best LLM Observability & Evals 2026
Shipping an AI feature without evals is shipping without tests. We compare Langfuse, LangSmith, Braintrust, Arize Phoenix, and Helicone on tracing depth, evaluation workflow, self-hosting, OpenTelemetry support, and what each actually bills you for.
Quick Verdict
The best default. Open source, free to self-host, works with essentially every framework, and the cheapest path from zero to real production tracing.
Zero-config if you build on LangChain or LangGraph. The trace tree maps directly onto your chain — no instrumentation to write.
Eval-first, not tracing-first. Scores are native to the trace view and regression gates run in CI. The premium option, and the best-funded.
Apache 2.0, no feature gating, no phone-home. The strongest OpenTelemetry story and the best option for local debugging.
One-line proxy setup, still the fastest way to see cost and latency. But it was acquired by Mintlify in March 2026 and is now in maintenance mode.
TL;DR
Start with Langfuse unless you have a specific reason not to. On LangChain? LangSmith. Evals are the center of your workflow? Braintrust. Want zero vendor and pure OTEL? Phoenix. Think twice before newly adopting Helicone.
Tracing vs evals — they're not the same product
Almost every tool here markets itself as both, and the distinction is the single most useful thing to hold onto while choosing.
Tracing answers "what happened?" — a tree of every LLM call, retrieval, and tool invocation in one request, with tokens, latency, and cost attached. It's the AI equivalent of a distributed trace, and it's how you debug a specific bad output a user reported.
Evals answer "is it getting better or worse?" — you build a dataset of inputs with expected properties, run your system against it, and score the outputs (with heuristics, an LLM judge, or human annotation). Evals are what let you change a prompt without praying. They are your regression suite.
The loop that actually matters: production traces → the ones that went wrong → an eval dataset → a score you can gate a deploy on. Langfuse gives you excellent traces. Braintrust is built around the dataset-and-score end. Whichever you pick, closing that loop is the point.
One structural change worth knowing: in 2026 the whole category is consolidating around OpenTelemetry. Instrumentation is increasingly portable, which means the lock-in risk of picking "wrong" is lower than it was a year ago — and it pushes the real differentiator onto how each vendor bills you.
Watch the billing unit. These platforms meter completely differently: Langfuse counts units (one trace plus its observations and scores is many units), LangSmith counts traces per seat, Braintrust bills processed GB plus eval scores. A workload that's cheap under one model can be expensive under another — model your real volume before committing.
Platform Overview
Two open-source options, two commercial platforms, and one cautionary tale.
Langfuse
Open-source tracing, prompts, and scores
Free self-hosted
Cloud: Hobby free, Core $29/mo
- MIT-licensed core, free to self-host
- Hobby cloud tier: 50k units/month free
- Core $29/mo, Pro $199/mo (100k units each)
- Overage $8 per 100k units, graduated down at scale
- Works with essentially every framework and provider
- Prompt management and session threading built in
Best for: Almost everyone — especially teams needing data sovereignty or GDPR-friendly self-hosting
LangSmith
Zero-config tracing for LangChain
$0 Developer
Plus $39/seat/mo
- Automatic trace tree for LangChain & LangGraph
- Developer: free, 1 seat, 5,000 base traces/mo
- Plus: $39/seat/mo, 10,000 base traces/mo
- Pay-as-you-go past the included allowance
- Insights clusters similar traces automatically
- Self-hosting only on Enterprise plans
Best for: Teams already building on LangChain or LangGraph who want tracing for free effort
Braintrust
Eval-first platform with CI regression gates
$0 Starter
Pro $249/mo
- Eval scores native to the trace view
- Starter free: 1 GB data, 10k scores, 14-day retention
- Pro $249/mo: 5 GB, 50k scores, 30-day retention
- Overage $3/GB + $1.50 per 1,000 scores on Pro
- Framework-agnostic; proprietary Brainstore engine
- Raised $80M Series B at $800M valuation (Feb 2026)
Best for: Teams with defined quality criteria who gate deploys on eval regressions
Arize Phoenix
Apache 2.0, OpenTelemetry-native
Free, no limits
fully open source
- Apache 2.0 with no feature gating
- No API key, no account, no phone-home telemetry
- OpenTelemetry + OpenInference trace model
- Auto-instruments LangChain, LlamaIndex, OpenAI SDK, LiteLLM
- Runs in a local Python process or on Kubernetes
- RAG-specific metrics and embedding analysis
Best for: Local debugging, air-gapped environments, and teams that refuse vendor lock-in
Helicone
One-line proxy for cost and latency
Free Hobby
Pro $79/mo · Team $799/mo
- Apache 2.0 — every tier can be self-hosted
- Proxy-based: one line of code to integrate
- Hobby: 10k requests/mo, 1 GB, 7-day retention
- Fastest path to cost and latency dashboards
- Acquired by Mintlify in March 2026
- Now in maintenance mode — no new feature work
Best for: Existing users; new projects should weigh the maintenance-mode status carefully
What about W&B Weave and Laminar?
Weights & Biases Weave is the natural pick if your team already lives in W&B for model training — the experiment tracking carries over cleanly to LLM work.
Laminar and Latitude are newer entrants pushing agent-specific observability and auto-generated evals. Promising, but with smaller ecosystems — worth a look once you know exactly what your eval loop needs.
Before you pick Helicone in 2026
Helicone announced on March 3, 2026 that it had been acquired by Mintlify and that the service would remain in maintenance mode — security updates, new model support, bug fixes, and performance fixes, but no new feature development.
It's still Apache 2.0 and still self-hostable, so existing deployments aren't at risk and the one-line proxy still works. But if you're choosing an observability platform today and expect to grow into agent tracing and evals, you'd be adopting a product that has stopped moving. Langfuse is the closest open-source replacement.
Pricing Breakdown (2026)
The headline numbers are not comparable — each platform meters a different thing. Read the billing unit column first.
Free tier
Self-host free · Hobby 50k units
Paid
Core $29/mo · Pro $199/mo · Ent. $2,499/mo
Bills units (a trace plus its observations and scores = many units). Overage $8/100k, dropping to $7 past 1M and $6 past 50M. Self-host enterprise license $500/mo.
Free tier
Developer $0 — 1 seat, 5k traces
Paid
Plus $39/seat/mo — 10k traces
Bills per seat plus traces, then pay-as-you-go. Seat-based pricing gets expensive for larger teams. Self-hosting is Enterprise-only.
Free tier
Starter $0 — 1 GB, 10k scores
Paid
Pro $249/mo — 5 GB, 50k scores
Bills processed data (GB) + eval scores. Starter overage $4/GB and $2.50/1k scores; Pro drops to $3/GB and $1.50/1k. Retention 14 days free, 30 days on Pro.
Free tier
Free — genuinely unlimited
Paid
Your infrastructure cost only
Apache 2.0 with no feature gating, no usage limits, no required API key. You pay for the box it runs on. Arize AX is the paid enterprise sibling.
Free tier
Hobby free — 10k requests, 1 GB
Paid
Pro $79/mo · Team $799/mo
Apache 2.0, self-hostable at any tier. Cheapest paid entry point here — but in maintenance mode since the March 2026 Mintlify acquisition.
Prices verified against provider pricing pages as of August 2026. Because billing units differ so much between vendors, estimate cost against your own trace volume rather than comparing plan names.
Feature Comparison
Licensing, tracing depth, and evaluation capability side by side.
Licensing
Tracing
Evals & ops
Deep Dive: Langfuse
Langfuse is the default recommendation for the same reason pgvector is the default vector store: it is good enough at everything, cheap, and doesn't lock you in. The core is MIT-licensed and free to self-host, framework coverage is the broadest in the category, and you get tracing, prompt management, scores, and session threading in one tool.
Cloud pricing runs Hobby free (50k units/month), Core $29/mo, Pro $199/mo (both with 100k units included), and Enterprise at $2,499/mo. The thing to understand is the billing unit: a single trace, with all its observations and scores, consumes many units — so estimate from your own volume rather than from trace counts. Overage is $8 per 100k units, graduating down to $7 past 1M and $6 past 50M. Self-hosting is free, with a $500/mo enterprise license for the advanced tier.
Where it's weaker: evals are functional but manual — you author datasets and annotation workflows yourself rather than getting the guided experiment machinery Braintrust ships.
Best for: Most teams, and anyone with data-sovereignty or GDPR constraints. Skip if: your entire workflow is dataset-and-regression-gate centered.
Deep Dive: LangSmith
If you build on LangChain or LangGraph, LangSmith is close to zero-effort: the trace tree maps onto your chain or graph structure automatically, with no instrumentation to write. Its Insights feature clusters similar traces so you can spot a failure pattern rather than reading a thousand individual runs.
Pricing is seat-based: Developer is free with 1 seat and 5,000 base traces/month; Plus is $39/seat/month with 10,000 base traces, then pay-as-you-go. That model is fine for a small team and gets expensive as headcount grows — five engineers is $195/month before you've traced anything unusual. Self-hosting and hybrid deployment exist only on Enterprise.
Best for: LangChain and LangGraph teams who value integration over portability. Skip if: you're not on LangChain — the main advantage evaporates and you're paying per seat for a closed platform.
Deep Dive: Braintrust
Braintrust inverts the usual design. Most tools are tracing platforms with evals bolted on; Braintrust is an evaluation platform where scores are native to the trace view. If your quality loop revolves around datasets, experiments, and regression gates that block a deploy, that architectural difference shows up in daily use rather than in a feature list.
It's also the premium option. Starter is free with 1 GB of processed data, 10,000 scores, and 14-day retention; Pro is $249/month with 5 GB, 50,000 scores, and 30-day retention, with overage at $3/GB and $1.50 per 1,000 scores. Billing on two axes — data volume and score count — means aggressive LLM-as-judge evaluation is what drives your bill, not traffic.
On durability: Braintrust raised an $80M Series B at an $800M valuation in February 2026 led by Iconiq, and counts Notion, Replit, Cloudflare, Ramp, and Dropbox as users. For a closed-source platform you're building a quality process around, that matters.
Best for: Teams with defined quality criteria who gate releases on eval scores. Skip if: you mainly need to debug traces, or you require self-hosting — there isn't one.
Deep Dive: Arize Phoenix
Phoenix is the most genuinely free option here — Apache 2.0 with no feature gating, no usage limits, no required API key, and no phone-home telemetry. You can run it in a local Python process while debugging and scale the same tool to Docker or Kubernetes in production.
Its real edge is standards. Phoenix is built on OpenTelemetry plus OpenInference, giving you a shared span vocabulary across LangChain, LlamaIndex, the OpenAI SDK, LiteLLM, and your own code. As the category consolidates on OTEL, that's the least lock-in available: your instrumentation stays portable if you later move to a commercial platform. It ships RAG-specific metrics and embedding analysis too, which is useful when debugging retrieval quality specifically.
Best for: Local debugging, air-gapped or regulated environments, and teams that want zero vendor dependency. Skip if: you want a managed service and a support contract — that's Arize AX, the paid sibling.
Deep Dive: Helicone
Helicone earned its reputation on the easiest integration in the category: change your base URL and you're logging every request, with cost and latency dashboards a minute later. It's Apache 2.0 and self-hostable at every tier, with Hobby free (10,000 requests/month, 1 GB, 7-day retention), Pro at $79/month, and Team at $799/month — the cheapest paid entry point of the group.
The complication is strategic, not technical. Helicone was acquired by Mintlify in March 2026 and now runs in maintenance mode: security patches, new model support, bug fixes, and performance work continue, but feature development has stopped. Combined with its proxy-based design — which captures requests well but not full agent trace trees — it's a questionable foundation for a new project heading toward agent evals.
Best for: Existing deployments, and quick cost/latency visibility on a simple LLM app. Skip if: you're starting fresh — Langfuse gives you the same open-source freedom on a product that's still moving.
Decision Guide
You just need to see what your AI app is doing
Use Langfuse. Free to self-host, generous cloud free tier, works with whatever framework you're on, and you can add evals later without switching tools.
You build on LangChain or LangGraph
Use LangSmith. Tracing appears with no instrumentation work, and Insights clusters failures for you. Just price the per-seat model against your team size.
Evals gate your deploys
Use Braintrust. Scores are native to traces, regression gates run in CI, and the $80M Series B says it will be around to maintain them.
You can't send data to a vendor
Use Arize Phoenix. Apache 2.0, no phone-home, no API key, OpenTelemetry-native so your instrumentation stays portable. Self-hosted Langfuse is the close second.
You're already on Helicone
Nothing is on fire — it's Apache 2.0, self-hostable, and still maintained for security and new models. But plan a migration path to Langfuse before you need agent tracing or real evals.
Frequently Asked Questions
What's the difference between LLM tracing and evals?
Tracing answers "what happened in this request?" — a tree of LLM calls, retrievals, and tool invocations with tokens, latency, and cost. Evals answer "is quality improving or regressing?" — running your system against a dataset and scoring outputs. Tracing debugs a specific complaint; evals let you change a prompt safely.
Langfuse vs LangSmith: which should I choose?
Choose LangSmith if you build on LangChain or LangGraph — tracing works with zero instrumentation. Choose Langfuse for everything else: it's open source, free to self-host, supports far more frameworks, and avoids per-seat pricing. Langfuse is the better default for teams not committed to the LangChain ecosystem.
Is Helicone still a good choice in 2026?
For existing users, it's fine — Apache 2.0, self-hostable, and still receiving security updates, new model support, and bug fixes. For new projects, be careful: Mintlify acquired it in March 2026 and placed it in maintenance mode, so no new features are coming. Langfuse is the closest actively-developed open-source alternative.
Which LLM observability tool is cheapest?
Self-hosted Arize Phoenix is free with no feature gating or usage limits — you pay only for the server. Self-hosted Langfuse is a close second with a richer product. Among cloud tiers, Langfuse Core at $29/mo is the cheapest real production plan; Braintrust Pro at $249/mo is the most expensive.
Do I need OpenTelemetry support?
It's increasingly the safest bet. The category is consolidating on OTEL in 2026, so OTEL-based instrumentation is portable between platforms — meaningfully reducing the cost of switching later. Phoenix is the strongest choice if OTEL is a hard requirement; Langfuse supports it well; others support it to varying degrees.
When should I add evals to my AI app?
As soon as you've changed a prompt twice and couldn't tell whether it improved things. Start small: 20–50 real inputs from production traces, with expected properties, scored by an LLM judge. That's enough to catch the regressions that matter, and every platform here supports it — you do not need Braintrust to begin.
Related Articles
The framework you'll be tracing
Best AI Agent Sandbox 2026Where your agent runs its code
Best Vector Database for RAG 2026Debugging retrieval quality
GPT-5.6 vs Claude vs GeminiThe model your evals are scoring
Build an AI App with Next.js & SupabaseThe app you're instrumenting
Best AI Voice Agent Platforms 2026Observability for voice pipelines