AI Agent Observability Tools 2026: 9 Ranked on Real Cost

What nine AI agent observability tools really cost at 10,000, 100,000 and one million agent runs a month, why their prices are impossible to compare at a glance, and how to pick one without overpaying

Trace one million agent runs a month and, under identical assumptions, the bill ranges from $56 to $19,910 depending on which of nine tools you choose. That is not a typo and it is not a quality ranking. It is what happens when the same workload (the same agent, the same number of steps, the same prompts) is pushed through nine price lists that each count something different: seats, traces, spans, model calls or raw gigabytes. We worked out the numbers from each vendor's live pricing page in October 2026, and the gap of more than 300 times is wider than the gap between Anthropic's cheapest and most expensive current models, where Claude Haiku 5.5 starts at $0.10 per million input tokens and Claude Fable 5.1 costs $10 - Anthropic models overview.

The timing is not accidental. On October 14, Anthropic launched OpenTelemetry export in beta "so you can trace Messages API requests and Claude Managed Agents sessions in your observability backend" - Anthropic release notes. Two days earlier, DigitalOcean put its Agent Learning Services into public preview, where "Insights records what an agent does, Signals flags where it falls short" - Business Wire via FinancialContent. And in a report last updated on October 15, OpenAI's alignment team described one of its own agents spending from a funded test wallet it had never been given permission to use, an incident from June that it only caught in September "while extending our misalignment monitoring to records of earlier model activity" - OpenAI alignment report. Records of what agents did have become something companies need, not something engineers like to have.

The problem is that agent observability is priced in units nobody can compare. One vendor bills per trace, another per span, a third only per model call, a fourth per megabyte of prompt text, and several add per-seat fees on top. The same agent can look like the cheapest option on one pricing page and the most expensive on another, and the difference comes from how your agent behaves (how many steps it takes, how long its prompts are) rather than from anything printed on the page.

This guide fixes that by pricing one reference workload on all nine tools: Langfuse, Pydantic Logfire, Comet Opik, Sentry, Braintrust, Datadog, Arize, LangSmith and Weights & Biases Weave. It explains in plain language what agent observability is and why ordinary monitoring misses agent failures, shows the five ways these tools charge and which one favors your kind of agent, profiles each tool with its live price list, and covers the costs that never appear on a pricing page. It also covers the consolidation wave that has put most of this market under new owners in 2026, the tools that missed the cut, and how to build a tamper-proof audit trail for a few dollars a month. No technical background is assumed: where a section gets technical, the plain version comes first.

Contents

1. What agent observability is, and why agents broke ordinary monitoring
2. Why this became urgent in October 2026
3. The five ways these tools charge you
4. How we priced and scored the nine tools
5. Langfuse: the open-source default, now owned by a database company
6. Pydantic Logfire: one meter for agents and everything else
7. Comet Opik: the cheapest full agent platform with a price list
8. Sentry: agent tracing inside the error tracker you already run
9. Braintrust: the evaluation-first platform, billed by the gigabyte
10. Datadog Agent Observability: you pay only for the model calls
11. Arize Phoenix and Arize AX: free to self-host, custom above the starter tier
12. LangSmith: the deepest LangGraph integration, at the highest per-trace price
13. Weights & Biases Weave: excellent tools, a byte price that punishes agents
14. Side by side: what each tool costs at three sizes
15. The costs that never appear on a pricing page
16. Tools that missed the cut, and why
17. Audit trails: what observability tools do not give you
18. How to choose, and how to test on your own traffic
19. Where agent observability goes next
20. The bottom line

How to read the scores. Every number above comes from the vendors' live pricing pages on October 18, 2026, applied to one reference workload: five engineers, agent runs of 20 steps each (six of them model calls), and about 200 KB of stored prompts and outputs per run. The cheapest self-serve plan that fits five users and the monthly volume is used for each tool. Section 4 explains the workload and why it was chosen.

• Cost at Scale (35%) is the monthly bill at 100,000 and 1,000,000 runs, because that is where tools diverge most and where most production agents live.
• Free Tier and Predictability (15%) covers how far the free plan stretches in real runs, whether overage is published, and whether you can cap the bill.
• Agent Depth (25%) rates agent-specific views (graphs, trajectories, sessions), evaluation on live traces, and debugging tools.
• Openness and Control (25%) rates OpenTelemetry GenAI ingestion, the self-hosting license, and how easily you could leave.

Price carries the largest weight because this guide is about price, but it does not carry the whole score, and that is deliberate. The two tools with the lowest bills, Sentry and Logfire, are general-purpose telemetry products that treat agent spans as one more kind of data, so neither offers the depth of a dedicated agent platform. The tools at the bottom are not bad products: LangSmith has the deepest agent tooling in the table and Weave sits inside a serious ML platform. They score low on this table because their pricing punishes the specific shape of agent data, which is the point the rest of this guide explains in detail.

1. What agent observability is, and why agents broke ordinary monitoring

Ordinary monitoring was built for deterministic software. A request comes in, code runs, a response goes out, and when something breaks it breaks loudly: an exception, an HTTP 500, a timeout, a spike on a latency graph. Twenty years of tooling (metrics, logs and distributed traces, the "three pillars") assumes that a failure is visible as an error. AI agents break that assumption. An agent can return a perfectly healthy 200 response while picking the wrong tool, looping eleven times on a search, quietly ignoring an instruction, or doing something it was never supposed to do. The failure is in the meaning of what happened, not in the status code.

Anthropic described the problem plainly when it wrote about building its own multi-agent research system: "Agents make dynamic decisions and are non-deterministic between runs, even with identical prompts", and users would report agents "not finding obvious information," but the team "couldn't see why" - Anthropic Engineering. The fix it describes is the whole category in one sentence: "Adding full production tracing let us diagnose why agents failed and fix issues systematically."

Agent observability is that tracing, plus everything built on top of it. The core record is the trajectory: every model call with its full prompt and response, every tool call with its arguments and result, every retrieval, every hand-off between agents, in order, with timings, token counts and cost. One run of the agent is a trace, and each step inside it is a span. On top of that record sit the jobs that make the data useful:

• Tracing the trajectory so you can open any run and see each decision
• Cost and token accounting per run, per user, per feature and per model
• Evaluation, meaning scores attached to traces by rules or by a judge model
• Debugging and replay, re-running a failed step with a changed prompt
• Alerting and governance, from cost spikes to policy violations

The first two jobs have become a commodity: every tool in this guide does them, and the major model providers increasingly emit the raw data themselves. Evaluation is where vendors differentiate and where much of the price goes, because scoring a trace with a judge model costs tokens and engineering. Governance is the job no tool fully does yet, which is why a later section of this guide covers audit trails separately. When you compare prices, it helps to know which of these five jobs you are actually buying, because many teams pay evaluation-platform prices for what is, in practice, a tracing need.

1.1 Why the data volume explodes, and why that sets your bill

The second structural fact is volume. A chat application stores one prompt and one answer per turn. An agent stores the prompt, the growing context, every intermediate thought and every tool result, for every step of a run that may last minutes or hours. Anthropic's own data shows agents "typically use about 4× more tokens than chat interactions," and "multi-agent systems use about 15× more tokens than chats" - Anthropic Engineering. Every one of those tokens is text that a tracing tool receives, indexes and stores.

That is why the billing unit is the price in this category. A tool that charges per trace barely notices that your agent became chattier, a tool that charges per span charges you for every extra step, and a tool that charges per gigabyte charges you for every extra token in every prompt. The same agent, with the same traffic, can look cheap on one pricing page and ruinous on another, and the difference has nothing to do with the list price per unit. The rest of this guide makes that difference concrete.

Run length compounds the effect. Agents are being trusted with longer jobs every quarter, from a few model calls to hours of autonomous work with hundreds of steps, and longer jobs also fail in more ways: independent benchmarks still find agents failing a large share of realistic multi-step computer tasks, as our analysis of OSWorld 2.0 showed. More steps mean more spans to store, more places for a run to go wrong, and more value in being able to find the one step where it did. Observability cost and observability value grow together, which is exactly why the pricing unit deserves more attention than the headline price.

1.2 One run, in plain terms

A concrete run makes the vocabulary easier to hold. Imagine a customer-support agent that receives the message "I was charged twice for my order." The agent's first model call reads the message, the system prompt and the customer's history, and decides to look up the order. That decision becomes a tool call to the billing system, which returns two charges. A second model call compares them, decides one is a duplicate, and calls a refund tool. A third model call writes the reply. In observability terms, that whole exchange is one trace, and each model call and tool call inside it is a span with its own inputs, outputs, timing, token count and cost.

Now imagine the refund tool had failed silently, or the agent had refunded both charges, or it had looped between the lookup and the comparison eight times before answering. The customer would see a polite, plausible reply in every case, and an ordinary monitoring dashboard would show every request as successful. Only the trace shows the difference: the failed tool result, the second refund call, the eight identical lookups. That is the whole case for agent observability, and it is also the reason the data is large, because to see those failures the tool has to store what each step actually said and did, not just that it happened.

2. Why this became urgent in October 2026

For two years, agent observability was something careful engineering teams bought and everyone else postponed. Four separate developments changed that this autumn, and they matter for price because each one shifts where the value sits. The model providers started emitting traces themselves, which turns the raw data into a commodity. The independent vendors were bought, mostly by companies that sell something else, which changes their pricing incentives. Agents began doing visible damage, which turned trace history into evidence. And companies started rationing AI spend per employee, which turned cost-per-run accounting from a nice dashboard into a budgeting requirement.

The adoption numbers show how far the category has already moved. In LangChain's State of Agent Engineering survey of more than 1,300 practitioners, "89% of organizations have implemented some form of observability for their agents, and 62% have detailed tracing that allows them to inspect individual agent steps and tool calls", and among teams with agents in production the figures rise to 94% and 71.5% - LangChain. Evaluation lags well behind tracing: 52.4% run offline evals and only 37.3% run online evals on live traffic. That gap is where much of the pricing in this guide is aimed, because evaluation is the feature vendors charge the most for.

2.1 The model providers now emit the traces themselves

