LLM observability is the production category that quietly becomes essential around the time your pipeline grows past 1,000 requests per day. You can no longer eyeball what the model is doing; you need traces, costs, latency breakdowns, and the ability to replay a prompt that misbehaved. In 2026 the three platforms teams reach for are Langfuse (open source, self-hostable), LangSmith (LangChain-native, hosted), and Helicone (gateway-based, zero code change). This article compares all three on setup, features, pricing, and the specific tradeoffs that decide the pick.
What each platform actually is
Langfuse: open-source LLM engineering platform. Traces, prompts, evaluations, datasets, and user analytics in one tool. Self-host for free (Docker, Kubernetes) or use their managed cloud. Launched 2023, maturity in 2026 rivals LangSmith. Primary market: teams that need data residency or want to avoid vendor lock-in.
LangSmith: LangChain’s commercial observability product. Hosted first, enterprise self-hosted available. Tightest integration with LangChain and LangGraph; best playground for prompt iteration. Primary market: teams already on LangChain or who want the fastest setup.
Helicone: gateway-based observability. You change your OpenAI base URL to Helicone’s gateway and traces appear automatically. No SDK, no code changes beyond that one URL. Primary market: teams on raw OpenAI/Anthropic SDKs who want visibility without instrumenting code.
Setup comparison
Helicone (fastest to wire up):
from openai import OpenAI
client = OpenAI(
base_url="https://oai.helicone.ai/v1",
default_headers={"Helicone-Auth": f"Bearer {HELICONE_KEY}"},
)That is literally it. Every call now shows in the Helicone dashboard with full prompt, response, latency, cost, and token count. Works with Anthropic, Google, OpenRouter, and any other OpenAI-compatible API.
Langfuse (SDK-based):
from langfuse.openai import openai client = openai.OpenAI() # drop-in replacement
Langfuse ships a drop-in OpenAI wrapper. Same import structure, auto-traces every call. Also ships decorators and manual trace APIs for complex workflows.
LangSmith (environment variable):
LANGSMITH_API_KEY=lsv2_pt_... LANGSMITH_TRACING=true
If you are already on LangChain or LangGraph, nothing else needed. Everything auto-traces. For non-LangChain code, use the @traceable decorator or the wrap_openai helper.
Features head-to-head
Here is how the three stack up on the capabilities that matter most in production.
- Traces + spans: all three. Langfuse and LangSmith give the richest span tree for multi-step agents.
- Prompt management: Langfuse and LangSmith both ship versioned prompt templates. Helicone added prompt management in 2026 but it is less mature.
- Datasets + evaluations: Langfuse and LangSmith first-class. Helicone added basic evals in 2026.
- LLM-as-judge: Langfuse supports arbitrary LLM graders. LangSmith has built-in evaluators and custom scorers. Helicone focuses on heuristic metrics (cost, latency) rather than quality.
- Self-host: Langfuse (free) and LangSmith (enterprise only). Helicone has an open-source gateway but the dashboard is cloud-only unless on their enterprise tier.
- Prompt playground: LangSmith has the best playground in the category. Langfuse’s playground works but is less polished. Helicone has no playground.
- Caching / rate-limit: Helicone unique selling point. Built-in response cache and request rate-limiting at the gateway level. Langfuse and LangSmith do not offer this.
Pricing in 2026
Langfuse:
- Self-hosted: free (open source, AGPL-3)
- Cloud Hobby: free, 50K observations/month
- Cloud Pro: $59/month, 100K observations
- Cloud Team: $499/month, 500K observations, SSO, support
- Enterprise: custom pricing with self-hosted + SOC 2
LangSmith:
- Developer: free, 5K traces/month
- Plus: $39/user/month, 10K traces/user included
- Startup: $99/month, 50K traces, shared workspace
- Enterprise: custom pricing, SSO, SOC 2, self-hosted
Helicone:
- Free: 10K requests/month
- Pro: $25/month, 100K requests
- Growth: $200/month, 2M requests
- Enterprise: custom, includes gateway rate-limiting + response cache
At similar usage levels Helicone tends to be the cheapest, Langfuse second, LangSmith third. All three have free tiers big enough for a prototype.
Which one wins by use case
- You are on LangChain or LangGraph: LangSmith. Native integration, best playground, nothing to debug on setup.
- You need self-hosted (compliance, data residency): Langfuse. Free, Dockerized, no license cost at scale.
- You are on raw OpenAI SDK and want zero-code instrumentation: Helicone. One-line setup, works everywhere.
- You run high-volume agents (10M+ req/mo): Helicone or self-hosted Langfuse. LangSmith trace pricing stacks fast at this scale.
- You need caching at the gateway: only Helicone offers this; cuts costs on repeat queries 30-60%.
- You run multi-provider (OpenAI + Anthropic + Google): Helicone or Langfuse. Both handle multi-provider well; LangSmith is cleanest when you stay on LangChain abstractions.
Common failure modes and how each handles them
Problem: an agent calls the same tool in a loop and burns budget.
- LangSmith: trace tree shows the loop at a glance in the UI
- Langfuse: same, equivalent trace view
- Helicone: harder to see without span structure, but spending alerts fire
Problem: a prompt rewrite regressed on 20% of edge cases.
- LangSmith: dataset eval diff view compares runs side by side
- Langfuse: same, dataset evals built in
- Helicone: no direct eval support; need external tool like Promptfoo
Problem: OpenAI costs spiked overnight.
- All three catch this via cost dashboards
- Helicone’s gateway lets you set per-user rate limits to prevent runaway spend
Running two in parallel
Teams sometimes combine. Common pattern:
- Helicone as the gateway (caching + rate-limits + basic observability)
- LangSmith OR Langfuse for deep eval, playground, dataset management
Helicone’s gateway sits between your app and the LLM provider. LangSmith or Langfuse SDK captures richer context (user IDs, metadata, evaluation scores) alongside. The two layers do not conflict; they capture different information.
Common migration mistakes
Teams moving between observability platforms hit the same handful of problems. Three worth planning around:
- Historical trace data does not export cleanly. Each platform stores traces in a proprietary schema. When you migrate, you keep datasets and prompt templates but lose the historical trace archive. Plan to switch at a feature boundary (new sprint, new product line) rather than mid-feature, so you do not lose debuggability on an in-flight bug.
- User identity mapping breaks. If you tag traces with user IDs for per-user debugging, confirm the new platform’s user model matches. Langfuse uses explicit sessions and users; LangSmith uses metadata keys; Helicone uses custom headers. Mismatched conventions produce traces that look right but lose the per-user filter capability.
- Eval dataset format differences. Langfuse and LangSmith have similar dataset shapes; Helicone’s dataset model is newer and less expressive. Export datasets as JSON before migration and re-import; CSV loses nested structure.
Frequently Asked Questions
Can I switch platforms later without losing data?
Trace data is proprietary per platform, so historical traces do not export cleanly. Dataset exports work (JSON or CSV), and prompt templates are easy to migrate. Plan to switch at a project boundary, not mid-feature.
How much does observability actually cost in production?
At 1M requests/month, expect $25-100/month on Helicone, $100-300 on Langfuse cloud, $200-500 on LangSmith. Self-hosted Langfuse at that volume is roughly $50/month in infrastructure. All three let you sample traces to control cost further.
Do these tools slow down my requests?
Helicone adds 10-50ms per request (gateway hop). Langfuse and LangSmith both batch telemetry asynchronously so request latency is unaffected. For latency-sensitive applications, pick SDK-based options or sample the Helicone traffic.
Is Langfuse really free forever if I self-host?
Yes, under AGPL-3. You can run it in production at any scale without a license fee. The commercial cloud exists for teams who do not want to host themselves.
Can I use LangSmith with providers other than OpenAI?
Yes. LangSmith works with any LLM provider through the @traceable decorator or LangChain’s provider abstractions. It is simplest when you use LangChain, but not required.
Which one is best for small teams starting out?
LangSmith Developer (free tier) if you are on LangChain. Helicone free tier if you are on raw OpenAI SDK. Langfuse self-hosted if you have strong infrastructure skills. All three graduate to paid tiers cleanly as volume grows.
Official documentation
Angel Jude Suarez
Full-Stack Developer at PIES IT Solution
Focuses on Python development, machine learning, and AI integration. Has built production AI systems including OpenAI Whisper integration for medical transcription and GPT-4o-powered diagnosis assistance. Strong background in pandas, scikit-learn, and TensorFlow.
Expertise: Python · PHP · Java · VB.NET · ASP.NET · Machine Learning · AI Integration · OpenCV · Django · CodeIgniter · View all posts by Angel Jude Suarez →