Skip to content
Datadog Bits Agent Builder

An agent for your runbook,
that can only do what the runbook says.

Datadog Bits Agent Builder takes a runbook and a scope as its input: the instructions you give it, the Datadog data it may read, and the actions from the Action Catalog it may take. It produces a custom agent that investigates, decides within those limits, and acts, or asks. We write the agents from runbooks that already exist, draw the scope tightly, and under Critical Support we are the human it asks. Agents own the analysis. Humans own the outcome.

Input
A runbook, and a scope
Output
An agent that acts, or asks
Decision
A named approver, per action
Monthly
Every agent action reviewed

Quick facts

CoversCustom agents built from instructions and the Action Catalog; Datadog and third-party data sources; connections and their credentials; triggers from Work Management automation rules and manual assignment; approvals; agents chained together; the Skills Library
Start withDatadog HealthScan, read-only and fully automated, which reports the agents that exist, what each can reach, and what they have consumed
Runs onManaged Observability for the scoping and the monthly review, with Critical Support as the approver for any agent action in the runtime we operate
AccessAdmin on Datadog for agents, connections and automation rules. The connections an agent uses are scoped with you, on your accounts.
Best whenThe same triage is done by hand for every work item of one type, or a runbook has a step that an engineer follows at 3am that a well-bounded agent could do at 3am instead

Related

01
What Bits Agent Builder gives you

The runbook that reasons, within the lines you drew

A work item arrives: a customer reports slow exports. The triage is always the same. Check the export queue, check the last deploy to the export service, check whether the customer's tenant is on the big shard, and either fix the known thing or escalate with those three facts. That is a runbook with a judgement in it. A workflow cannot make the judgement. An agent can, and it can be forbidden from doing anything else.

Input: instructions, data and a scope. You tell the agent what it is for, which Datadog and third-party data it may read, and which actions from the Action Catalog it may take. The scope is the agent's whole world; it cannot reach past it.

Output: an action taken, or a question asked. The agent investigates, decides within its instructions, and either takes a permitted action, such as updating the work item or opening a ticket, or stops and asks a person. Which actions need the question is your decision, not the agent's.

Where the human sits: at the trigger and the approval. An agent assigned to a work item runs with the permissions of the person who assigned it. Any action beyond the safe set waits for a named approver. Under Critical Support that approver is ours.

Agents that call other agents. A triage agent can hand a confirmed code cause to Bits Code, or a confirmed infrastructure cause to Bits Remediation behind its guardrail. The chain is explicit, and every step of it is on the work item's timeline.

02
Where it goes wrong

An agent built from an admin's permissions, with instructions that say "fix it", and nobody reading what it did

How it bills. Agents built with Bits Agent Builder draw on AI Credits, the meter shared across the Bits AI family, sold on demand or in monthly bundles that reset on the first of each calendar month and do not roll over. Each agent run, manual or automatic, consumes credits, and administrators can cap credit usage for the organisation and per user. Datadog announced Bits Agent Builder as generally available at DASH 2026, and its documentation lists the Work Management integration with custom agents as in Preview. We publish no rates. The lever is how often an agent is triggered and how much it is allowed to do, which is the same lever as safety.

The configuration traps. The agent is built by an administrator and run under their permissions, so an agent designed to update work items can also delete monitors. The instructions say "resolve the issue" rather than naming the four checks and the two permitted fixes, and the agent, being helpful, finds a fifth thing to try. The connection it uses is the one from the first workflow, with the broadest role in the account. The trigger is an automation rule on every work item in the project rather than one type. The agent's actions are on the timeline, and the timeline is read by nobody. Each of these is a scope that was left open because closing it took an afternoon.

Field noteThe most common gap we see is the agent whose scope is a person. It runs as whoever assigned it, and whoever assigned it is an admin, so the only limit on what it can do is what it decides to do. The instructions are then the entire safety model.

Field noteThe pattern we keep finding is instructions written as goals rather than steps. "Triage the signal and resolve it" produces an agent that does something different each time. "Check these three things, take one of these two actions, otherwise ask" produces one that is boring, which is the point.

Field noteThe agent is triggered on every work item in the project because the automation rule offered that. It triages the ones it was designed for well, and spends the month's credits producing confident nonsense about the rest.

Field noteThe agents that earn their place replace a runbook step a person was already following at 3am. The ones that get switched off were built to do something nobody had a runbook for, and nobody could tell whether the agent was doing it right.

03
How we implement it

Start from a runbook that exists. Give the agent a service account, not a person. Name the approver before the first trigger.