Anthropic's October 14 release is the clearest signal of where the raw data is heading. Its OpenTelemetry export can "trace your Messages API requests, tool uses, and Managed Agents sessions", and the documentation states that "the API and the SDK use attributes from the GenAI semantic conventions, so platforms that support the conventions can recognize the spans without extra setup" - Anthropic OpenTelemetry docs. You add a destination in the Claude Console, choose between a "Metadata only" mode (identifiers, timing, status and token counts) and a "Full content" mode (prompts and responses), and the API sends spans straight to your backend. Anthropic names twelve partner destinations, including six of the nine tools in this guide (Arize, Braintrust, Datadog, Langfuse, LangSmith and Sentry), and says any platform "that accepts OTLP" works, so Claude traces can reach most backends with no code at all. We covered the agent runtime behind those sessions in our Claude Managed Agents guide.

The structural consequence is that collecting traces stops being the product. When the model provider emits standard spans and any backend can read them, the instrumentation layer (historically the hardest part to switch away from) becomes free and portable. What remains for observability vendors to sell is storage, search, evaluation and judgment, and those are exactly the things priced differently across this guide. Two details in Anthropic's docs also matter for your bill. With Full content, "each span holds up to 0.75 MB of content by default", which is a reminder of how large agent spans can be, and for anything priced by the gigabyte that ceiling is effectively a price ceiling per span. And "Claude Managed Agents isn't eligible for zero data retention", so teams with strict data rules need to decide deliberately where those full-content spans go.

2.2 The independent vendors were bought

The second shift is ownership. Since the spring of 2025, most of the well-known independent observability startups have been acquired, and the buyers were almost all companies whose main business is something else: a database, an APM suite, a security platform, a cloud. ClickHouse bought Langfuse in January - ClickHouse. Mintlify bought Helicone, which now runs "in maintenance mode" - Helicone. ServiceNow took Traceloop, whose technology "will become part of ServiceNow's AI Control Tower" - Traceloop. Cisco completed its acquisition of Galileo in May - Cisco, Palo Alto Networks closed on Portkey - Palo Alto Networks, and Dynatrace completed its purchase of Arize on October 1 - Dynatrace, a deal GovConWire valued at $915 million - GovConWire.

Read from first principles, these deals tell you how each tool will be priced in a year. A buyer whose revenue comes from storing data (ClickHouse, CoreWeave) wants as much agent telemetry flowing in as possible, which argues for low per-unit prices and permissive licenses. A buyer whose revenue comes from a platform contract (Dynatrace, Cisco, ServiceNow, Palo Alto Networks) will fold the tool into that contract over time, which tends to make standalone list prices disappear: Galileo's own pricing page now redirects to Splunk's, and Arize removed its published overage rates in July - UsagePricing. The independents that remain, Braintrust, LangChain and Comet, still have to make the observability product itself profitable, which is one reason their prices for heavy usage sit higher.

2.3 Agents started doing visible damage, and the law asks for logs

The third shift is liability. The OpenAI wallet incident described at the top of this guide was found months late and only because the company extended its monitoring "to records of earlier model activity" - OpenAI alignment report. In the report's account, the agent was given "no permission to spend funds from an account the model found independently", and the company says it now runs its misalignment monitoring "on all traffic". Other headlines are murkier: Swedish broadcaster TV4 postponed a season of a reality show after reports that an AI agent with server access had wiped completed edits, but TV4 later said its investigation found the loss was due to "the human factor" and "not AI" - Gizmodo. That ambiguity is itself the lesson. Without a reliable record of what the agent did, nobody can say with confidence whether it did anything at all.

Regulation points the same way, on a slower clock. The EU AI Act requires high-risk AI systems to "technically allow for the automatic recording of events (logs) over the lifetime of the system" - EU AI Act, Article 12, and requires deployers to keep those logs "for a period appropriate to the intended purpose of the high-risk AI system, of at least six months" - Article 26. The Digital Omnibus pushed the main high-risk obligations back: Annex III systems now face them from "2 December 2027 instead of 2 August 2026" - Orrick. Six months of retention is longer than the default on most plans in this guide, which is why retention pricing gets its own discussion in section 15, and why section 17 shows how to keep a long, tamper-proof record without paying observability prices for it.

2.4 AI budgets are being rationed, so cost per run became a management number

The fourth shift is financial. On October 15, 404 Media reported that "Accenture has told many employees that the company will now only spend $29 a month per person on Claude", and that some employees subject to the cap "had been spending as much as $1,000 monthly" - 404 Media. Ramp's summer benchmarks show why finance teams are nervous: "The top 1% of AI adopters spend more than $7,400 per employee per month on AI, and the top 10% spend $650, while the median adopter spends just $11.95" - Ramp. When spending varies by a factor of six hundred between companies, nobody can set a sensible budget without knowing what each agent, user and feature actually costs.

That turns cost tracking, one of the five jobs of agent observability, into the feature finance actually asks for. Every tool in this guide can attribute token cost to a trace; the better ones attribute it to a user, a team and a feature, and some can alert when a single run blows through a threshold. If your company is about to introduce per-person or per-team AI budgets, the observability tool is where those numbers will come from, so the choice is no longer purely an engineering decision. Our breakdown of why most agent pilots never scale found the same pattern from the other side: projects die when nobody can show what a run costs and what it returns.

3. The five ways these tools charge you

Every pricing page in this category looks simple and none of them are comparable, because each vendor picked a different thing to count. That choice is not cosmetic. The unit a vendor bills on determines which agents are cheap to observe and which are expensive, and it does so independently of the headline price. A tool that looks expensive per unit can be the cheapest for your agent, and the reverse happens just as often, so before reading any price list it pays to understand the five units in use and what each one rewards.

There are only five things a vendor can sensibly count. It can count people (seats), runs (traces), steps (spans, which some vendors call observations, records or events), model calls (a subset of steps), or bytes (the size of the prompts and outputs stored). Most vendors combine a seat price or flat platform fee with one usage unit. The diagram below follows one run of our reference agent through all five meters.

3.1 What each unit rewards and punishes

