The best tools for tracing and debugging AI agents in 2026

this list is for people who already have an agent running in production and have hit the moment where something went wrong and nobody can say why. a browser agent clicked the wrong button at 3am. a tool call loop burned through a day of budget. a customer says the agent “did something weird” and all you have is a final answer. if you are still prototyping in a notebook, you can probably get by with print statements for a while longer.

I run agents for my own properties from Singapore, mostly browser automation and some LangGraph workflows, so my bias is toward what an operator needs on a bad day. I care less about pretty dashboards and more about three questions. what did the agent do, step by step. what did each step cost. and can I replay or diff it against a run that worked.

I picked seven tools. none of them is perfect, and I say what bothers me about each one. pricing changes often in this category, so every price below is dated and you should confirm it on the vendor page before you commit. nothing here is sponsored.

how I picked

step level tracing: a run has to show up as a tree of LLM calls, tool calls and retries, not one blob. if I cannot see the failing step, the tool does not help me.
cost and token attribution: per step and per run, with model pricing handled for me. “what did it cost” is half the use case.
framework fit: it has to work with LangGraph, the OpenAI and Anthropic SDKs, and plain Python or TypeScript without rewriting my agent around the vendor.
open standards: I weigh OpenTelemetry support heavily, because it lowers the cost of switching later. the OpenTelemetry GenAI semantic conventions are still being developed, so support varies between tools.
self-hosting and data control: agent traces contain prompts, page content and sometimes user data. being able to keep that on my own infrastructure matters.
honest pricing at small scale: a solo operator or small team should not need a sales call to find out what a month costs.

the picks

Langfuse

Langfuse is the one I reach for first. it is open source, you can self-host it with Docker or Kubernetes, and there is also a hosted cloud. traces are nested, so an agent run shows up as a tree with timings, token counts and cost per span. the Langfuse docs cover SDKs for Python and JS, an OpenTelemetry endpoint, and integrations for LangChain, LlamaIndex and the OpenAI SDK.

what I like in practice is that it stays out of the way. you can add a decorator or an integration, get traces, and later add prompt management and evals if you want them. the cost tracking is solid for mainstream models and lets you define custom prices for the odd ones. the self-hosted route takes real effort though: you run Postgres, ClickHouse, Redis and blob storage, and you own upgrades.

open source with a self-host option, so prompts and page content can stay on your servers
good cost and token tracking per span, with custom model pricing
accepts OpenTelemetry data, so you are not locked to one SDK
cons: self-hosting is a real ops job with several moving parts
cons: the UI is functional rather than polished, and large traces can feel slow to browse

pricing: free self-hosted. cloud has a free Hobby tier, then paid tiers starting around $29 a month, as of my last check in 2025. verify on the vendor page.

link: langfuse.com/docs

LangSmith

LangSmith is LangChain’s own platform, and if your agents run on LangGraph it is the lowest friction option. you set a couple of environment variables and traces appear, including the graph structure, state at each node and tool inputs. the LangSmith docs also cover datasets, evals and annotation queues.

for LangGraph specifically it shows things other tools flatten, like which node ran, what the state looked like going in, and where a run stopped. that matters because LangGraph failures can be quiet. I wrote up one case where a run can vanish with no error if it crashes before its first checkpoint, in why a LangGraph run can vanish with no error if it crashes before its first checkpoint. tracing helps you notice the missing run, but you still need to design for it. the downside is that LangSmith is hosted by default, and self-hosting sits on enterprise plans.

best view of LangGraph state and node level execution
datasets and evals live next to traces, so a bad run becomes a test case quickly
works with non-LangChain code through its SDK and OpenTelemetry
cons: per-seat pricing adds up for a team, and trace volume has its own limits
cons: self-hosting is not something a small team can easily get

pricing: free Developer tier with a monthly trace allowance, and a Plus plan priced per seat (about $39 per seat per month as of my last check in 2025). verify before buying.

link: docs.smith.langchain.com

Arize Phoenix

Phoenix is Arize’s open source tracing and eval tool. you can run it locally in a notebook, in a container, or point it at Arize’s hosted product when you outgrow that. it is built on OpenTelemetry and the OpenInference instrumentation, which means traces from OpenAI, Anthropic, LangChain, LlamaIndex and others come through with a consistent shape. the project home is phoenix.arize.com.

I like Phoenix for debugging sessions where I want to poke at a handful of traces on my own machine without creating an account. you can start it in one command, send spans to it, and look at a run in minutes. it is lighter than Langfuse to start with, and good for evals on a dataset of failures. the trade-off is that it feels more like an analysis tool than a long-running production system, and the move to the paid Arize platform is a different product with a different price.

runs locally or self-hosted with no account, handy for quick debugging
OpenTelemetry native, so instrumentation is portable
strong eval and embedding analysis tools if you also care about retrieval quality
cons: production-scale hosting, auth and retention are more work than with a hosted tool
cons: the step from open source Phoenix to Arize’s paid platform is a jump

pricing: free and open source for Phoenix. Arize’s hosted tiers are priced separately, and I have not seen a number I would quote with confidence, so check their site.

link: phoenix.arize.com

Braintrust

Braintrust is the one on this list that treats evals as the main event and tracing as the input. you log production traces, pull bad ones into a dataset, run experiments against them, and compare scores between versions of your prompts or agent. for teams that ship changes weekly and want to know if a change made things worse, that loop is the product.

for tracing alone it is fine, with nested spans, cost and latency. where it earns its place is the diffing. you change a prompt, rerun the same 200 cases and see which ones moved. I have found that more useful than staring at individual traces once the agent is mostly working. the catch is that it is hosted first, and pricing steps up quickly once you pass the starter tier.

strong experiment and comparison workflow built on real production traces
good UI for reviewing and scoring outputs by hand
logs from many SDKs and a proxy option
cons: more tool than you need if you just want to see what a run did
cons: hosted first, with self-hosting limited to enterprise arrangements

pricing: free Starter tier, then a Pro plan around $249 a month, as of my last check in 2025. verify on the vendor page.

link: site: braintrust.dev

Helicone

Helicone started as a proxy. you point your OpenAI or Anthropic base URL at it, and every request is logged with cost, latency and tokens, without installing an SDK. that is the quickest path from nothing to “I can see what my agent spent today”. it also does caching, rate limits and request retries at the gateway level.

the limit is that a proxy sees requests, not your agent’s logic. you can group calls into sessions and add custom properties, which gets you a usable step by step view, but you will not get a graph of node state the way you do with LangSmith. for a small agent that makes a handful of LLM calls per run, that is often enough. for a multi-agent system with lots of non-LLM tool calls, you will want something with real spans.

almost no code change: swap the base URL and you have logs and cost
sessions and custom properties give a workable per-run view
open source, with a self-host option
cons: sees LLM requests, not the full shape of tool use and state
cons: putting a proxy in the request path adds a dependency you have to trust and monitor

pricing: free tier with a monthly request allowance, then paid plans, as of my last check in 2025. exact figures move, so check the vendor page.

link: site: helicone.ai

AgentOps

AgentOps is aimed squarely at agents rather than general LLM apps. it records sessions, replays them as a timeline, tracks tool calls and costs, and has integrations for CrewAI, AG2 (formerly AutoGen), the OpenAI Agents SDK and others. the AgentOps docs walk through the SDK, and getting a first session recorded is a few lines.

the session replay is the part I find most intuitive for people who are new to agent debugging. you can scrub through a run and see what happened in order, including failures and retries. it is less flexible than OpenTelemetry-first tools, and the smaller ecosystem means fewer community examples when something does not work. I would use it for multi-agent frameworks it explicitly supports, and be more cautious outside them.

timeline style session replay that is easy to explain to non-engineers
direct support for several agent frameworks, not only raw LLM calls
cost tracking per session
cons: smaller ecosystem and fewer integrations than the bigger platforms
cons: coverage depends on framework support, so check your stack first

pricing: free tier to start, with paid plans above it (around $40 a month as of my last check in 2025). verify before relying on that number.

link: site: agentops.ai

Weights & Biases Weave