We start with a Datadog HealthScan, read-only and fully automated, which reports the agents that exist, the connections and permissions each runs under, the automation rules that trigger them and the credits consumed. The build then runs within Managed Observability onboarding, one agent at a time, and the approvals are staffed by Critical Support.

  1. Pick a runbook with a judgement in it. Not one that is a fixed sequence, which is a workflow, and not one that nobody has written down, which is a research project. A triage that an engineer does by hand, the same way, with one decision in the middle.
  2. Write the instructions as steps and limits. What to check, in what order, which two actions are permitted, and the exact condition for stopping and asking. The instructions are reviewed like code, because they are the agent's behaviour.
  3. Scope the data and the actions. Only the data sources the runbook reads. Only the Action Catalog actions the runbook takes, through connections with the narrowest role that works. Nothing inherited from the builder.
  4. Run it under a scoped identity. An automation rule assigns the agent from a service identity whose permissions match its scope, not from whoever set up the rule.
  5. Put an approver on every action beyond the safe set. Updating a work item or posting context runs unasked. Anything that changes the runtime, a ticket in another system, or customer-facing output waits for a named person. Under Critical Support that person is ours.
  6. Trial it against the last month of work items. The agent is run on the items it would have triaged, its actions compared with what the engineer did, and the difference written up. Then it is triggered for real, with a credit budget and an owner.

Access is admin on the Datadog organisation for agents, connections and automation rules. The connections an agent uses are created on your accounts, by you, with us specifying the role; no credential of yours is held by us.

04
Getting the most out of it

An agent's instructions were right for the runbook as it was in March

The runbook changes after an incident. A new action appears in the catalogue. The team that owned the approval is reorganised. Managed Observability reviews every agent every month against what it did, and Critical Support is the approver for anything it proposes in the runtime we operate.

Every month, the timeline is read. Every action each agent took, every question it asked, every approval and every rejection. An agent that asks constantly has instructions that are too narrow. One that is often overruled has instructions that are wrong.

Instructions follow the runbook. When a runbook changes after a postmortem, the agent built from it changes in the same week. The two are versioned together, so the agent never follows a procedure the team has abandoned.

Scope is kept narrow. Quarterly, each agent's connections, data sources and permitted actions are checked against its instructions. Anything the instructions do not use is removed, including capabilities Datadog added since.

The approval is ours when the runtime is. Under Critical Support our on-call engineer answers the agent's question at 3am for anything in the runtime we operate, approves or declines with a reason, and the reason goes into the next month's review.

05
Why with Critical Cloud

We operate the stack. You own the product.

We build agents from our own runbooks and run them inside our own operations, under the same rule: the agent follows the steps, decides within the limits, and asks a person for everything else. An implementation partner builds the agent and leaves. A managed partner is the person it asks, and reads what it did every month. We are the second kind. The agents, their instructions and their timelines stay in your Datadog, and you can take them in-house whenever you choose.

Datadog is our proof, not our headline. Datadog certified one managed provider globally. We are it. The Powered by Datadog accreditation means Datadog's own engineers reviewed how we instrument, alert, respond and report. We are also a Datadog Advanced Partner, ISO 27001 certified and Cyber Essentials Plus certified, with offices in Cardiff, London and Dublin.

Powered by Datadog accredited Datadog Advanced Partner ISO 27001 Cyber Essentials Plus 10+ years on Datadog
06
Questions we get asked

Datadog Bits Agent Builder, answered plainly

What is the difference between a custom agent and a workflow?

A Workflow Automation workflow is a fixed sequence of actions from a trigger: the same steps, in the same order, every run. A custom agent built with Bits Agent Builder is given instructions, data sources and a set of permitted actions, and it reasons about which to use. If the runbook has no judgement in it, build a workflow; it is cheaper and more predictable. If the runbook has a decision an engineer currently makes by hand, an agent can make that decision within the limits you set, and should be forbidden from everything else.

How is Datadog Bits Agent Builder billed?

Through AI Credits, the meter shared across the Bits AI agents. Datadog sells credits on demand or in monthly bundles that reset on the first of each calendar month and do not roll over, and each agent run, manual or automatic, consumes credits. We do not publish prices. We set a credit budget per agent with a named owner and trigger agents only on the work item types they were built for.

What permissions does a custom agent run with?

When an agent is assigned to a work item, it runs with the permissions of the person who assigned it. That is the reason we never let an agent inherit an administrator. Each agent is assigned from a scoped identity whose permissions match its instructions, and its connections to other systems use the narrowest role that works. The instructions limit what the agent tries. The identity limits what it can do if the instructions are wrong.

Can an agent act without asking anyone?

Within the safe set you define, yes: updating a work item, adding the context it gathered, posting to a channel. Anything that changes the runtime, opens a ticket in another system or reaches a customer waits for a named approver, and the agent stops until the answer arrives. Datadog lists the Work Management integration with custom agents as in Preview, so we treat the approval step as mandatory for anything beyond the safe set. Under Critical Support the approver for the operated runtime is our on-call engineer.

What does Critical Cloud do with Bits Agent Builder every month?

Under Managed Observability we read every agent's timeline: the actions taken, the questions asked, the approvals and the rejections. Agents that are often overruled get their instructions corrected. Agents whose runbooks changed after a postmortem are updated in the same week. Each agent's connections, data sources and permitted actions are checked against what its instructions actually use. Under Critical Support our engineer answers the agent's questions, 24x7, for anything in the runtime we operate. Agents own the analysis. Humans own the outcome.

Read next

An agent that follows the runbook and asks about everything else.

Tell us which triage your engineers repeat by hand. We will show you what it looks like as an agent, what it must be forbidden from, and who it should ask at 3am.