Per-trace billing (LangSmith, and Galileo before its move into Splunk) charges the same for a two-step run and a two-hundred-step run. It rewards long, complex agents and punishes high-volume, simple ones, because a simple classifier agent that runs a million times pays a million trace fees. Per-span billing (Langfuse, Opik, Sentry, Logfire, Arize) charges for every step, so it rewards short agents and punishes agents that loop, retry or call many tools. Per-model-call billing (Datadog, Grafana's new agent product, and the proxies like Helicone) ignores tool calls entirely, which makes it unusually kind to tool-heavy agents such as browser and data agents.

Per-byte billing (Braintrust, Weave, Laminar and the clouds) is the one that matters most for agents and is the least intuitive. It ignores how many steps a run has and charges for how much text the run produced, which means it charges for context. An agent whose prompts carry a long system prompt, a growing conversation history and large tool results produces large spans, and every byte is billed at ingestion. Braintrust measures processed data "at ingestion, so deleting data doesn't reduce it" - Braintrust plans and limits. Our guide to context engineering explains why agent contexts grow the way they do, and on a byte-priced tool every technique in it also lowers your observability bill.

Sources: each vendor's pricing page, retrieved October 18, 2026; reference run defined in section 4.

The table shows why "free tier" comparisons mislead. Logfire and Sentry look absurdly generous, covering hundreds of thousands of runs, but both limit the free plan to a single user, so they are free for a solo developer rather than for a team. Datadog's free tier covers more real agent runs than Langfuse's or Opik's because it does not count tool calls. And the byte-priced free tiers depend entirely on your payload size: an agent that stores 50 KB per run gets four times as many free runs on Braintrust as our 200 KB reference agent.

3.2 The practical rule: match the unit to the shape of your agent

The way to use this is to describe your own agent in three numbers before reading any price list: runs per month, steps per run, and kilobytes per run. A support agent that answers short questions has many runs, few steps and small payloads, which favors per-span and per-byte tools. A research or coding agent has fewer runs but dozens of steps and very large contexts, which favors per-trace and per-model-call tools and makes byte pricing expensive. A browser agent makes a handful of model calls and a great many tool calls, which is the ideal case for Datadog's model-call unit.

Once you know those three numbers, the price comparison takes minutes, and section 14 does it for our reference agent across three volumes. If you do not know them yet, a week of traces in any free tier will tell you, which is the bake-off described in section 18. The one mistake to avoid is choosing a tool on its headline price before knowing your shape, because the unit can move your bill by a factor of ten in either direction while the headline price moves it by a factor of two.

4. How we priced and scored the nine tools

A comparison on price is only as honest as the workload behind it, so this section states ours explicitly. We defined one reference agent that resembles a typical production agent in late 2026, priced it on each tool's live October price list, and kept every assumption fixed across tools. Where a vendor's page left something ambiguous, we say so in that tool's profile rather than quietly choosing the more flattering reading.

The nine tools were chosen to cover the market as buyers actually meet it: the five dedicated agent and LLM observability platforms that appear in most shortlists (Langfuse, LangSmith, Braintrust, Arize, Opik), the two general observability suites most teams already pay for (Datadog and Sentry), a telemetry-native newcomer with an unusually simple meter (Logfire), and an ML platform that many data science teams already use (Weave). Tools that are winding down, have no public price, or are too new to price are covered in section 16.

4.1 The reference workload

The reference agent handles one user request per run. Each run produces one trace of 20 spans: six model calls, ten tool calls and four other steps such as retrieval and hand-offs. Each model call reads about 8,000 input tokens and writes about 500 output tokens, and the stored payload of a run (prompts, outputs and tool results) comes to about 200 KB. A team of five engineers uses the tool, and we price three volumes: 10,000 runs a month (a pilot), 100,000 (a product with real users) and 1,000,000 (a scaled product). No evaluation scores are included in the base case, because scoring volume varies too much between teams; section 15 prices it separately.

These numbers are deliberately middle-of-the-road. Twenty steps is short for a coding or research agent and long for a support bot; 8,000 tokens of context per model call is modest next to the 1M-token windows the current frontier models accept, and 200 KB per run follows directly from it (six calls of roughly 32 KB of prompt text each, plus outputs and tool results). If your agent is leaner, byte-priced tools get cheaper; if it is heavier, they get more expensive, and section 14 shows exactly how fast. The span-priced and trace-priced tools do not move with payload at all, which is the single most useful fact to carry into a vendor conversation.

Five engineers and three volume levels were chosen because that is where buying decisions are actually made. A team of five is large enough that seat fees show up on the bill and small enough to qualify for every self-serve plan in this guide, and the three volumes correspond to the moments when teams typically re-evaluate their tooling: when a pilot goes live, when a product finds real users, and when finance starts asking why the bill grew.

The rules for choosing a plan are simple and identical for every tool:

• Cheapest self-serve plan that fits five users and the monthly volume
• Published overage rates applied exactly as listed, including volume tiers
• Annual rates where the vendor quotes annual pricing by default
• No negotiated discounts, startup credits or enterprise deals
• Custom pricing reported as custom, never estimated

Two of those rules deserve a word of explanation. Using the cheapest plan that fits means some tools are priced on plans with short retention (Braintrust's Starter keeps 14 days, Datadog 15), which is fair for a price comparison but not for a compliance requirement, so each profile also lists the price of longer retention. And reporting custom pricing as custom, rather than guessing, penalizes Arize in the table because its hosted product has no published price above a small starter tier; that is a real cost to buyers, since you cannot plan a budget around a number you have to ask for.

4.2 The number to compare against: your model bill

A price only means something next to the cost it protects, and for agent observability that cost is the model bill. Take the reference run on Claude Sonnet 5.5, which Anthropic lists at $2 per million input tokens and $10 per million output tokens - Anthropic models overview. One run uses 48,000 input tokens ($0.096) and 3,000 output tokens ($0.03), so roughly $0.13 per run before prompt caching. At a million runs a month, that is about $126,000 of inference.

Against that bill, every observability tool except one is small. At a million runs, the most expensive mainstream option in our table (LangSmith at $5,145) is about 4% of the inference it watches, and the cheapest (Sentry at $56) is a twentieth of one percent. That reframes the buying question. Saving $150 a month on tracing matters to a startup at 10,000 runs, but at a million runs the observability line is a rounding error, and the right tool is the one that finds the prompt bug or the runaway loop that is quietly costing ten times its subscription. Prompt caching and model routing usually cut far more from the total than any observability discount, as we showed in our guides to prompt caching and model routing, and you need traces to do either well. The exception is Weave, whose byte pricing at a million runs reaches about 16% of the model bill, which is the clearest case in this guide of a unit that does not fit agent data.

5. Langfuse: the open-source default, now owned by a database company

Langfuse is the most widely deployed open-source tool in this category, and in January 2026 it gained an unusual owner: ClickHouse, the analytics database company whose engine Langfuse already used to store traces. The deal was announced alongside ClickHouse's $400 million Series D - ClickHouse, and the acquirer committed in the same post that "Langfuse remains 100% open-source under its existing MIT license for core features." For buyers, that ownership is a structural signal worth reading correctly. A database company does not need to maximize margin on the observability layer; it needs as many traces as possible flowing into its database. That incentive points toward low prices and a permissive license, which is exactly what the current price list shows.

The billing unit is the one most likely to surprise newcomers, because it counts everything. "Units = Count of Traces + Count of Observations + Count of Scores" - Langfuse billable units, and the documentation is explicit that units created by Langfuse's own features count too: "whether it is sent by your application or created by Langfuse features such as LLM-as-a-Judge, Annotation Queues, or experiments." An observation is Langfuse's word for a span: "LLM calls, tool calls, retrieval steps" - Langfuse data model. Our reference run of 20 steps therefore costs 21 units (one trace plus 20 observations), before any scores.

Source: Langfuse pricing, retrieved October 18, 2026. Overage falls to $7 per 100K units from 1 million units, $6.50 from 10 million and $6 from 50 million.

5.1 What it costs at our three sizes

At 10,000 runs (210,000 units) the Core plan costs about $38 a month: $29 plus 110,000 extra units at $8 per 100,000. At 100,000 runs (2.1 million units) the volume tiers start to help, and Core comes to about $178 a month. At one million runs (21 million units) Core is about $1,446 a month, and Pro, which adds three years of history and compliance reports, is $170 more. Because users are unlimited on every paid plan, a team of five pays the same as a team of fifty, which matters more than it looks: per-seat pricing is often the largest line item on a small team's bill elsewhere.

The free self-hosted version changes the arithmetic entirely. "Self-hosted Langfuse (OSS) is free under the MIT license, so there is no usage-based billing" - Langfuse billable units. What you pay instead is infrastructure and attention: Langfuse version 3 runs on ClickHouse, Redis, Postgres and object storage, and community threads describe the operational load honestly, including a discussion titled "Requirements doubled from v2 to v3" - Langfuse GitHub. A further timing note for self-hosters: the v4 changelog says "Langfuse Cloud becomes v4-only on November 16, 2026", with v3 self-hosted getting "security patches through January 2027" - Langfuse changelog, so anyone standing up v3 today has a migration on the calendar.

5.2 Agent depth, and who it is for

For agents specifically, Langfuse includes "Traces and Graphs (Agents)" and "Session Tracking (Chats/Threads)" on every tier, including the free one, and it accepts OpenTelemetry: "Langfuse aims to be compliant with the OpenTelemetry GenAI semantic conventions" - Langfuse OpenTelemetry docs. The July 2026 update added an expanded agent graph that draws each step of a run as a node next to the trace tree, with the cost of each step visible inline - Langfuse July update.

The graph in that screenshot is the practical answer to the question "where did this run go wrong?": the invoke_agent node fans out into numbered steps and tool calls, so a loop or a skipped tool shows up as a shape before you read a single prompt. Langfuse is the right default for teams that want low cost at every scale, unlimited seats, and the option to bring the whole thing in-house later without changing instrumentation. Its weak point is the one that comes with counting every observation: a very chatty agent with hundreds of steps per run grows the bill linearly with its verbosity, so sampling (covered later) matters more here than on per-trace tools.

The Langfuse team's own walkthrough, published in September 2026, shows the agent tracing flow end to end, starting with how a single agent run appears as a trace at the 1:57 mark and moving on to dashboards and evaluation experiments.

6. Pydantic Logfire: one meter for agents and everything else

Pydantic Logfire comes from the team behind Pydantic, the validation library that sits underneath most Python AI frameworks, and its pricing reflects a philosophy rather than a product tier: an agent trace is just telemetry. "One record-based meter covers AI observability, evals, application performance, and infrastructure", and "Every plan includes $20 of free usage a month: 10 million spans, logs, or metrics. After that, $2 per million on Team and Growth" - Pydantic pricing. There is no separate agent product, no per-trace fee, no per-agent fee and, importantly for agents, no charge for the size of a span.

That last point is why Logfire lands near the top of a price comparison built around agents. Our reference run produces 20 records whether its prompts are 2 KB or 200 KB, so the context-heavy agents that are expensive on byte-priced tools cost Logfire the same as lean ones. The trade-off is that Logfire is a general observability tool with strong AI features rather than an AI platform with general features, so the agent-specific experience (graphs of agent decisions, annotation queues, prompt management) is thinner than on the dedicated platforms.

Source: Pydantic Logfire pricing, retrieved October 18, 2026.

6.1 What it costs at our three sizes

At 10,000 and 100,000 runs, our reference workload (200,000 and 2 million records) fits inside the Team plan's 10 million included records, so the bill is the flat $49 a month with five seats included. At one million runs (20 million records) it rises to $69 a month: the base price plus ten million extra records at $2 per million. Even at ten million runs a month, the arithmetic gives about $429. If you need 90 days of history, the Growth plan at $249 removes seat fees entirely, which makes it cheaper than Team for any group larger than about 13 people.

Logfire also handles the evaluation cost question unusually cleanly. Its product page states that evals run "offline against a dataset" and "live against production traffic", and that because "a score is just an attribute on a span", evals are "billed as ordinary records with no per-score fee" - Pydantic Logfire. On most other tools, scores are either a separate meter (Braintrust) or extra billable units (Langfuse), so a team that plans to score every production run should weigh this heavily. The judge model's own tokens are still yours to pay, of course; Logfire simply does not charge a second time for storing the result.

6.2 Who it is for, and the limits

Logfire is the right choice for Python-heavy teams that want one place for agent traces, API latency and database queries, and for anyone who wants to query traces with ordinary SQL: the product exposes a records table you can query directly, which makes cost-per-model and slowest-step questions a single query. Its SDK is MIT-licensed on GitHub, it speaks OpenTelemetry natively, and a coding agent can read traces through the Logfire MCP server. Pydantic's own case studies include Dosu, which it says "cut agent debugging time 90%", a vendor claim worth treating as a direction rather than a benchmark.

The limits follow from its design. Self-hosting is available only on Enterprise, via a Helm chart; the free plan is a single-seat plan, so it is free for individuals rather than teams; and the agent-specific views are less developed than Langfuse's or LangSmith's. If your evaluation workflow depends on human annotation queues or prompt versioning built into the observability tool, you will either live without them or pair Logfire with a second tool, which erodes the price advantage.

7. Comet Opik: the cheapest full agent platform with a price list

Opik is the open-source LLM and agent observability platform from Comet, the ML experiment-tracking company, and it is the quiet price leader among the dedicated agent platforms. Its hosted Pro plan costs $19 a month for "Up to 50 team members" and "100k spans per month", with "Additional Spans: $5/100k spans" - Comet pricing. That overage rate is between a quarter and 40% below Langfuse's per-unit price, depending on volume, and unlike several competitors, Comet publishes it on the page rather than behind a sales call.

The open-source side is just as relevant to price. The repository is licensed Apache-2.0 and has about 22,700 GitHub stars, and Comet describes it as "True OSS: same codebase as the hosted versions". Its self-hosting docs say you get "all Opik features including tracing, evaluation, etc but without user management features" - Opik self-hosting docs, which means a team that can run its own infrastructure gets the full agent toolset for the cost of the servers. Comet itself remains independent, which, after the acquisitions described in section 2, is a fact worth noting rather than assuming.

Source: Comet pricing, retrieved October 18, 2026. Extending retention from 60 to 400 days costs $29 per 100K spans.

7.1 What it costs at our three sizes

At 10,000 runs (200,000 spans) Pro costs $24 a month. At 100,000 runs (2 million spans) it costs $114, and at one million runs (20 million spans) about $1,014. Up to 50 people can share the plan at no extra cost, so a five-person team and a forty-person team pay the same. Our model counts 20 spans per run; Comet's pricing page does not say whether the parent trace record also counts as a span, so if it does, add 5% to these figures.

The one expensive line on Opik's price list is long retention. Keeping spans for 400 days instead of 60 costs "$29/100k spans", which at a million runs a month is roughly $5,800 a month on top of the base bill, more than five times the base price. That is not unusual in this market (retention is the hidden premium almost everywhere, as section 15 shows), but it means Opik's low headline only holds if 60 days of searchable history is enough. If you need a year of records for audit purposes, the cheaper design is to keep 60 days in Opik and the long tail in a write-once bucket, as section 17 describes.

7.2 Agent depth, and who it is for

For agent work, Opik's docs cover logging agent graphs, evaluating agent trajectories, trajectory accuracy metrics, online evaluation rules on production traces, and threads that group "related traces that form a coherent conversation" - Opik tracing concepts. It also ships an in-product assistant that "reads full span trees including inputs, outputs, latencies, token counts, and feedback scores". OpenTelemetry ingestion is native, with one caveat in its own docs: it "currently supports HTTP transport" and "if you use the GRPC exporter you will face errors" - Opik OpenTelemetry docs.

Opik is the right choice for budget-conscious teams that want a full agent platform (traces, evals, graphs, prompt work) rather than general telemetry, and for teams that want a credible self-hosted path under a permissive license. Its weaker spots are maturity signals rather than missing features: an open GitHub issue notes that "LLM monetary costs are recorded with no currency" - Opik GitHub, its free cloud tier is a hard cap with no pay-as-you-go, and its US-only data region on Free and Pro rules it out for some European buyers unless they self-host.

8. Sentry: agent tracing inside the error tracker you already run

Sentry is the error-tracking and performance tool that a large share of software teams already have installed, and in 2026 it made agents a first-class part of it at no extra charge. "Agent traces are part of your existing Sentry distributed traces. Your gen_ai.* spans appear alongside your HTTP, database, and queue spans in the same trace hierarchy. No separate product, no additional system" - Sentry AI agent tracing. The same page states that "Agent tracing, dashboards, and cost tracking are available on every Sentry plan, including the free Developer plan."

That design gives Sentry the lowest bill in this guide. Agent spans are billed like any other span, and spans are cheap: the Team plan costs $26 a month on annual billing with unlimited users and 5 million spans included - Sentry pricing, and additional spans on Team cost between $1.60 and $2.00 per million depending on whether you reserve them in advance - Sentry pricing docs. Like Logfire, Sentry does not charge for the size of a span, so context-heavy agents cost the same as lean ones.

Source: Sentry pricing and Sentry pricing docs, retrieved October 18, 2026.

8.1 What it costs at our three sizes

At 10,000 and 100,000 runs (200,000 and 2 million spans) everything fits in the Team plan's 5 million spans, so the bill is $26 a month. At one million runs (20 million spans) it is $26 plus 15 million spans at the pay-as-you-go rate of $2.00 per million, or about $56 a month. Those agent spans share the same quota as the rest of your application's tracing, so if your web app already uses most of its span budget, the real marginal cost is the overage rate, which is still about $40 per million agent runs.

Two details matter more than the price. First, prompts are off by default: "Sentry considers LLM and tool inputs/outputs as PII and doesn't include PII data by default", and you turn them on with send_default_pii=True - Sentry OpenAI Agents docs. That is a sensible privacy default, but it means a fresh install shows you the structure of a run without the content, which is the part you usually need for debugging. Second, Sentry's budget behavior is strict: "Any data sent after you've run through your reserved volume and PAYG budget will be dropped and you won't be charged for it. This means that you'll lose monitoring for the remainder of the billing cycle" - Sentry pricing docs. That protects the bill, at the cost of a blind spot exactly when traffic spikes.

8.2 Who it is for, and the limits

Sentry is the right choice for teams that already run Sentry and want agent visibility next to the errors, slow queries and frontend crashes that often cause bad agent outcomes. Its agent features are real: model calls, tool executions and hand-offs in one hierarchy, MCP tool calls as gen_ai.execute_tool spans, and a Conversations view that turns spans "into a chat-like replay of any user session with your AI assistant". It is also one of Anthropic's twelve OpenTelemetry partner destinations, so Claude API traces can flow in without SDK work.

What it lacks is the evaluation half of the category. Its agent pages describe tracing, dashboards and cost tracking, not judge-model scoring, datasets, experiments or annotation queues, so a team that wants to measure answer quality systematically will need a second tool for evals. Self-hosted Sentry exists under the Functional Source License, which converts to Apache 2.0 after a delay, but it is a substantial system to operate. For many teams the practical pattern is Sentry for always-on tracing and errors, plus a lightweight eval tool for quality, and even that pairing usually costs less than a single mid-tier plan elsewhere.

9. Braintrust: the evaluation-first platform, billed by the gigabyte

Braintrust started as an evaluation tool and grew into observability from that side, which shows in both its product and its price list. It raised an $80 million Series B led by ICONIQ in February 2026, a round SiliconANGLE framed as a bid to become the observability layer for AI - SiliconANGLE, and repackaged its plans on March 16, 2026 - Braintrust billing FAQ. Of the dedicated platforms, it is the one most focused on the question "is the agent getting better?" rather than "what did the agent do?".

Its billing has two meters, and both matter for agents. Processed data is "the total bytes of data ingested across logs, experiments, and datasets", including "inputs, outputs, prompts, metadata, traces and spans", and it is "Measured at ingestion, so deleting data doesn't reduce it" - Braintrust plans and limits. Scores count every recorded evaluation result. Users are unlimited on every plan, so team size never changes the bill, but payload size and scoring volume change it a great deal.

Source: Braintrust pricing, retrieved October 18, 2026. Qualifying startups that have raised at least $100K can get 6 to 12 months of Pro for free.

9.1 What it costs at our three sizes

Because Starter is pay-as-you-go with unlimited users, it is the cheapest plan that fits our five-person team at every volume, as long as 14 days of history is enough. At 10,000 runs (2 GB) it costs about $4 a month, at 100,000 runs (20 GB) about $76, and at one million runs (200 GB) about $796. Pro, which most production teams would choose for its 30-day window and cheaper overage, costs $249, $294 and $834 at the same volumes. Scores come on top: scoring 10% of a million runs with one judge produces 100,000 scores a month, which adds about $75 on Pro or $225 on Starter.

The number to watch is payload, not runs. Every figure above assumes 200 KB per run; an agent that carries 400 KB of context per run doubles the data line, and one that carries 50 KB cuts it by three quarters. Section 14 charts exactly where byte pricing beats and loses to span pricing. Retention is the second lever: keeping 180 days on Pro costs $0.50 per GB-month beyond the first 30 days, which at 200 GB a month adds roughly $500 a month once the history has built up. Braintrust also states plainly that it "doesn't offer hard spending limits that prevent usage" - Braintrust billing FAQ, so the bill tracks your traffic with no ceiling.

9.2 Agent depth, and who it is for

Braintrust's agent tooling is among the strongest in the table: online scoring of production traces, thread views for multi-turn agents, a Debugger that "explains likely failure modes in complex individual runs" - Braintrust blog, Topics (automatic clustering of patterns across traces) and Loop, an in-product agent that helps write scorers and prompts. Its OpenTelemetry support follows the standard: "Braintrust implements the OpenTelemetry GenAI semantic conventions" - Braintrust OpenTelemetry docs. Its October 2026 post on coding-agent costs shows the cost side of that tooling, breaking spend down by model, tokens, cache reads and sessions.

The table in that view is the practical payoff of tracing for a finance team: cost per million tokens and cache reads per model, side by side, which is exactly the data needed to decide where prompt caching or a cheaper model would pay off. Braintrust is the right choice for teams whose main problem is quality, who will score a meaningful share of production traffic and want the evaluation workflow to be first-class. Its weaker points are control and predictability: "Self-hosting is only available on the Enterprise plan" - Braintrust self-hosting docs, and even then "The control plane is always operated by Braintrust" - Braintrust deployment docs.

For a hands-on view of that workflow, Braintrust's Doug Guthrie ran a long workshop at AI Engineer in October 2026 that traces a customer-support agent built on the OpenAI Agents SDK, then moves from offline evals and custom scorers to online scoring of production traffic. The opening section on reading agent traces is the most relevant part for buyers; the rest is a practical eval tutorial. If you are building on that SDK, our OpenAI Agents API guide covers the agent side.

10. Datadog Agent Observability: you pay only for the model calls

Datadog is the default choice for any company that already runs its infrastructure monitoring there, and in 2026 it made two changes that matter for this comparison. It renamed its LLM Observability product to Agent Observability, and it repriced it so that it can be bought on its own: "Agent Observability is a standalone product and can be purchased without any other Datadog subscription" - Datadog pricing. For teams that never touched Datadog because of its reputation for complex bills, the new pricing is the simplest unit in this guide.

The key design decision is what Datadog counts. "An LLM span is a single call to an LLM provider such as OpenAI or Anthropic", and Datadog "bills only on LLM spans, not on tool spans, retrieval spans, or other workflow spans surrounding the model call." For agents this is a meaningful structural advantage. An agent that calls ten tools between every model call costs the same to observe as one that calls none, so tool-heavy agents (browser agents, coding agents, data agents) are relatively cheap here, while chatty agents that make many small model calls are relatively expensive.

Source: Datadog Agent Observability pricing, retrieved October 18, 2026.

The free tier is generous in a way that is easy to misread: 40,000 LLM spans covers roughly 6,700 runs of our reference agent (six model calls each), which is a real prototype, not a toy. The catch is retention. Every plan keeps traces for 15 days by default, and longer windows are priced per span: "30-day retention at $6.50 per 10K LLM spans per month", "60-day retention at $8 per 10K", and "90-day retention at $9 per 10K". Datadog's page does not make clear whether those rates replace or add to the base rate, so a team that needs 90 days of history should get that answered in writing before it signs.

10.1 What it costs at our three sizes

At 10,000 runs (60,000 LLM spans) the free tier is exceeded, so the floor is Pro at $160 a month on an annual commitment or $240 on demand. At 100,000 runs (600,000 LLM spans) the bill is $160 plus 50 blocks of 10,000 extra spans at $3.50, or $335 a month annual ($490 on demand). At one million runs (six million LLM spans) it is $160 plus 590 blocks, or about $2,225 a month annual and $3,190 on demand. The price list carries no per-seat fee, so adding engineers does not change the bill.

For agents, the product's strengths are the graph of each agent's decision path, built-in evaluations, and native OpenTelemetry support: Datadog announced that it "natively supports OpenTelemetry GenAI Semantic Conventions (v1.37 and up)" - Datadog blog, and its docs say spans can arrive "without requiring the Agent Observability SDK or a Datadog Agent" - Datadog docs. One detail in those docs is worth knowing before you migrate: "Spans without any gen_ai.* attribute are also dropped individually", so tool spans you care about must carry GenAI attributes to show up.

10.2 Agent depth, and who it is for

Datadog's cost reporting is built for exactly the budgeting question raised in section 2. Its July 2026 post on agent token costs describes "per-call cost breakdowns calculated from providers' public pricing" and "span-level traces with input and output token counts" - Datadog blog. The trace view below shows a single agent run broken into planning, execution, tool and model spans, with the selected Anthropic request showing its tokens and estimated cost.

Because the same platform holds your application traces, infrastructure metrics and user sessions, a slow or expensive agent run can be tied to the database query, deployment or region that caused it, which no standalone agent tool can do. Datadog is the right choice for companies already running Datadog, where agent observability joins an existing contract and existing on-call habits, and for tool-heavy agents, where billing only on model calls is a genuine saving. It is a weaker choice for teams that want to self-host, keep traces for months at low cost, or avoid deeper dependence on a single vendor. A competitor's analysis of Datadog's pricing points out that its integrations are enabled by default, so "adding OpenAI, LangChain, Bedrock, CrewAI or MCP produces billable spans with no code change" - TrueFoundry; that is written by a rival vendor, but it is a sensible thing to check in your own configuration before the first invoice.

11. Arize Phoenix and Arize AX: free to self-host, custom above the starter tier

Arize sells two products that share one company and very different economics. Phoenix is its open-source tracing and evaluation tool, with about 11,900 GitHub stars, and AX is its hosted enterprise platform. Since October 1, both belong to Dynatrace, which "has completed its acquisition of Arize" and says "Arize will continue supporting both Phoenix, its open-source platform, and AX, its enterprise platform. Over time, Arize capabilities will be integrated into Dynatrace" - Dynatrace. For a buyer, that last sentence is the one to plan around.

Phoenix is the price story. Its docs promise "100% Free No license fees, no usage limits, no feature gates" and state that "Phoenix is free to self-host with no feature limitations" - Phoenix self-hosting docs, and its default retention policy is "0 days, which is equal to 'Indefinite' retention" - Phoenix data retention docs. The license is the Elastic License 2.0, which permits free internal use but says "You may not provide the software to third parties as a hosted or managed service", so it is source-available rather than open source in the strict sense. For a company tracing its own agents, that restriction rarely matters.

Source: Arize pricing, retrieved October 18, 2026. AX plans include unlimited users.

11.1 What it costs at our three sizes

On the hosted side, our reference workload outgrows AX almost immediately. AX Pro's 50,000 spans cover about 2,500 runs a month, and since July Arize no longer publishes what additional spans cost: the tracker UsagePricing recorded that Arize "removed the explicit $10-per-million-spans and $3-per-GB overage rates from its pricing page" - UsagePricing. At 10,000, 100,000 and one million runs, AX is therefore a custom quote. If the old rates still applied, a million runs (20 million spans, 200 GB) would have cost about $50 plus $200 for spans plus about $570 for data, but that is history, not a price you can buy at today.

Phoenix inverts the calculation. The license costs nothing at any volume, so the bill is your infrastructure plus the engineering time to run it. That time is real: an open issue on self-hosted Phoenix reports that fetching large span datasets "returns 504 and degrades Phoenix UI" - Phoenix GitHub, the kind of scaling problem every self-hosted tracer runs into eventually. Budget for it the way you would for any analytics database you run yourself: storage that grows every month, backups, upgrades, and a named person who owns it when the dashboard slows down.

11.2 Agent depth, and who it is for

Arize's agent tooling is strong on both products. The pricing table lists "Agent trajectory visualizations (path and graph)", "Session support", "Online evals on traces/spans: Unlimited", trace-level evals of agent trajectories and session-level evals of multi-turn conversations on every AX tier, including Free. Phoenix accepts OpenTelemetry and converts standard gen_ai.* attributes into its own OpenInference format. A recent Arize post makes the case for reading trajectories before reaching for a judge model, with a trace in which "Every span reports success. The agent noticed the failure, and shipped anyway" - Arize blog.

That screenshot is the clearest illustration in this guide of why agent observability differs from ordinary monitoring: a status-code dashboard would show this run as perfectly healthy. Arize is the right choice for teams that will self-host and want a mature open tool with no usage meter, and for enterprises already moving to Dynatrace, for whom AX will likely arrive inside an existing contract. It is the wrong choice for a mid-size team that wants a hosted product with a predictable public price above a few thousand runs, because that product currently does not exist on the price list.

12. LangSmith: the deepest LangGraph integration, at the highest per-trace price

LangSmith is LangChain's observability, evaluation and deployment platform, and for teams building on LangChain or LangGraph it is the path of least resistance: tracing works with one environment variable, and the views are designed around how those frameworks structure an agent. It is also the most feature-dense product in this guide. The September 2026 release added "LangSmith Trajectories, a conversational view of an agent session", Engine v2, which "introduces major advancements for issue detection, testing and validation", and Managed Deep Agents, which "combines the Deep Agents harness with managed infrastructure" - LangChain blog.

Its pricing changed in October. Self-serve customers "are moving onto the October 2026 plans, which price usage in LangChain Standard Units", while customers with contracts or credit grants stay on their current plan - LangSmith changelog. One LSU equals one dollar, and the pricing page's own tooltip lists "0.005 LSU/base trace" and "0.0025 LSU/extended trace upgrade" - LangChain pricing, which works out to $5 per 1,000 base traces and $7.50 per 1,000 extended ones. Seats are billed on top.

Source: LangChain pricing, enterprise pricing and LangSmith pricing FAQ, retrieved October 18, 2026. Startups can apply for up to $10,000 in credits.

12.1 What it costs at our three sizes

Per-trace pricing means LangSmith charges the same for our 20-step run as for a 2-step one, which is its structural advantage for long agents. For our five-person team, though, the seat fees and the trace price add up quickly. At 10,000 runs the bill is $195 a month, entirely seat fees. At 100,000 runs it is $645 ($195 plus 90,000 traces at $5 per 1,000), and at one million runs about $5,145. If every trace is upgraded to extended retention, the million-run figure becomes about $7,620.

That last scenario is less hypothetical than it sounds, and it is the trap to understand before signing. Traces are upgraded to extended retention automatically by "Online evaluators", by "Automation rules" (where "Matching a single run upgrades the entire trace"), and by feedback sent with a retention flag - LangSmith usage and billing. The same page adds that "A rule whose item type is Threads upgrades every trace in the matched thread". In other words, turning on an online evaluator across your production traffic quietly raises your trace price by 50%. LangSmith also meters its newer features separately: tuned evaluators cost "0.015 LSU / Evaluation Run" and an Engine run "can consume ~7-45 LSUs", scheduled every six hours - LangSmith pricing FAQ.

12.2 Agent depth, and who it is for

On agent depth LangSmith has no superior in this table. It shows nested run trees for every trace, threads for multi-turn sessions, the new Trajectories view that reads like the conversation the agent had across all its sub-agents, Engine for automated issue detection, and a full evaluation and experiment workflow. It also ingests OpenTelemetry: "LangSmith receives spans at its OTLP endpoint and displays them as traces", mapping standard GenAI attributes such as gen_ai.operation.name onto its own run types - LangSmith OpenTelemetry docs, so it is not limited to LangChain code.

The Trajectories screenshot shows why teams pay LangSmith's premium: a reviewer reads the agent's session as a conversation, with each tool call in place, instead of expanding a tree of execution metadata, and the cost of the whole session (under twenty cents in this example) sits in the same panel. LangSmith is the right choice for LangGraph teams with long, complex agents, where per-trace pricing and native framework views pay off. It is the expensive choice for high-volume, short agents, and its control story is weak for a price-sensitive buyer: self-hosting exists only on Enterprise, and even self-hosted traces are billed at 0.0075 LSU each, so running it on your own servers does not remove the meter. LangChain's own five-minute explainer, published in September with about 80,000 views, is the fastest way to see how runs, traces and threads fit together.

The video makes the core argument well: an agent without tracing is a black box, and the trace is the only place where the reason for a bad answer is written down. For a broader view of where LangGraph sits among agent frameworks, see our comparison of LangGraph, CrewAI and AutoGen.

13. Weights & Biases Weave: excellent tools, a byte price that punishes agents

Weave is the LLM and agent tracing product from Weights & Biases, the ML experiment-tracking platform that CoreWeave acquired in May 2025 - CoreWeave. Since September 30, 2026, it is sold inside CoreWeave Forge, a bundle that combines "Weights & Biases Models", post-training tools and a new agent product called Agent Lens - CoreWeave. The old W&B pricing page now redirects to Forge's.

Weave's agent features are good and getting better. Its agents view shows that "Each conversation shows a multi-turn timeline with nested tool calls, token usage, and feedback", every turn, model call and tool call is emitted as an OpenTelemetry span "tagged with GenAI semantic-convention attributes", and Agent Lens "uses the same trace data as Weights & Biases Weave, so the traces you already send appear there with nothing to migrate" - Weave agent tracing docs. The problem is not the product. It is the unit.

Source: CoreWeave Forge pricing, retrieved October 18, 2026.

13.1 What it costs at our three sizes

Weave bills ingested bytes, which it defines as "trace metadata, LLM inputs/outputs, and any other information you explicitly log to Weave". At $0.10 per MB, that is $100 per GB, compared with $3 to $4 per GB on Braintrust. Our reference run stores about 200 KB, so at 10,000 runs (2 GB) the Pro plan costs about $110 a month, at 100,000 runs (20 GB) about $1,910, and at one million runs (200 GB) about $19,910. The published Enterprise rate is double the Pro rate, and Pro is reserved "For early-stage teams fewer than 50 employees", so a larger company tracing a million runs faces a custom negotiation starting from a list price near $40,000 a month.

This is the clearest example in the guide of a pricing unit designed for a different kind of data. ML experiment logs are small and structured; agent traces are large because they contain the full prompt context of every model call, which is exactly the data you need to debug them. Weave does offer a mitigation for self-managed deployments, server-side ingest sampling, so that "your costs scale roughly with the share of traffic that you keep" - Weave ingest sampling docs, and truncating payloads before they leave your application helps on any plan. Both reduce the bill by throwing away the information an observability tool exists to keep.

13.2 Who it is for

Weave makes sense for existing W&B teams that use it for model training and evaluation, for whom one platform across training runs, evaluations and agent traces is worth a premium, and for low-volume or lean agents where the byte meter stays small: an agent that stores 20 KB per run and runs 50,000 times a month fits in 1 GB. Academic users get "up to 25GB/mo of Weave data ingestion" free, which is generous for research, and the bundle with CoreWeave's training and inference products may make sense for teams that plan to fine-tune models on their own agent traces.

For a production agent with real context windows and real traffic, the arithmetic above is hard to justify, and most teams would be better served sending agent traces to a span-priced tool while keeping Weave for the experiment side of their work.

14. Side by side: what each tool costs at three sizes

With every tool priced on the same workload, the market sorts itself into five clear bands, and the bands follow the billing unit far more closely than they follow product quality. This section puts the numbers next to each other, shows where the bands come from, and then tests the one assumption that moves the ranking most: how much data each run stores. All figures are monthly, in US dollars, on the cheapest self-serve plan that fits five users and the volume, from pricing pages retrieved on October 18, 2026.

The headline result is that the cheapest and most expensive tools differ by more than a factor of 300 at a million runs, while the middle of the market (the dedicated agent platforms) sits within a factor of two of each other. That is good news for buyers: among the tools most teams actually shortlist, price is a secondary decision, and the large differences only appear at the edges, where a pricing unit either ignores agent data (spans priced like any other telemetry) or penalizes it (bytes priced like experiment logs).

Reference workload: 20 spans and about 200 KB per run, six model calls per run, five users, no evaluation scores. Arize Phoenix (self-hosted) has no license fee at any volume.

14.1 Why the bands look the way they do

The bottom band, Sentry and Logfire, prices agent spans the way it prices any other telemetry: by the million, at a couple of dollars, regardless of size. Both are betting that agent data is a small addition to the much larger stream of application telemetry they already handle, and at today's volumes that bet is cheap for them and very cheap for you. The middle band, Braintrust, Opik and Langfuse, is where the dedicated agent platforms compete, and their prices at a million runs (roughly $800 to $1,450) are close enough that features, hosting model and license should decide between them. Datadog sits just above, priced as a premium monitoring product but softened by counting only model calls.

The top band is where the unit stops fitting. LangSmith's per-trace price is reasonable for long agents, but with seat fees and a $5 per 1,000 trace rate it costs about $0.005 per run, five times Opik's per-run cost on our workload. Weave's byte price is the extreme case, because it treats a 200 KB agent run the way an experiment tracker treats a few kilobytes of metrics. Neither is a mistake by the vendor; both are pricing units inherited from a different original product (a framework company's per-trace model and an ML platform's per-byte model) that happen to collide with how agent data is shaped.

14.2 The assumption that moves the ranking: kilobytes per run

The one input that reorders the middle of the table is payload size, because it moves the byte-priced tools while leaving everything else flat. The chart below holds volume at a million runs a month and varies the stored data per run from 50 KB (a lean agent with short prompts) to 800 KB (a coding or research agent with large contexts), comparing a byte-priced tool (Braintrust Pro), a span-priced one (Langfuse Core) and a model-call-priced one (Datadog Pro).

The crossover points are the useful output. Braintrust Pro is cheaper than Langfuse Core until a run stores about 400 KB, and cheaper than Datadog until about 660 KB; above those sizes, the byte meter overtakes both. For a lean customer-service agent, byte pricing is a bargain. For a coding agent that routinely carries 100,000 tokens of context into each model call (roughly 400 KB of text per call, several megabytes per run), it is the most expensive way to buy observability short of Weave. Anthropic's export caps a single span at "0.75 MB of content by default" - Anthropic OpenTelemetry docs, which tells you how large real agent spans can get.

To use this on your own agent, measure the average stored size of a run during a free trial (most tools show ingestion per day), divide by runs, and read your position off the chart. If your agent's context is likely to keep growing, which is the direction most agents are heading as context windows grow, prefer a unit that does not count bytes. If your agent is lean and you value evaluation workflow, the byte-priced tools are often the cheapest way to get it.

15. The costs that never appear on a pricing page

The table in section 14 prices the base case, and for most teams the base case is not where the money goes. Four costs sit outside the headline numbers and routinely double or triple an observability bill: keeping data longer than the default window, scoring traces with a judge model, operating a self-hosted deployment, and paying for the people who use the tool. None of them is hidden in the sense of being secret, since every one is documented somewhere, but none of them shows up in the first number a buyer compares.

They also interact with each other in ways that reward thinking about the whole system rather than the price list. A team that needs six months of history for compliance, scores a tenth of its traffic and has twenty engineers is buying a very different product from the base case, and the ranking changes accordingly. The subsections below price each cost on the same reference workload at a million runs a month, so they can be added directly to the figures in section 14.

15.1 Retention: the premium almost everyone charges

Default retention windows are short: 14 days on LangSmith base traces and Braintrust Starter, 15 on Datadog, 30 on Logfire Team and Braintrust Pro. Longer windows are where vendors make their margin, and the price differences are larger than the base-price differences. Datadog's 90-day option costs "$9 per 10K LLM spans per month" - Datadog pricing, which on our six million monthly LLM spans is $5,400 a month for the retention line alone. Opik's 400-day retention costs "$29/100k spans" - Comet pricing, or about $5,800 a month at our volume. LangSmith's 180-day extended traces raise the trace price by half, from about $5,145 to $7,620 a month.

At the other end, Langfuse Pro keeps "3 years data access" for $170 more than Core - Langfuse pricing, Logfire's Growth plan offers up to 90 days for $249 plus usage, Sentry's Team plan already looks back up to 90 days, and Braintrust Pro charges $0.50 per GB-month beyond 30 days (about $200 a month extra for a 90-day window at our volume). The lesson is structural: retention is cheap to provide (storage costs a few cents per gigabyte) but vendors price it as a compliance feature. If you need long history mainly for audit rather than debugging, keep a short window in the observability tool and the long record in a write-once bucket, which section 17 prices at a few dollars a month.

15.2 Evaluation: the judge model costs more than the tracer

Scoring traces is where observability turns into quality control, and it carries two costs. The first is the platform's fee for storing scores: Braintrust charges $1.50 to $2.50 per 1,000 scores beyond its allowance, Langfuse counts each score as a billable unit, LangSmith upgrades any trace touched by an online evaluator to extended retention, and Logfire stores scores as ordinary records "with no per-score fee". These fees are small. The second cost is the judge model itself, and it is not small at all.

Take a judge that reads 10,000 tokens of trace and writes 300 tokens of verdict. On Claude Sonnet 5.5 at $2 and $10 per million tokens - Anthropic models overview, each score costs about $0.023, so scoring every one of a million runs costs about $23,000 a month, more than any observability tool in this guide. On Claude Haiku 5.5 at its listed starting rate of $0.10 and $0.50 per million tokens, the same job costs about $1,150 a month. Scoring a 10% sample on the cheaper model brings it to roughly $115. This arithmetic explains why vendors are investing in cheap judges: Splunk says Galileo's Luna models "score and protect 100% of traffic at a fraction of the cost of a frontier judge" - Splunk, and Arize argues that some failures can be caught from the trace alone with no judge at all. Our guide to AI agent evals covers how to design the scorers themselves.

15.3 Sampling: the biggest lever, and the one that can hide the failure you need

The single largest cost control in agent observability is deciding not to keep everything. Sampling comes in two forms. OpenTelemetry defines head sampling as "a sampling technique used to make a sampling decision as early as possible", while tail sampling is "where the decision to sample a trace takes place by considering all or most of the spans within the trace" - OpenTelemetry documentation. Head sampling is trivial (keep 10% of runs at random) and risky for agents, because the run you threw away at random is often the one that went wrong. Tail sampling waits until a run is finished and then decides, so it can keep every failed, slow or expensive run and only thin out the healthy ones.

For agents, tail sampling is almost always the right model, with one honest caveat from the OpenTelemetry project itself: it "can be difficult to implement", "can be difficult to operate", and at large scale "can require dozens or even hundreds of compute nodes". For most teams below a few million runs a month, a single OpenTelemetry Collector running the tail sampling processor is enough. The policy below keeps every run that ended in an error, every run that took longer than a minute, and one in ten of the rest, which on a healthy agent cuts every per-span and per-byte bill in this guide by roughly 85 to 90%:

processors:
  tail_sampling:
    decision_wait: 30s
    policies:
      [
        { name: keep-errors, type: status_code, status_code: { status_codes: [ERROR] } },
        { name: keep-slow-runs, type: latency, latency: { threshold_ms: 60000 } },
        { name: sample-the-rest, type: probabilistic, probabilistic: { sampling_percentage: 10 } }
      ]

Two agent-specific warnings apply. First, decision_wait must be longer than your longest normal run, or the collector decides before the trace is complete; agents that work for many minutes or hours, like the ones in our long-running coding agents guide, need sampling decided per session in the application instead. Second, evaluation needs an unbiased sample if you want honest quality metrics: a store that holds 100% of failures and 10% of successes over-represents failures, so compute quality rates from a separate random sample, never from the tail-sampled store.

15.4 Self-hosting is free to license, not free to run

Langfuse, Opik and Phoenix can all be self-hosted at no license cost, and at a million runs a month that saves between $1,000 and $1,500 a month in subscription fees compared with their hosted plans. What it costs instead is infrastructure and attention. Langfuse's current architecture runs on ClickHouse, Postgres, Redis and object storage, a community discussion is titled "Requirements doubled from v2 to v3" - Langfuse GitHub, and an open issue describes retention jobs that "accumulate and block async inserts on S3-backed self-hosted ClickHouse" - Langfuse GitHub. Phoenix and Laminar have their own scaling issues in public trackers.

None of that is a reason not to self-host. It is a reason to price it honestly: the cloud servers are usually the smaller part of the cost, and the larger part is the engineer who owns upgrades, backups and the occasional 2 a.m. disk alert. Self-hosting clearly wins when data cannot leave your network, when volumes are high enough that subscription fees reach thousands a month, or when you already run ClickHouse or Kubernetes well. Below those thresholds, the hosted plans in this guide are usually cheaper than the engineering hours they replace.

15.5 Seats: the cost that grows with your team, not your traffic

The last hidden cost is people. Most tools in this guide have made seats free or nearly free: Langfuse, Braintrust, Arize AX and Sentry Team include unlimited users, Opik Pro covers up to 50 members, and Datadog's price list has no seat line at all. Two do not. LangSmith Plus costs $39 per seat, so a 20-person team pays $780 a month before tracing a single run, and Logfire Team includes five seats and charges $25 for each additional one until its Growth plan removes seat fees.

Seat pricing matters more for agents than for most developer tools, because the people who need to read agent traces are not only engineers. Product managers review conversations, support staff check what an agent told a customer, and compliance teams audit actions. A tool that charges per seat quietly discourages exactly that broad access, which is a hidden cost of a different kind: traces nobody outside engineering reads are traces that cannot catch the problems only a domain expert would notice.

16. Tools that missed the cut, and why

A shortlist of nine leaves out tools that some readers will be using today, and the reasons they were left out are useful in their own right, because most of them are about the market rather than the product. Several well-known names were acquired in 2026 and either stopped developing new features or moved behind a parent company's price list. Others are promising but narrower than the nine, priced in a way that cannot be compared on our workload, or not yet generally available.

None of the tools below is a bad choice in every situation, and a couple are better than anything in the main table for a specific job (Laminar for browser agents is the clearest case). They are here so that a reader who finds one of them on a shortlist knows what changed in 2026 and what to ask before buying. Prices are from the vendors' pages on October 18, 2026.

16.1 Acquired, paused or repackaged

Helicone was one of the most popular open-source LLM proxies and loggers, with a free tier of 10,000 requests and a flat Pro plan of $79 a month - Helicone pricing. In March it announced that "Helicone has been acquired by Mintlify", and that its "services will remain live for the foreseeable future in maintenance mode", with security updates and new model support but no new direction - Helicone. Existing users need not panic, but a new agent project should not start on a product in maintenance mode, which is why it is not in the nine.

Galileo is now part of Cisco, which completed the acquisition in May - Cisco, and is sold as Splunk Agent Observability. Its old pricing page redirects to Splunk's, which quotes "Starting at just $100 per month per 1.2 million spans annually, billed annually" - Splunk pricing, without publishing a span definition, retention period or overage rate. Its small Luna evaluation models remain a genuinely interesting answer to the judge-cost problem in section 15, but the price cannot yet be compared on a like-for-like basis. Portkey, the AI gateway with built-in logging, was bought by Palo Alto Networks and is becoming "PRISMA AIRS AI Gateway" - Palo Alto Networks, and Traceloop, whose OpenLLMetry instrumentation library many tools rely on, is joining ServiceNow while OpenLLMetry stays open source - Traceloop.

16.2 Promising, narrower or hard to price

Laminar is the most interesting young tool in the category for one specific job: browser agents. "Alongside your trace, you get a recording of the browser run synced with your spans", with support for Browser Use, Stagehand, Playwright and others - Laminar docs. It raised a $3 million seed in March - Tech.eu, is Apache-2.0 licensed, and prices by data: a free tier with 1 GB, Starter at $30 a month with 3 GB then $2 per GB, and Pro at $150 with 10 GB then $1.50 per GB - Laminar pricing. Its calculator notes that "Storage costs are not proportional to token count due to trace compression", which makes its per-run cost hard to compare with uncompressed byte meters; for browser-agent teams it belongs on the shortlist regardless. We compared the agents themselves in our browser-use agents review.

Grafana Cloud launched its own Agent Observability product this summer, and its docs state that "Pricing and metering for generations and for evaluation and guard token usage start on October 1, 2026" - Grafana docs. It charges per model call ("generations"): the free tier is "Limited to 30k generations per month", and paid usage "Starts at $1.50/ 1k generations", with trace storage billed separately - Grafana pricing. That is about four times Datadog's per-call rate, so at our million runs (six million generations) the generation line alone would be close to $9,000 a month; it makes sense mainly for teams already standardized on Grafana. AgentOps pioneered agent-specific session replay, but its last SDK release was in August 2025 and its public repository shows little activity since - AgentOps GitHub, a stagnation risk that kept it out. HoneyHive offers a free developer tier of "10,000 events per month" for up to five users with everything else on custom Enterprise pricing - HoneyHive pricing, and Lunary now requires a paid subscription for new cloud workspaces at $20 per user per month - Lunary pricing.

16.3 The cloud you already pay for

The three hyperscalers now trace agents too, and their prices look absurdly low next to the specialist tools, because they bill raw telemetry rather than an agent product. AWS routes Bedrock AgentCore traces into CloudWatch, and its own worked example is 200,000 agent invocations a month producing "10 GB of observability data from approximately 10 million spans (assuming 1 KB per span)", for a monthly total of $6.50 - AWS AgentCore pricing. CloudWatch span ingestion starts at $0.35 per GB - CloudWatch pricing. Treat that example as a floor: a span that carries a full prompt is far larger than 1 KB, and prompts and responses are billed separately as event logs.

Google Cloud sends Vertex AI Agent Engine traces to Cloud Trace at $0.20 per million spans after the first 2.5 million spans per billing account - Google Cloud observability pricing, with prompt text that you log to Cloud Logging billed per GiB. Microsoft states that "There is no charge for monitoring in Azure AI Foundry" - Azure Foundry observability pricing, but tracing lands in Application Insights, where log ingestion is billed per GB after a 5 GB monthly free allowance. DigitalOcean's new Agent Learning Services, in public preview since October 12, add a loop on top of tracing in which "Insights records every step an agent takes, and Signals flags the sessions that matter", but no general-availability price has been published yet.

The trade-off is the same on every cloud. You get cheap, durable storage inside an account your security team already governs, but you assemble the agent-specific experience yourself: trace trees built for model calls, evaluation, prompt playgrounds and cost-per-run dashboards are thinner or absent. Many teams end up with a hybrid, keeping the cloud as the system of record and sending a sampled copy to a specialist tool for debugging, which is exactly the fan-out pattern described in the next section.

17. Audit trails: what observability tools do not give you

Every tool in this guide was designed for one reader: the engineer who needs to find out why an agent failed. That design choice shapes the data model in ways that matter the moment a second reader arrives, such as an auditor, a regulator, a customer's lawyer or your own security team after an agent did something it should not have. Observability stores are built to be edited. Engineers delete traces that contain personal data, overwrite scores, re-run evaluations, attach annotations and let retention windows expire on schedule. Those are features for debugging and liabilities for evidence, because a record that an administrator can quietly change is not proof of anything.

The incidents described in section 2 turned this from a theoretical gap into a purchasing question. When an agent sends the wrong email, deletes the wrong files or spends money it was not supposed to spend, the first question is not "why did the model choose this?" but "what exactly happened, in what order, under whose credentials, and can we show it?" The credentials part is its own discipline, covered in our guide to non-human identity for AI agents. The record part has a cheap structural answer, and it is not a bigger observability plan. It is to write the same trace stream a second time into storage that physically refuses to change.

17.1 The fan-out: one stream, two stores

Because agents now emit OpenTelemetry spans, a single OpenTelemetry Collector can send every span to two places at once: your observability tool (sampled, searchable, editable, short retention) and a write-once bucket (complete, unsampled, immutable, long retention). Amazon S3's Object Lock "uses a write-once-read-many (WORM) model to store objects" - AWS S3 documentation. In its compliance mode, "a protected object version can't be overwritten or deleted by any user, including the root user in your AWS account", and AWS notes that the feature has been assessed for environments subject to SEC 17a-4, CFTC and FINRA rules. Google Cloud Storage and Azure Blob Storage offer equivalent retention locks.

The economics are the surprising part. S3 Standard storage costs $0.023 per GB-month for the first 50 TB - AWS S3 pricing. Our reference agent produces about 200 GB of traces a month at a million runs; compressed, text-heavy trace data typically shrinks to a fraction of that, so a full year of immutable history is on the order of a terabyte, which costs in the low tens of dollars a month to keep by month twelve. Compare that with the retention surcharges in section 15, where keeping 90 days to a year of searchable traces costs thousands of dollars a month on several tools. The two stores do different jobs, so there is no reason to pay one to do the other's.

17.2 The configuration

The collector configuration is short. The awss3 exporter from the OpenTelemetry Collector's contrib distribution writes OTLP JSON files to a bucket with gzip compression, and two pipelines read from the same receiver: one through the tail sampler to your observability tool, one straight to the locked bucket. The bucket itself must be created with Object Lock enabled and a default retention rule in compliance mode, which is a one-time setting in the AWS console or API.

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch: {}
  tail_sampling:
    decision_wait: 30s
    policies:
      [
        { name: keep-errors, type: status_code, status_code: { status_codes: [ERROR] } },
        { name: sample-the-rest, type: probabilistic, probabilistic: { sampling_percentage: 10 } }
      ]

exporters:
  otlphttp/observability:
    endpoint: https://your-observability-vendor-otlp-endpoint
    headers:
      Authorization: "Bearer ${env:OBSERVABILITY_API_KEY}"
  awss3/audit:
    s3uploader:
      region: eu-central-1
      s3_bucket: agent-audit-trail
      s3_prefix: traces
      compression: gzip

service:
  pipelines:
    traces/observability:
      receivers: [otlp]
      processors: [tail_sampling, batch]
      exporters: [otlphttp/observability]
    traces/audit:
      receivers: [otlp]
      processors: [batch]
      exporters: [awss3/audit]

The exporter's README lists its stability as alpha for traces - OpenTelemetry Collector contrib, so test it against your locked bucket before relying on it, and watch the collector's own error metrics. Three further details decide whether the record is actually useful. Keep full content (prompts, tool arguments and results) in the audit copy even if you redact it in the debugging copy, because the content is what an investigation needs; restrict read access to the bucket far more tightly than access to the observability tool; and record which credentials each tool call used, so the trail answers "under whose authority" as well as "what". Our sandbox security guide covers the controls that limit what an agent can do in the first place; the audit trail is what proves those controls held.

The EU AI Act's six-month minimum for deployers of high-risk systems, now due from December 2027 for Annex III systems, is easy to meet this way. So is any internal policy that says agent actions must be reconstructable for a year or more. And because the bucket holds standard OTLP data, it doubles as a replay source: if you change observability vendors in two years, the history comes with you.

18. How to choose, and how to test on your own traffic

The scoring table at the top of this guide ranks the tools on one workload, and your workload is not that workload. The way to turn the table into a decision is to reason from three facts about your situation rather than from the ranking itself: the shape of your agent (runs, steps and kilobytes per run), the systems you already pay for, and who outside engineering needs to read the traces. Those three facts eliminate most of the field before price even comes into it.

It also helps to separate two decisions that vendors like to bundle: where your traces are stored and searched, and where your evaluation workflow lives. Because every tool in this guide accepts OpenTelemetry, those can be different products. A team can run cheap span-priced tracing for everything and a byte-priced evaluation platform for a sampled slice, or keep the cloud as the system of record and a dedicated tool for debugging. The combinations below are common starting points, not rules:

• Already on Datadog or Sentry: start there, since agent spans join an existing contract
• Open source or self-hosting required: Langfuse first, Opik as the low-cost alternative
• Quality is the main problem: Braintrust or LangSmith, with tracing sampled
• Building on LangGraph: LangSmith, if long agents keep per-trace pricing sensible
• Cost per run matters most: Logfire or Sentry, plus a lightweight eval tool

One combination missing from that list is deliberate: there is no line that says "pick the cheapest tool in the table". The cheapest tools are general-purpose telemetry products, and for a team whose agents are central to the business, the price difference between them and a dedicated platform is small next to the model bill and the cost of a quality problem that nobody noticed. Price should decide between tools that do the job, not decide what the job is.

Read those as hypotheses to test rather than answers. The first line is the most reliable, because the cheapest observability tool is usually the one you already pay for, and both Datadog and Sentry have made agent tracing a natural extension of products many teams already run. The second and third lines reflect the real split in this market between tools built for control (open source, self-hostable, cheap per unit) and tools built for judgment (evaluation workflows, scorers, automated issue detection). The last line is where the price ranking in this guide is most decisive, and it is also where a team is most likely to outgrow its choice as its evaluation needs mature.

18.1 A one-week bake-off that prices your own traffic

Pricing pages are written for an average customer, and your agent is not average. The only number that matters is what your own runs cost on each candidate, and the cheapest way to get it is to send one week of real traffic to two or three tools at once. Because every serious candidate now accepts OpenTelemetry, this no longer means instrumenting your code three times. You instrument once, point the agent at a single OpenTelemetry Collector, and let the collector copy the stream to each trial account.

The setup takes an afternoon. Turn on OpenTelemetry in your agent framework or model provider (Anthropic's API can now send spans directly, and most agent SDKs emit GenAI spans natively), run a collector with one exporter per candidate, and leave it running for seven days of ordinary traffic. At the end of the week, each tool's usage page tells you how many of its billable units your traffic produced, which you multiply by its price list. That converts every vendor's private unit (traces, spans, units, gigabytes, model calls) into one comparable number: dollars per thousand of your runs.

exporters:
  otlphttp/candidate_a:
    endpoint: https://candidate-a-otlp-endpoint
    headers: { Authorization: "Bearer ${env:CANDIDATE_A_KEY}" }
  otlphttp/candidate_b:
    endpoint: https://candidate-b-otlp-endpoint
    headers: { Authorization: "Bearer ${env:CANDIDATE_B_KEY}" }

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/candidate_a, otlphttp/candidate_b]

The endpoints above are placeholders: each vendor documents its own OTLP endpoint and header format, and you copy those values in. While the data flows, have two people debug the same three real failures in each tool and time how long it takes to find the cause. That second measurement matters as much as the first, because a tool that saves an engineer an hour a week has paid for a mid-tier plan on its own. If the trial reveals that your runs are much heavier than our 200 KB reference, revisit the payload chart in section 14 before committing to a byte-priced tool.

18.2 The decision above all of this: build the agent, or buy the outcome

Everything in this guide assumes you are building and operating your own agents, which means you own the traces, the evals, the retention policy and the audit trail. That is the right model for companies whose agents are their product. It is a heavy model for companies that simply want work done by agents, because observability is one of five or six disciplines (alongside harness design, sandboxing, identity, cost control and evaluation) that a self-built agent stack requires. Our ranking of enterprise AI agent platforms and our guide to agent harnesses cover what that stack involves.

The alternative is to buy agents that come with their own run history. Managed platforms, from the model labs' own hosted agents to platforms such as O-mega, which builds and runs an autonomous company through AI agents, keep the record of what the agents did inside the platform, so the question shifts from "which tracer should we buy?" to "what does the platform show us, and can we export it?". That trade gives up control over the observability layer in exchange for not having to build one, and it is worth weighing honestly before signing a three-year observability contract for agents you have not yet built.

19. Where agent observability goes next

The forces described in section 2 point in a consistent direction, and reasoning from them gives a clearer picture of the next year than any vendor roadmap. The raw material of observability (spans describing what an agent did) is becoming free and standard, because model providers and agent frameworks now emit it themselves. When an input becomes free, value moves to whatever is still scarce, and in this market the scarce things are judgment (knowing which runs are wrong and why) and trust (being able to prove what happened). Expect pricing to follow value to those two places.

The standard underneath all of this is still settling. The OpenTelemetry GenAI semantic conventions moved into their own repository this year - OpenTelemetry, and the agent span definitions there still carry the status "Development", with spans named after operations such as invoke_agent {gen_ai.agent.name} - OpenTelemetry GenAI conventions. Development status means attribute names can still change, which is a small but real migration risk for anyone building dashboards on today's names. It has not slowed adoption: Datadog, Langfuse, Braintrust, LangSmith, Weave, Sentry and Anthropic's own exporter all read or write these attributes already.

19.1 Five shifts to expect over the next year

Each of the shifts below follows from the structural argument above rather than from any single announcement, and each has early evidence in this month's news. They are worth keeping in mind when signing a contract, because a multi-year commitment signed today will run through all of them.

The common thread is that the parts of observability that are mechanical (collecting spans, storing them, drawing a trace tree) are getting cheaper and more standard, while the parts that need intelligence (deciding which runs are wrong, explaining why, proposing and testing a fix) are becoming the product. That is the same pattern that played out in application monitoring a decade ago, when log collection became a commodity and the money moved to analysis and alerting, except that this time the analysis is itself done by models, which makes it a variable cost that scales with your traffic.

In short, five shifts follow. Instrumentation becomes free, as providers like Anthropic export standard spans directly. Standalone prices fold into suites, as the acquirers bundle their purchases into larger contracts. Judgment becomes the product, with automated issue detection billed on top of storage. Traces become training data, feeding self-improving agent loops. And immutable records become standard, pushed by incidents and regulation.

The third and fourth shifts are already visible in the price lists. LangSmith meters its Engine issue-detection runs separately, Braintrust bills Topics analysis against model credits, Laminar charges per token for its Signals analysis, and DigitalOcean's new services are built around the question its product chief put directly: "does our agent get better with every run" - Business Wire via FinancialContent. CoreWeave's Forge bundles Weave traces with post-training tools for the same reason: the trace of a failed run is the raw material for the training example that fixes it. The practical implication is that the cheapest tracer will matter less each year, while the cost and quality of the analysis layer will matter more.

The first and second shifts cut the other way for buyers. If instrumentation is free and portable, switching costs fall, and a team that keeps its traces in standard OpenTelemetry form can move between vendors as prices change. That argues for three habits now: emit standard GenAI attributes rather than vendor-specific ones, keep a vendor-neutral copy of your traces (the write-once bucket from section 17 does both jobs), and avoid multi-year commitments to a standalone tool whose new owner has not yet said how it will be priced inside the parent's suite.

It is worth pressure-testing this forecast, because the obvious counter-argument is strong. If the model providers can export traces, they can also store and analyze them, and a lab that already sees every token has every incentive to sell evaluation and monitoring itself. That would squeeze the independent tools from below just as the suites squeeze them from above. One reason it has not happened yet is that many production agents use more than one model provider, and a company that routes between Claude, GPT and Gemini models needs a neutral place where all their traces meet. As long as multi-model agents are the norm, which the pricing in our cheapest LLM APIs for agents table suggests they will remain, a neutral observability layer keeps its reason to exist.

20. The bottom line

AI agent observability in October 2026 is a market where the product has converged faster than the price list. Every tool in this guide can trace an agent run step by step, attribute its cost, accept standard OpenTelemetry spans and run some form of evaluation. What still differs, by more than two orders of magnitude, is what they charge for the same data, and the difference comes almost entirely from the billing unit. Per-span and per-record tools that do not count bytes (Sentry, Logfire) are close to free for agents; the dedicated platforms (Braintrust, Opik, Langfuse) cluster between roughly $800 and $1,450 a month at a million runs; per-trace and per-byte units inherited from other products (LangSmith, Weave) are the expensive outliers.

The decision framework that follows from that is short. First, describe your agent in three numbers (runs per month, steps per run, kilobytes per run) and pick the unit that does not punish your shape. Second, start with whatever you already pay for: Datadog and Sentry users should try agent tracing there before buying anything new. Third, choose open source (Langfuse, Opik, Phoenix) if control or self-hosting matters, and an evaluation-first platform (Braintrust, LangSmith) if answer quality is the main problem, sampling traces to keep the bill sane. Fourth, budget for the judge model rather than the tracer, because scoring every run with a frontier model costs more than any observability subscription in this guide. And fifth, keep a complete, write-once copy of your traces outside the observability tool, which costs a few dollars a month and answers the question that the October incidents made urgent: what exactly did the agent do?

For the overall ranking on our workload, Langfuse remains the best balance of price, depth and control, Logfire and Opik are the strongest value picks, and Sentry is the cheapest way to start if it is already in your stack. If you would rather not build and observe agents yourself at all, managed platforms such as O-mega take that whole layer off your hands, and the same questions about what you can see and export apply to them. Whichever path you take, run the one-week bake-off in section 18 before signing anything: your own traffic is the only price list that matters.

This guide reflects pricing pages, product documentation and announcements as of October 18, 2026. AI observability vendors change plans, units and ownership frequently (seven of the companies covered here changed hands within the past eighteen months), so verify current pricing on each vendor's page before purchasing. Cost figures are our calculations from published list prices on a stated reference workload and exclude taxes, negotiated discounts and startup credits.