Weave is the tracing and eval toolkit from Weights & Biases. if your team already uses W&B for model training or experiment tracking, Weave slots into the same login, projects and billing. you wrap functions with a decorator and get traces with inputs, outputs, latency and cost. it also supports evaluations and comparing runs.

for a team with ML people in it, that familiarity is the selling point. for a solo operator running browser agents, it is more platform than I need, and I would not adopt W&B just for this. it is a good fit when agent work sits next to fine-tuning or other ML work and you want one place for both.

decorator based tracing that needs very little setup in Python
sits alongside W&B experiment tracking if you already use it
evaluation and run comparison features
cons: makes the most sense if you are already in the W&B ecosystem
cons: smaller footprint outside Python than some alternatives

pricing: free tier, then paid plans that start in the tens of dollars per month, as of my last check in 2025. confirm the current numbers on the vendor page.

link: site: wandb.ai

comparison table

tool	price (as of my last check, 2025)	primary strength	primary weakness
Langfuse	free self-hosted, cloud from about $29/month	open source with solid cost tracking	self-hosting is real ops work
LangSmith	free tier, about $39/seat/month	best LangGraph state view	per-seat cost, hard to self-host
Arize Phoenix	free, open source	quick local debugging, OpenTelemetry native	production hosting is on you
Braintrust	free tier, Pro about $249/month	evals and run comparison	heavy if you only want tracing
Helicone	free tier, then paid	no-SDK proxy setup	sees requests, not full agent logic
AgentOps	free tier, about $40/month	agent session replay	smaller ecosystem
W&B Weave	free tier, paid from tens of dollars	fits existing W&B teams	best only if you use W&B

how to choose

start with where your data is allowed to live. agent traces hold prompts, scraped pages, tool arguments and sometimes customer details. if that cannot leave your own servers, your shortlist is Langfuse, Phoenix and Helicone, the open source ones, and the rest of the decision is about how much ops work you want. if hosted is fine, the choice opens up and framework fit matters more.

next, match the tool to the shape of your agent. if you run LangGraph, try LangSmith first because the state view is hard to match, and read self-hosted LangGraph checkpointing vs LangGraph Cloud for long tool calls so you understand what is being recorded where. if your agent is mostly raw SDK calls, Langfuse or Helicone is simpler. if it is a CrewAI or AG2 crew, AgentOps is worth a trial. for a wider look at what the whole stack costs to run, my notes on which LLMs actually hold up running a browser-use agent in production cover the model side that your cost traces will be reporting on.

third, decide whether you want to watch or to improve. watching means “what happened in run 4,812”, and any tool here does that. improving means turning failures into test cases and checking that a change helped, which is where Braintrust and LangSmith’s datasets pay off. most small teams only need watching for the first few months, so do not pay for an eval workflow you will not use. and keep your instrumentation on OpenTelemetry where you can, so changing vendor later is an afternoon and not a rewrite.

one practical note for browser agents. a trace tells you what the agent saw and did, but if a failure only happens on a page that behaves differently by location or network, you need to reproduce it from the same place. if the sites you are testing are your own properties and you need to see them as a real Singapore mobile user would, Singapore Mobile Proxy sells real Singapore mobile IPs with sticky sessions, so a replayed run goes through the same kind of connection. it is Singapore only, and it is for checking your own pages and consenting users within each site’s terms, not for anything else. if your problem is elsewhere, ignore this paragraph.

verdict / top pick

for most operators, I would start with Langfuse. it gives you step level traces, per step cost, OpenTelemetry input and the choice between self-hosting and cloud, and it does not tie you to a framework. I would pick LangSmith instead if you are all in on LangGraph and want the state view without extra work. if your first need is simply “what did this cost me yesterday”, Helicone gets you there in about ten minutes.

whichever you pick, test it on a real failed run before you trust it. take the worst run from last week, trace a fresh run of the same task, and see if you can find the bad step in under five minutes. if you can, the tool works for you. if not, move on to the next one on the list. prices and features above are as of my last check in 2025, so confirm them before you pay.

Written by Xavier Fok

disclosure: this article may contain affiliate links. if you buy through them we may earn a commission at no extra cost to you. verdicts are independent of payouts. last reviewed by Xavier Fok on 2026-10-13.