Datadog MCP server: tools, limits and read-only setup
Datadog reaches CI, production telemetry, LLM traces and cost through one hosted connection, and almost none of its limits announce themselves in the response.
Last verified 1 September 2026 · from Datadog's documentation, OpenAPI specification and pricing page
This page is one of 90 in a directory of monitoring and developer tools. Each page checks what an AI coding agent can get out of the tool through its MCP server, the connector that lets the agent query the tool directly.
Summary
Datadog's MCP server lets an agent query CI, production telemetry, LLM traces and cost, through one hosted connection. That is four of the five stages this guide tracks, from a single endpoint.
The problem is not access but completeness: result caps, storage tiers, trace sampling and metric rollups all trim what comes back, and almost none of them announce themselves in the response.
Connect it, but first paste the instructions below into your agent, so it says what it could have missed before you trust its conclusions.
What is the Datadog MCP server?
Datadog's hosted MCP endpoint spans CI, telemetry, LLM traces and cost. MCP is an open protocol that lets an AI coding agent call a tool's functions, such as running a log search, without anyone writing code against the tool's API.
You point the agent at the endpoint, and it gains a set of tools: run this log search, fetch that trace, list the monitors. The tools are grouped into toolsets you switch on by name, and the agent picks tools on its own based on what you ask in English. For metrics the order matters. The agent finds the metric with search_datadog_metrics, reads its context with get_datadog_metric_context, then queries it with get_datadog_metric.
Datadog reaches four of the five stages. Only a handful of the vendors here do: Braintrust, Keywords AI and Harness also reach four. The exception is code review: Datadog has no code-review feature, and the test results in CI Visibility belong to the release stage below.
| Part of the work | What Datadog has here | Can an agent reach it |
|---|---|---|
| Code, tests & review | None. Test results sit in CI Visibility, covered by the next stage | No code-review feature for an agent to query |
| CI & release | CI Visibility, deploy events, Watchdog (Datadog's anomaly detection) | Partial. Opt-in (software-delivery), 14 tools |
| Production observability | Logs, traces, spans, metrics, infrastructure | Yes. In the default toolset. Database monitoring, RUM and the wider apm toolset are opt-in |
| Agent observability & evals | LLM Observability | Partial. Opt-in (llmobs), documented separately |
| AI cost management | Cloud Cost Management, LLM cost surfaces | Partial. Opt-in (cost) |
One connection can follow a regression from the deploy that shipped it, to the traces it slowed, to the cost it added. Only production telemetry is on by default. The other three stages stay off until you enable their toolset by name. An agent asked about CI or cost on a default connection reports nothing, and does not explain why.
What can an AI agent do with Datadog?
| Task | Tools | Works | Watch out for |
|---|---|---|---|
| Investigate a production incident | search_datadog_logs analyze_datadog_logs search_datadog_monitors search_datadog_events search_datadog_hosts | Yes | Default storage tier, result caps |
| Correlate an error spike with a deploy | search_datadog_events search_datadog_spans get_datadog_metric | Yes | Rollup averaging on windows of a day or more |
| Explain a latency regression | get_datadog_trace get_datadog_metric_context search_datadog_service_dependencies | Yes | Trace sampling and the 15-minute live window. Profiling adds the profiling toolset |
| Find recurring CI failures | Enable software-delivery get_datadog_flaky_tests search_datadog_ci_pipeline_events search_datadog_test_events | Yes | Toolset of 14 tools, not in the default 23. Enable it by name |
| Diagnose an LLM or agent session | Enable llmobs (no tool names published) | Partial | Datadog's tools reference documents no tool under this toolset, so the tool names cannot be verified here. Check that the LLM trace shares a trace ID with the infrastructure trace |
| Explain an AI cost regression | Enable cost cost_recommendations | Partial | One tool in the toolset, and it returns recommendations rather than a cost breakdown. Attribution granularity is not published |
| Create dashboards and notebooks | upsert_datadog_dashboard create_datadog_notebook edit_datadog_notebook | Yes | On by default, and these are writes. See the read-only setup below |
265 documented, 23 on by default
- Search and read20
search_datadog_logsanalyze_datadog_logssearch_datadog_spansget_datadog_tracesearch_datadog_metricsget_datadog_metricget_datadog_metric_contextsearch_datadog_eventssearch_datadog_monitorssearch_datadog_hostssearch_datadog_servicessearch_datadog_service_dependenciessearch_datadog_incidentsget_datadog_incidentsearch_datadog_rum_eventsaggregate_rum_eventssearch_datadog_dashboardsget_datadog_dashboardsearch_datadog_notebooksget_datadog_notebook- Write3
upsert_datadog_dashboardcreate_datadog_notebookedit_datadog_notebook
Recounted from Datadog's tools reference on 1 September 2026, heading by heading. The other 242 sit in opt-in toolsets: security (42 tools), software delivery (14), experiments (14), RUM (11), profiling (12), APM (11), database monitoring (11) and more. One naming trap: trace fetch and span search are already core tools, so the toolset named apm adds 11 more on top of them. APM being opt-in does not mean traces are.
What connecting costs before the first question
A context window is the amount of text a model can hold at once, and connecting uses some of it before the agent asks anything. Every tool the server registers sends its name, description and input schema to the model when the session starts, and the list is charged whether or not a single tool is called.
Datadog's server is hosted and closed source, and a tools/list response needs a real API key and application key, so no input schemas are public. The counts below cover each tool's name and description only. They are a floor, not the final figure. On Grafana, where the schemas could be captured, the full definitions came to 2.9 times the names and descriptions alone.
| Tool set | Tools | Tokens (GPT-5.6, GPT-5.5) | Tokens (GPT-4, GPT-3.5) | Tokens (Claude Haiku 4.5 to Opus 5) | Share of a 200,000-token window |
|---|---|---|---|---|---|
| Core toolset, the default | 23 | 748 to 955 | 759 to 966 | 1,851 to 2,155 | 0.4% to 1.1% |
| Every toolset enabled | 264 | 11,829 to 14,215 | 11,790 to 14,176 | 20,021 to 27,463 | 5.9% to 13.7% |
Encodings: GPT-5.6, GPT-5.5 o200k_base; GPT-4, GPT-3.5 cl100k_base; Claude Haiku 4.5 to Opus 5 count_tokens. Counted from Datadog's tools reference as retrieved on 1 September 2026, which documented 265 entries. 264 are measured: link_jira_issue_to_datadog_case carries no description in the reference, so there is nothing to count for it beyond its name.
The figures cover names and descriptions only, because Datadog publishes no input schemas. The real cost is higher by the size of those schemas. The spread within each column is formatting. Compact serialization sits at the low end, indented at the high end.
The Claude figures are measured through the API's count_tokens endpoint with an empty schema for each tool. They cover the same names and descriptions as the other columns, and carry the same caveat. The range is two tokenizer generations: Haiku 4.5 and Opus 4.6 at the low end, Opus 5 and Sonnet 5 at the high end. The gap between them runs from 16% to 37% depending on the tool set.
Can Datadog watch your own AI agents?
The signals below are the ones that matter when watching your own AI agents rather than your infrastructure. Checked against Datadog's Agent Observability documentation, retrieved 13 August 2026.
Agent access to all of them runs through the llmobs toolset, which is off by default. GovCloud accounts cannot use it, though that is no extra loss: the MCP server as a whole is unavailable on GovCloud.
| Signal | Covered | Notes |
|---|---|---|
| Tool-call tracking | Yes | Seven span kinds, including dedicated tool, agent and workflow spans |
| Token usage per span | Yes | Recorded on LLM spans |
| Eval scores on traces | Yes | Managed evaluations, custom LLM-as-a-judge checks where one model scores another's output, custom submission and a NeMo integration. Named checks include failure-to-answer and topic relevancy |
| Session-level grouping | Yes | Evaluations run at trace and session level |
| Agent frameworks instrumented | Yes | OpenAI Agents SDK, LangGraph and CrewAI via the Python SDK |
| Eval score by prompt version | Partial | No prompt-version correlation documented as of 13 August 2026 |
| Goal drift | No | Not documented as a signal in LLM Observability as of 13 August 2026 |
| Loop detection | No | Not documented as a signal as of 13 August 2026 |
| Cache hit rate | No | Not documented as a named signal as of 13 August 2026. Token counts are tracked on LLM spans, and cache behavior is not reported separately from them |
| Agent trace joins the infrastructure trace | Partial | Separate surfaces with shared trace-ID correlation. Whether they join well enough for one investigation is not settled by the docs |
Datadog MCP server limits: where answers come back incomplete
Datadog documents each boundary below, but only trace truncation announces itself in the response. The others arrive silently, leaving an agent able to answer confidently from incomplete data.
The agent says: “There are no matching logs.” The logs exist.
Queries default to the indexes storage tier. Anything in Flex or Online Archives is not searched unless the agent sets storage_tier explicitly, and the response does not say that data was excluded.
Excluded logs also still flow to archives under Datadog's exclusion filters, so where an archive is configured, not indexed does not have to mean not collected.
Guard: Instruct the agent to name the storage tier it queried, and to treat no data returned and no data exists as different statements.
The agent says: “These are all the errors from last night.” It got the first 1,000.
Span aggregates carry no pagination object at all, so there is no documented way to page past the first set. Logs search, spans search, RUM and audit queries cap page[limit] at 1,000, and log aggregate pagination stops at 1,000 results.
Guard: Treat a result count of exactly 1,000 as a probable cap hit, not as the total. The agent should say so, then narrow the query. It can page onward where pagination exists. Span aggregates have none.
The agent says: “The trace for that incident doesn't exist.” It was sampled out or aged out.
Un-indexed spans are searchable for 15 minutes. After that, only what a retention filter kept is visible, and Intelligent Retention keeps a representative sample of distinct behaviors plus a flat 1% of all traffic.
An agent investigating an hour-old incident is looking at the filtered subset, not the full traffic.
Guard: For anything older than 15 minutes, the agent reports that results reflect retention filters, not full traffic.
The agent says: “No latency spike occurred that week.” The spike was averaged away.
A metrics series returns at most 1,500 points, rolled up automatically: 5-minute averages over a day, one-hour averages over a week, four-hour over a month. A 90-second spike inside a one-hour average disappears into the average, and nothing visible remains.
Guard: The agent states the rollup interval for any window past a few hours, and re-queries a narrow window around anything it needs to see at full resolution.
The agent's answer just stops. Usually the client cut it off; sometimes Datadog did.
Claude Code hard-limits MCP tool output at 25,000 tokens by default, and every enabled tool definition consumes context before any data arrives. With 265 tools available, enabling too many crowds out the answer itself. Datadog's own docs warn that enabling all toolsets "consumes context window space".
Datadog-side truncation exists too: get_datadog_trace documents that large traces "may be truncated (and indicated as such) without a way to retrieve all spans". The response carries the truncation flag, but the missing spans are still gone, so the agent has to notice the flag and say so.
Guard: Enable only the toolsets the task needs, and, in Claude Code, raise MAX_MCP_OUTPUT_TOKENS before concluding the backend returned a partial trace.
How to configure Datadog MCP for agents
- 1
Start read-only
The default toolset includes three write tools:
upsert_datadog_dashboard,create_datadog_notebookandedit_datadog_notebook. The Standard Role carriesmcp_write, so they work out of the box. Connect with a role that hasmcp_readonly until there is a reason not to. - 2
Pick toolsets by task
The default is
core, 23 tools. Add what the job needs by name:?toolsets=core,apm,software-delivery. Avoidallas a habit; it enables every generally available toolset and spends the agent's context on definitions. - 3
Subtract what should never be called
Use
omit_tools, in the same query-string style:?toolsets=core&omit_tools=upsert_datadog_dashboard. - 4
Know the ceiling
Fair use is 50 requests per 10 seconds and 50,000 tool calls a month, both described as adjustable.
Paste this into your agent’s instructions
This block makes the agent report its time range, its row count against the cap, and which storage tier it searched.
When you query Datadog, always report alongside your answer: - The time range you queried. - Rows returned. If exactly 1,000, state that the result cap was likely hit, then paginate where supported or narrow the query. - The storage tier searched. The default is indexes only; Flex and Online Archives are not included unless requested. - For metrics over windows longer than a few hours, the rollup interval applied to the data you saw. - For traces older than 15 minutes, that results are limited to retention-filtered spans, not full traffic. Never state that data does not exist. State that no data was returned under the constraints above. Write your answer in ASD-STE100 Simplified Technical English. Use short sentences with one idea in each.
Do you need the MCP server at all?
Not for everything. A coding agent can call Datadog's REST API directly, with the same API and application keys. The full API surface is available, rather than a curated toolset. Rate limits are documented for each endpoint and returned in X-RateLimit headers. Agents write code, so calling the REST API with curl and the API reference has been an option all along.
What MCP adds is packaging: tools the agent can discover on its own, the mcp_read and mcp_write permission gate, no glue code, and Datadog's own descriptions telling the agent what each tool is for. The raw API gives two things instead: endpoints the toolsets do not expose, and full control of pagination. The cost is that the agent hand-rolls every request and you build the guardrails yourself.
Use MCP for investigation work, and the API for anything the toolsets do not cover.
Datadog MCP server setup
There is no binary to run. You need an API key and an application key, or the OAuth flow, plus your region's endpoint.
The examples below use the US1 endpoint (mcp.datadoghq.com). If your account lives on another site, swap in your region from the table, or the connection fails with a 401 or 403.
| Datadog site | MCP endpoint |
|---|---|
| US1 | mcp.datadoghq.com |
| US3 | mcp.us3.datadoghq.com |
| US5 | mcp.us5.datadoghq.com |
| EU | mcp.datadoghq.eu |
| AP1 | mcp.ap1.datadoghq.com |
| AP2 | mcp.ap2.datadoghq.com |
| UK1 | mcp.uk1.datadoghq.com |
All seven sit at /v1/mcp. Not available on GovCloud. Keys from one site used against another site's endpoint fail with a 401 or 403 rather than a message naming the mismatch, which is why the site is worth checking first.
Claude Code
The bare command carries no keys because the hosted server authenticates over OAuth: on first connect, Claude Code opens a browser window to authorize against your Datadog org.
Clients that skip the OAuth flow send the API and application keys as headers instead, as the Cursor example below shows. Datadog's Claude Code plugin (in preview, version 0.7.14) wires the endpoint, keys and toolset selection through environment variables.
claude mcp add --transport http datadog https://mcp.datadoghq.com/v1/mcp
Cursor
In ~/.cursor/mcp.json for all projects, or .cursor/mcp.json in one.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp?toolsets=core",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Codex CLI
Codex reads TOML, so the JSON blocks above will not transfer.
[mcp_servers.datadog]
url = "https://mcp.datadoghq.com/v1/mcp"
http_headers = { DD_API_KEY = "...", DD_APPLICATION_KEY = "..." }The key is `mcp_servers`, with an underscore. The http_headers line carries the same keys the Cursor example uses; without it, the connection needs the OAuth flow, which not every Codex setup completes.
Every other client
Each block below is the configuration for one client, with the file path and the key that client expects.
Claude Desktop
macOS ~/Library/Application Support/Claude/claude_desktop_config.json. Windows %APPDATA%\Claude\claude_desktop_config.json. There is no CLI. Edit through Settings, Developer, Edit Config, then quit and restart fully for changes to load.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Gemini CLI
~/.gemini/settings.json globally, or .gemini/settings.json per project. CLI: gemini mcp add.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}VS Code Copilot
.vscode/mcp.json per workspace, or your user profile. CLI: code --add-mcp.
{"servers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}The key is `servers`, not `mcpServers`. VS Code is the only client that uses that name, and a config copied from another client fails silently.
Windsurf
~/.codeium/windsurf/mcp_config.json, which is the path Windsurf documents. Key mcpServers, the same shape as Cursor.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Zed
~/.config/zed/settings.json, with the same URL and the same API and application key headers as the blocks above.
The key is `context_servers`. Zed does not use MCP vocabulary in its config, so searching its settings for mcp finds nothing.
Google Antigravity
~/.gemini/config/mcp_config.json globally, or .agents/mcp_config.json per project. Key mcpServers. There is no CLI. Use the /mcp overlay. Supports stdio, streamable HTTP, SSE and websocket.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Amp (Sourcegraph)
~/.config/amp/settings.json or .amp/settings.json, carrying the same URL and key headers. The amp mcp CLI covers approve, doctor and oauth.
The key is namespaced: `amp.mcpServers`. A bare mcpServers block is ignored.
Cline
~/.cline/mcp.json per the docs. The source also reads ~/.cline/data/settings/cline_mcp_settings.json. Key mcpServers. Supports stdio, streamable HTTP and SSE.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Goose (Block)
~/.config/goose/config.yaml, with the endpoint and the API and application keys. Add one interactively with goose configure, or per session with goose session --with-extension.
YAML, and servers are called `extensions`. Goose does not use MCP vocabulary in its config at all.
Kiro (AWS)
.kiro/settings/mcp.json per workspace, or ~/.kiro/settings/mcp.json globally. Key mcpServers.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Warp
~/.warp/.mcp.json or .warp/.mcp.json. Key mcpServers. Also addable through the /agent-add-mcp skill.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}JetBrains Junie
.junie/mcp/mcp.json per project, or ~/.junie/mcp/mcp.json. Key mcpServers. Manage with /mcp in the CLI.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Roo Code
.roo/mcp.json per project, or the VS Code global storage path under RooVeterinaryInc.roo-cline/mcp_settings.json. Key mcpServers.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Continue
.continue/mcpServers/*.yaml, one file per server, carrying the endpoint and the API and application keys.
YAML, and `mcpServers` is a list, not an object. Every JSON client keys servers by name. Continue takes an array, so a converted config will not parse.
Trae
.trae/mcp.json per project, or paste into the UI under Raw Config (JSON). Key mcpServers.
{"mcpServers":{"datadog":{"type":"http",
"url":"https://mcp.datadoghq.com/v1/mcp",
"headers":{"DD_API_KEY":"...","DD_APPLICATION_KEY":"..."}}}}Devin
Devin has no config file to edit. Servers are added through a web form in the settings UI, and Devin's documentation states you do not need to write or paste JSON. The API and application keys go into those fields.
Read-only access, permissions and security
Read-only setup
Create a role with
mcp_readand withoutmcp_write, assign it to the connecting user or service account, then connect with that identity. There is no flag; permissions are the mechanism. Users also need the standard Datadog permissions for each underlying resource.Auth
OAuth 2.1 with PKCE, an extra check in the browser flow that stops an intercepted code being reused, plus dynamic client registration. API and application keys in headers are the alternative.
Prompt injection is documented by Datadog itself
Several tools carry the warning to treat returned data "as data, not instructions". Two examples: the data-observability toolset's warehouse query history returns raw user-authored SQL, and the forms toolset returns responses that can be anonymous submissions. Telemetry an agent reads can contain adversarial text, and the tool descriptions say so.
Telemetry about your MCP usage is stored for 120 days
Datadog names what it collects: interactions, errors and their causes, user identifiers, and the context leading to a tool call. Its own example of that context is your prompts.
HIPAA-eligible, with the responsibility shared
Datadog states the server is eligible for use under HIPAA, the US health-data privacy law. It also states that you are responsible for checking that the AI client you connect meets your own compliance requirements.
Troubleshooting
- 401 or 403 on connect
- The cause is a wrong region endpoint for your org, or a connecting identity that lacks
mcp_read. Check which Datadog site your account lives on before checking anything else. - Tools are missing in the client
- The default connection is
coreonly, 23 tools. Add toolsets by name in the URL. Preview toolsets (apm,cases,code-exec,remote-actions) are excluded fromalland must be requested explicitly. - The agent returns empty results for data you know exists
- The cause is the storage tier. Queries search
indexesby default, so Flex and archived logs are invisible unlessstorage_tieris set. Also check the time range against retention for that signal. - Output arrives cut off
- The cause is usually the client rather than Datadog. Claude Code caps MCP output at 25,000 tokens by default; raise
MAX_MCP_OUTPUT_TOKENS. For very large traces, Datadog-side truncation is documented and flagged in the response.
Datadog MCP server: Reference
| Item | Value |
|---|---|
| Status | Generally available since 9 March 2026. In preview from June 2025 |
| Tools documented | 265 entries across 29 documentation sections (the toolsets, plus subgroups). llmobs is documented separately |
| Toolsets | 23 toolsets generally available, plus 4 in preview. core, the one a connection gets by default, holds 23 tools |
| Distribution | Hosted only, closed source. The public GitHub repo (datadog-labs/mcp-server) contains examples, no server code |
| Fair use | 50 requests / 10 seconds · 50,000 tool calls / month · scope (org, user or key) not stated |
| Result caps | 1,000 on logs, spans, RUM and audit search · aggregate paging 1,000 · group-by 10,000 buckets · histogram 100 buckets |
| Metrics | 1,500 points per series · rollup 5m/day, 1h/week, 4h/month |
| Retention defaults | Indexed spans 15 or 30 days by retention-filter setting · APM errors 15 days · RUM sessions 30 days · audit 90 days |
| Unlisted toolsets | experiments (14), forms (8) and session-replay (2) are in the tools reference but on neither the generally available nor the preview list |
| Clients | 14 documented by Datadog, plus a generic option |
What engineers report
The Datadog MCP server has been generally available since 9 March 2026, runs on seven regional endpoints, and documents client configuration for 14 clients. Public discussion of it is thin all the same: six comment matches on Hacker News, and Reddit searches on 13 August 2026 found nothing substantive.
“Claude connected to a Postgres (readonly obviously) and Datadog MCP servers in addition to access to the codebase can debug prod issues so quickly. That's easily a 10x win compared to a senior engineer doing the exact same.”
“I have had incredible success debugging issues by just hooking up Datadog MCP and giving agents access to it. Claude/cursor don't seem to have any issues pulling in the raw data they need in amounts that don't overload their context.”
One scope note on both quotes: the raw data they need is bounded by the storage tier, caps and sampling described above, whether or not the user notices.
Should you connect an agent to Datadog?
Yes. Best for teams already standardized on Datadog that want an agent investigating telemetry, and are willing to configure the connection deliberately rather than accept the defaults.
- Strongest fit
- Cross-surface investigations that span production telemetry, deploys and CI in one conversation. Of the vendors in this guide, no other official connector spans that much from one connection.
- Main advantage
- Coverage of four of the five stages, with granular toolset control and mature auth.
- Main weakness
- Incomplete datasets look complete. Caps, tiers, sampling and rollups all trim results, mostly without notice, so the agent's answers are trustworthy only with the instructions above in place.
- Operational risk
- Three write tools ship in the default toolset, and the Standard Role can use them. Read-only requires deliberate role setup.
From Oodle
One platform for agent traces and infrastructure
Agent traces usually sit in a different product from the rest of your telemetry, so when a slow database makes an agent slow the symptom is in one tool and the cause is in another. Oodle keeps both in one query surface, from $10 per million spans.
See agent observabilityFrequently asked questions
Is the Datadog MCP server read-only by default?
No. Three write tools ship in the default toolset, and the Standard Role can use them. Read-only means connecting with a role that has mcp_read and not mcp_write; the steps are above.
Why does my agent say there are no matching logs when the logs exist?
Queries search the indexes storage tier by default. Logs in Flex or Online Archives are invisible unless the agent sets storage_tier, and the response does not say anything was excluded.
Can I self-host the Datadog MCP server?
No. It is hosted-only, and no server source is published.
Does connecting an agent cost extra?
No separate connector charge is published. Fair-use limits apply, and queries against billable surfaces follow your existing plan's metering.
Does the agent trace join the infrastructure trace?
LLM Observability spans and APM spans are separate surfaces with shared trace-ID correlation. Whether they join well enough for a single investigation is the key question to test in your own account; the docs do not settle it.
Is it available on GovCloud?
No.