NewAgent Observability is live.
Back to directory
Datadog logo

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.

Connector
Official hosted MCP
Coverage
4 of the 5 stages in this guide; no code review
Tools
265 documented, 23 on by default
Biggest risk for an agent
Incomplete results look complete

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 workWhat Datadog has hereCan an agent reach it
Code, tests & reviewNone. Test results sit in CI Visibility, covered by the next stageNo code-review feature for an agent to query
CI & releaseCI Visibility, deploy events, Watchdog (Datadog's anomaly detection)Partial. Opt-in (software-delivery), 14 tools
Production observabilityLogs, traces, spans, metrics, infrastructureYes. In the default toolset. Database monitoring, RUM and the wider apm toolset are opt-in
Agent observability & evalsLLM ObservabilityPartial. Opt-in (llmobs), documented separately
AI cost managementCloud Cost Management, LLM cost surfacesPartial. 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?

TaskToolsWorksWatch out for
Investigate a production incidentsearch_datadog_logs analyze_datadog_logs search_datadog_monitors search_datadog_events search_datadog_hostsYesDefault storage tier, result caps
Correlate an error spike with a deploysearch_datadog_events search_datadog_spans get_datadog_metricYesRollup averaging on windows of a day or more
Explain a latency regressionget_datadog_trace get_datadog_metric_context search_datadog_service_dependenciesYesTrace sampling and the 15-minute live window. Profiling adds the profiling toolset
Find recurring CI failuresEnable software-delivery get_datadog_flaky_tests search_datadog_ci_pipeline_events search_datadog_test_eventsYesToolset of 14 tools, not in the default 23. Enable it by name
Diagnose an LLM or agent sessionEnable llmobs (no tool names published)PartialDatadog'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 regressionEnable cost cost_recommendationsPartialOne tool in the toolset, and it returns recommendations rather than a cost breakdown. Attribution granularity is not published
Create dashboards and notebooksupsert_datadog_dashboard create_datadog_notebook edit_datadog_notebookYesOn 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 setToolsTokens (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 default23748 to 955759 to 9661,851 to 2,1550.4% to 1.1%
Every toolset enabled26411,829 to 14,21511,790 to 14,17620,021 to 27,4635.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.

SignalCoveredNotes
Tool-call trackingYesSeven span kinds, including dedicated tool, agent and workflow spans
Token usage per spanYesRecorded on LLM spans
Eval scores on tracesYesManaged 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 groupingYesEvaluations run at trace and session level
Agent frameworks instrumentedYesOpenAI Agents SDK, LangGraph and CrewAI via the Python SDK
Eval score by prompt versionPartialNo prompt-version correlation documented as of 13 August 2026
Goal driftNoNot documented as a signal in LLM Observability as of 13 August 2026
Loop detectionNoNot documented as a signal as of 13 August 2026
Cache hit rateNoNot 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 tracePartialSeparate 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. 1

    Start read-only

    The default toolset includes three write tools: upsert_datadog_dashboard, create_datadog_notebook and edit_datadog_notebook. The Standard Role carries mcp_write, so they work out of the box. Connect with a role that has mcp_read only until there is a reason not to.

  2. 2

    Pick toolsets by task

    The default is core, 23 tools. Add what the job needs by name: ?toolsets=core,apm,software-delivery. Avoid all as a habit; it enables every generally available toolset and spends the agent's context on definitions.

  3. 3

    Subtract what should never be called

    Use omit_tools, in the same query-string style: ?toolsets=core&omit_tools=upsert_datadog_dashboard.

  4. 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.

Terminal
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 siteMCP endpoint
US1mcp.datadoghq.com
US3mcp.us3.datadoghq.com
US5mcp.us5.datadoghq.com
EUmcp.datadoghq.eu
AP1mcp.ap1.datadoghq.com
AP2mcp.ap2.datadoghq.com
UK1mcp.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.

Terminal
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.

Terminal
{"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.

Terminal
[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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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.

Terminal
{"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_read and without mcp_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 core only, 23 tools. Add toolsets by name in the URL. Preview toolsets (apm, cases, code-exec, remote-actions) are excluded from all and must be requested explicitly.
The agent returns empty results for data you know exists
The cause is the storage tier. Queries search indexes by default, so Flex and archived logs are invisible unless storage_tier is 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

ItemValue
StatusGenerally available since 9 March 2026. In preview from June 2025
Tools documented265 entries across 29 documentation sections (the toolsets, plus subgroups). llmobs is documented separately
Toolsets23 toolsets generally available, plus 4 in preview. core, the one a connection gets by default, holds 23 tools
DistributionHosted only, closed source. The public GitHub repo (datadog-labs/mcp-server) contains examples, no server code
Fair use50 requests / 10 seconds · 50,000 tool calls / month · scope (org, user or key) not stated
Result caps1,000 on logs, spans, RUM and audit search · aggregate paging 1,000 · group-by 10,000 buckets · histogram 100 buckets
Metrics1,500 points per series · rollup 5m/day, 1h/week, 4h/month
Retention defaultsIndexed spans 15 or 30 days by retention-filter setting · APM errors 15 days · RUM sessions 30 days · audit 90 days
Unlisted toolsetsexperiments (14), forms (8) and session-replay (2) are in the tools reference but on neither the generally available nor the preview list
Clients14 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.”

dgellow, Hacker News, 4 May 2026 · on the connector, used for production debugging

“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.”

hrimfaxi, Hacker News, 9 April 2026 · on the connector, on context handling

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 observability

Frequently 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.

Changelog

  • August 2026. 265 tools documented, counted from the tools-reference entries. Datadog publishes no total.
  • May 2026. Datadog removed the daily tool-call rate limit. Recorded at the time. Neither the current documentation nor the public changelog mentions it now.
  • March 2026. General availability.
  • June 2025. Preview launch. Datadog's current documentation does not state how many tools it carried then.

Sources

Every number on this page traces to one of these

  1. Datadog MCP server documentation: setup, toolsets and the tools reference. The 265 figure comes from counting documented tool entries, because Datadog publishes no official total
  2. Result caps from Datadog's published OpenAPI v2 specification
  3. Retention, rollup, storage-tier and trace-sampling behavior from Datadog's own docs, quoted where load-bearing
  4. Client output limits from Anthropic's Claude Code documentation
  5. Community counts from Hacker News and Reddit searches, retrieved 13 August 2026

Datadog’s own MCP documentation

Also production observability:

Agent observability, where Datadog also competes: