What Datadog Agent Observability gives you for an agent
Datadog shows each request your application handles as one trace, with a span for each choice the agent makes or each step of the workflow. Each span has a kind. An LLM span is a call to a model. A tool span is a call to a program or service whose arguments the model generated. Workflow, agent, task, embedding and retrieval spans cover the rest of the work.
Around the traces, Datadog's docs describe dashboards for cost, latency and usage, and scanning that redacts sensitive data and identifies prompt injections. Evaluations come in several forms. There are managed evaluators that Datadog maintains, custom LLM-as-a-judge evaluators you write as natural-language prompts, scores you send from your own evaluation system through the API, and annotation queues for human review. The pricing page adds hallucination and drift detection to the evaluator list, and the docs add Patterns, which clusters production traffic by topic so you can watch response quality over time.
Datadog's Insights feature looks for recurring cost and reliability problems, and each insight comes with its root cause, its impact, the supporting evidence and a recommended fix, with no additional configuration.
For work before production, every tier includes a playground for trying prompts and models, versioned datasets built from production traces, and experiments that compare configurations side by side.
Datadog supports LangChain, CrewAI, Pydantic AI, LiteLLM and Strands Agents, SDKs in Python, Node.js and Java, and accepts OpenTelemetry instrumentation or its HTTP API for anything else. So for most teams whose frameworks Datadog supports, the decision turns less on features and more on the bill and on how long traces are kept.
How Datadog LLM Observability pricing works for agents
Datadog bills per LLM span, and an LLM span is a single call to a model provider such as OpenAI or Anthropic. Tool spans, retrieval spans and workflow spans are traced but not billed. In Datadog's words, "You pay for calls to the model, nothing else."
Count the calls to the model, not the steps. Datadog's own example counts three LLM spans in one trace: the model call that decides to retrieve, the reasoning call and the model call that picks a tool. The retrieval and the tool calls they lead to are traced but add nothing to the bill. That suits agents that do much of their work in tools. A request with three model calls and twelve tool calls is billed as three LLM spans.
The size of each call does not change the bill either. Datadog prices by the number of LLM spans, "even as context grows, reasoning gets heavier, and agents use more tools."
The Free tier covers up to 40,000 LLM spans a month with 15-day retention. Pro has three prices, set by how you commit. These are Datadog's list prices as of October 2026.
| Pro plan | Annual commitment | Month to month | On demand |
|---|---|---|---|
| Base price, with 100,000 LLM spans a month included | $160 a month | $200 a month | $240 a month |
| Each extra 10,000 LLM spans | $3.50 | $4.20 | $5 |
Every tier includes the full feature set, and Datadog says multi-year and volume discounts are also available. So for a large contract, read the list price as the starting point for a negotiation.
What a month of LLM spans costs for a support agent
A support agent at 6 million LLM spans a month comes to about $2,225 on an annual commitment and $3,190 on demand, at list price and the default 15-day retention.
To estimate your own month, multiply your requests a day by the model calls in each request, then by 30. Take off the 100,000 LLM spans that Pro includes, divide what is left by 10,000, multiply by the rate for your commitment, and add the base price.
As an illustration, take a support agent that handles 50,000 conversations a day and calls the model four times in each one. That is 200,000 LLM spans a day, or 6 million in a 30-day month. After the included 100,000, the other 5.9 million are 590 blocks of 10,000. The totals below are our arithmetic on Datadog's published rates at the default 15-day retention, not a quote.
| Commitment | Base price | 590 blocks of 10,000 LLM spans | Month |
|---|---|---|---|
| Annual | $160 | $2,065 at $3.50 | $2,225 |
| Month to month | $200 | $2,478 at $4.20 | $2,678 |
| On demand | $240 | $2,950 at $5 | $3,190 |
The agent's tool calls are not in these totals, however many it makes. The number of model calls is what changes the bill. If a new version of the agent calls the model a fifth time in each conversation, the month grows to 7.5 million LLM spans, which is $2,750 on an annual commitment at the same rates.
How long Datadog LLM Observability keeps agent traces
Datadog keeps traces and spans for 15 days on all plans by default. That covers everything on the span, including cost, token counts, latency, errors and the evaluation scores attached to it. Datadog's product-wide retention table gives the same 15-day default for production traces and spans.
If you debug most failures within days, 15 days is enough. It runs short when a failure reaches you late. A customer who writes in three weeks after a wrong answer, or a monthly review of a bad week, finds the trace already gone. It also runs short when you must keep a record. If your compliance team asks you to keep what an agent did with customer data for longer than 15 days, the default does not meet that.
Some data does outlast the spans. Metrics that Datadog builds from your spans follow standard metric retention, 15 months at full granularity, so your dashboards still show the trend after the spans behind them are gone. A trace you annotate is kept for 90 days from the annotation, even if your span retention is shorter. And datasets are stored for three years, so examples you copy from production traces into a dataset outlast the traces.
To keep the traces themselves longer, Datadog sells a retention add-on for 30, 60 or 90 days. The add-ons are listed at $6.50, $8 and $9 per 10,000 LLM spans a month as of October 2026, and they also extend experiment retention to 6, 9 and 12 months. No trace retention longer than 90 days is listed. They are not available on the free tier, and they are arranged through your account team rather than turned on in the Datadog UI.
The pricing page does not say whether the add-on rate replaces the span rate or is added to it, so ask your account team for the total at your volume.
Decide on retention before you need it. An add-on applies to every span that has not already expired, and spans that expired under the shorter period cannot be recovered.
Following a request past the model call takes Datadog APM
To follow the request into your services, such as the database query behind a slow tool call, you open the linked span in Datadog APM. Agent Observability on its own shows the agent's steps. Agent Observability is a standalone product that you can buy without any other Datadog subscription. Datadog describes the link to services, infrastructure and user sessions as extra value for teams that also use Datadog for APM, infrastructure monitoring or Real User Monitoring.
The two products are linked by span ID. Datadog says teams that run both see agent behavior next to their services within the same platform and trace ID, without any extra configuration. If you use the Python SDK together with APM's dd-tracer, you move between an agent span and its APM span with no extra setup. If you send spans through the API instead, you include the captured span IDs in each request yourself.
So if APM already traces the services your agents call, the link needs no new product. If it does not, the trace ends at the agent until you add APM.
Who Datadog Agent Observability fits
It fits a team that already runs Datadog APM, wants agent traces next to its services, and debugs most failures within days. It fits agents that work mostly through tools especially well, because Datadog bills only the calls to the model.
Look harder before you commit if one of these describes you.
- Failures reach you more than 15 days after they happen, or you must keep agent traces for longer than 90 days.
- You need to run the tool on your own infrastructure. Datadog runs as a hosted service.
- You want the request, the agent's steps and the database behind them in one trace, and you do not run Datadog APM.
Before you sign, count the model calls in one real request, and ask your account team a few things. Ask for the total per 10,000 LLM spans with the retention period you need. Ask which commitment your rate assumes, since the list price per 10,000 runs from $3.50 to $5. And ask whether your volume qualifies for a volume or multi-year discount.
How Oodle keeps agent traces with the rest of the request
Oodle keeps agent traces on the same platform as your logs, metrics and application traces. When your services pass trace context to each other, one trace runs from the API request through the agent and its tools to the database, and you read all of it in one place. On Datadog, the agent's model calls are metered on one product, and the request around them is traced on another.
Traces go to object storage, and each query runs on serverless compute that stops when the query is done. Oodle keeps every span of every session for your retention period (30 days on Pro, longer for an added fee), on the same bill as the rest of the telemetry.
Oodle bills by the gigabyte ingested, and every span counts, tool calls included. Oodle has simple, ingest-based pricing, starting at $1 per GB, and is cost efficient.
Datadog can cost less for a tool-heavy agent. It bills only model calls, while Oodle bills the bytes of every span. On an annual commitment, an extra model call costs $0.00035 on Datadog ($3.50 ÷ 10,000), however many bytes it carries. So an agent that traces a lot of data around each model call can cost less on Datadog. One example is an agent whose tools return whole web pages or files.
Oodle's issue detection works in two passes, and the first covers every session. Every session is analyzed at scale using statistics, ML classifiers and a small model for sentiment. Oodle's agent then checks each issue it finds against the evidence and removes the noise.




