If you're building AI agents in 2026, you have more observability options than ever — and less clarity about which one to use. This guide cuts through the noise: what each major tool does, who it's for, where it breaks down, and how to decide.
We cover seven tools: Langfuse, LangSmith, Helicone, Braintrust, Arize Phoenix, AgentOps, and Nexus. We built Nexus ourselves, so take our comparisons of it with appropriate skepticism — but we've tried to be honest about tradeoffs.
Quick comparison
| Tool | Pricing | Best for | Weakness |
|---|---|---|---|
| Langfuse | Free self-host / $39+/mo cloud | Self-hosted OSS, LangChain native | Ops overhead; cloud tier expensive |
| LangSmith | $39/mo base (usage-based) | Deep LangChain/LangGraph integration | Requires LangChain; pricing scales fast |
| Helicone | Free / $120/mo first paid tier | OpenAI proxy logging, no-code setup | Proxy model adds latency; not agent-native |
| Braintrust | Usage-based per log | Eval-first: run experiments on datasets | Not observability-focused; different use case |
| Arize Phoenix | Free OSS / paid cloud | OTEL-native, ML fairness + drift | Complex setup; ML-team focus |
| AgentOps | Free / $49/mo Pro | Agent-native SDK, session replays | Smaller ecosystem; newer product |
| Nexus | Free / $9/mo Pro | Simple agent tracing, no infra burden | Newer; smaller ecosystem than Langfuse |
Langfuse — the OSS standard
Langfuse is the default choice for teams that need self-hosted observability with an open-source codebase they can audit, fork, and run on their own infrastructure. With over 21,000 GitHub stars and active development, it has the most mature ecosystem.
Best for: Teams with a DevOps culture who want full control over their data, a rich UI, and don't mind managing a Postgres instance. Strong LangChain integration. Good Python and TypeScript SDKs.
Watch out for: Self-hosting adds ops burden (Docker Compose, Postgres, migrations). The cloud tier starts at $39/mo and gets expensive as usage grows. LLM cost tracking is the primary UX focus — agent session tracing is secondary.
LangSmith — if you're already in LangChain
LangSmith is LangChain's commercial observability offering. If your stack is LangChain or LangGraph, the integration is seamless — one environment variable and you have traces. The trace UI is well-designed and the evaluation features (annotating runs, comparing prompts) are strong.
Best for: Python teams already using LangChain or LangGraph. The native integration is the killer feature — there's nothing to instrument, you just enable it.
Watch out for: Tightly coupled to LangChain. If you use OpenAI SDK, Anthropic SDK, or raw API calls, the integration is manual and loses value. Pricing is $39/mo base plus usage — costs can surprise.
Helicone — the no-code option
Helicone takes a fundamentally different approach: it's a proxy, not an SDK. You change one base URL and every OpenAI call gets logged. No code changes. No instrumentation. Just instant dashboards.
Best for: Quick logging of LLM calls without any code changes. If you call OpenAI directly and want cost tracking and request history in under five minutes, Helicone is the fastest path.
Watch out for: Proxy model adds a network hop. Not agent-native — you see individual LLM calls, not agent sessions or multi-step traces. The first paid tier jumps to $120/mo. Not useful for agents that don't call OpenAI directly.
Braintrust — evaluation-first
Braintrust is not primarily an observability tool — it's an evaluation platform. You create test datasets, run LLM experiments against them, and track which prompts/models score best. If you're doing systematic prompt engineering or A/B testing of LLM configurations, it's excellent.
Best for: Teams doing systematic prompt evaluation, fine-tuning experiments, or regression testing LLM behavior. The eval tooling is genuinely differentiated.
Watch out for: This is not production monitoring. If you want to see what's happening with your agents in production right now — error rates, latency, failures — Braintrust isn't designed for that. Pick a different tool for production observability, and potentially Braintrust on top for evals.
Arize Phoenix — OTEL-native ML monitoring
Arize Phoenix is the open-source offering from Arize AI, an ML monitoring company. It's OpenTelemetry-native, integrates with LlamaIndex and LangChain out of the box, and has strong LLM-specific features: hallucination detection, embedding drift, retrieval quality metrics.
Best for: ML teams who want full OTEL compatibility, retrieval quality metrics, or embedding-level analysis. Strong LlamaIndex integration. Good for RAG pipeline monitoring at scale.
Watch out for: The setup complexity is real — you need to understand OTEL collectors, spans, and the Phoenix backend. More ML-team-focused than app-developer-focused. Running the Phoenix server adds infrastructure.
AgentOps — agent-native from day one
AgentOps was built specifically for AI agents (not LLM calls). Session replays, multi-agent tracing, and agent event timelines are first-class features. The SDK is clean and the integration stories for CrewAI and AutoGen are strong.
Best for: Teams using multi-agent frameworks like CrewAI, AutoGen, or custom agent orchestration. The session replay feature (see exactly what the agent did, step-by-step) is genuinely useful.
Watch out for: Smaller community than Langfuse. Newer product with a smaller ecosystem. Pricing ($49/mo Pro) is reasonable but the free tier has tight limits. Less flexibility for custom event schemas.
Nexus — simple, affordable, Cloudflare-native
Nexus is our tool — we built it because we needed something simpler and cheaper than the alternatives. It runs on Cloudflare Workers (edge-native, zero infra), stores traces in D1, and offers a clean dashboard for browsing traces and spans. Free plan covers 1,000 traces/month. Pro is $9/mo flat.
Best for: Solo developers and small teams who want trace-level visibility into their agents without managing infrastructure or paying enterprise prices. Works with any stack — TypeScript, Python, raw API calls.
Honest weaknesses: Newer product, smaller community. No eval features. No embedding analysis. No native LangChain integration (you wire it up manually with the SDK). If you need Langfuse-level richness or LangSmith's native integration, we're not there yet.
How to choose
You're on LangChain or LangGraph
Use LangSmith — native integration wins. Or Langfuse if you want self-hosted.
You need full data sovereignty / self-hosting
Use Langfuse — it's the most mature OSS option with a strong community.
You want instant logging with zero code changes
Use Helicone — change a base URL, get dashboards immediately.
You're doing systematic prompt evaluation
Use Braintrust — it's purpose-built for evals, not production monitoring.
You want OTEL-native with ML-level analysis
Use Arize Phoenix — especially if you're monitoring RAG retrieval quality or embeddings.
You want simple, cheap, no-infra tracing
Use Nexus — free tier, $9/mo Pro, no servers to manage. Start free →
Bottom line
There's no single "best" AI observability tool. The right choice depends on your stack, your team's operational preferences, and whether you need eval features alongside production monitoring. Use this guide as a starting point, then test the 1-2 that fit your situation.
For individual comparison pages: Nexus vs Langfuse · Nexus vs LangSmith · Nexus vs Helicone · Nexus vs Braintrust · Nexus vs Arize Phoenix · Nexus vs AgentOps