AutoMerge is generally available

Last updated:

Set Guardrails

Control Agent0's behavior and ensure safe execution with guardrails configuration.

Set guardrails to control what Agent0 can do when your automation runs. Guardrails ensure automations are safe, predictable, and only perform the actions you intend.

Guardrails settings showing network access, tools, timeout, concurrency policy, max parallel runs, debounce, and credit budget options

Network Access

Controls whether Agent0 can make outbound network requests to external systems.

This policy also applies to the automation's setup script. A script that downloads dependencies needs access to those hosts. In deployments with sandbox profiles, Network access appears in Sandbox instead of Guardrails; see Environment and profile controls.

Options

  • No Network: Agent0 can query Dash0 data and use integration tools (Slack, Linear, GitHub API). The sandbox cannot make direct network requests (git/gh CLI operations, webhooks, curl).
  • Trusted hosts only: Everything Agent0 can do with No Network — query Dash0 data and use integration tools (Slack, Linear, GitHub API, and installed MCP servers) — and Agent0 can additionally reach a curated allowlist of pre-approved hosts to fetch dependencies, clone repositories, and pull container images: Dash0's own properties and the source-control, package-registry, container-registry, and cloud-provider hosts an agent typically needs to build and run code. Everything else is blocked. The list is global (the same for every organization) and maintained by Dash0; see the full trusted hosts list.
  • Full Network: Agent0 can make any outbound request, including sandbox-native operations like git/gh CLI and webhooks.
Tip

Start with No Network and enable broader network access only when needed. Integration tools can still perform external actions, so review Allowed Tools too.

Timeout

Maximum time Agent0 can run before the automation stops. Default is 10 minutes.

Set higher timeouts for automations that:

  • Query large time ranges
  • Analyze many services
  • Perform complex calculations

Set lower timeouts to catch runaway executions quickly during testing.

Examples:

  • Simple Slack response: 1-2 minutes
  • Daily health report: 5-10 minutes
  • Deep incident analysis: 15-20 minutes

Allowed Tools

Controls which Dash0 tools and integrations Agent0 can use. Tool access, required calls, and parameter overrides are configured together, outside the Guardrails section.

Configure tools

  1. Open Tools & Skills in the automation editor, or Tools if custom skill selection is not available.
  2. Click Configure tools to open Manage tools.
  3. Search for and select a tool. Turn Allowed on to permit it, or off to block it.
  4. If every run must call the tool, turn Required on. The tool must be allowed first. Turn Required off to make calls optional without blocking the tool.
  5. To pin inputs, fill in Parameter overrides in the same tool panel. Leave a field blank to let Agent0 choose its value.
  6. Close the dialog to apply the changes to the form, then save the automation.

Manage tools dialog with a selected tool's Allowed and Required switches and parameter overrides

Use the All, Allowed, Required, and Overridden filters to review the configuration. MCP tools support allow and deny only, not required calls or parameter overrides.

Leave tool settings unchanged to use the default policy:

  • Dash0 query tools are allowed by default for metrics, logs, traces, services, and checks
  • Read tools are allowed across namespaces
  • Write tools are allowed when their namespace matches the trigger source: Slack, GitHub, or Linear
  • Destructive tools require explicit opt-in

Required tools and non-destructive internal tools are also included. This policy filters tools, not sandbox commands. GitHub git/gh and GitLab git/glab access depend on network access and credentials, not on a matching trigger. GitLab operations run as the automation's creator.

When to Customize

Override allowed tools when you need:

Scheduled automations that post to Slack:

  • Select slackSendMessage in Configure tools and turn Allowed on
  • Agent0 can now post daily reports or scheduled alerts

Restricting tool namespaces:

  • Allow dash0:* to select Dash0 tools
  • This is not a read-only setting: the namespace includes write tools when available. Required tools and non-destructive internal tools remain available, including tools outside this namespace.

Specific tool restrictions:

  • Allow slack:slackSendMessage but not slack:slackAddReaction
  • Fine-tune which actions are permitted

Tool Namespaces

When configuring tool allowlists through the API, use namespaced names or patterns. In the editor, select the individual tools in Configure tools instead.

  • dash0:* — All available tools in the Dash0 namespace, including write tools
  • slack:* — All Slack actions (posting, updating, reading channels)
  • github:* — All GitHub actions (requires GitHub integration)
  • linear:* — All Linear actions (requires Linear integration)

Specific Tools

Common tools to allow individually:

  • slack:slackSendMessage — Post messages to Slack
  • slack:slackAddReaction — Add emoji reactions to messages
  • github:githubListRepos — List accessible GitHub repositories

Denying Specific Tools

To block a tool, use the same Manage tools dialog:

  1. Open Tools & Skills → Configure tools.
  2. Find and select the tool you want to block.
  3. Turn Allowed off, close the dialog, and save the automation.

For example, allow slackSendMessage but turn Allowed off for slackAddReaction to permit messages without reactions. To block a required tool, remove its required status too.

If configuring an automation through the API, namespace patterns such as slack:* can allow a namespace while exclusions block individual tools. The editor manages these choices through each tool's Allowed switch.

Allowed Skills

An automation can use only the custom skills on its allowed skills list. Choose them in the Skills field of the Tools & Skills section. A run cannot load a skill that is not on the list, even when the prompt names it. Built-in Dash0 skills are not affected.

An automation with no allowed skills uses no custom skills, and its Skills field reads No skills allowed. This includes automations created before the list existed, so add the skills they need.

A run gets a skill only when all of these are true:

  • The skill is on the automation's allowed skills list.
  • The automation's creator can see the skill.
  • The creator has turned the skill on with Enabled for you.

When the prompt names a custom skill with / that is not on the list, the form warns you. Select Add skill (or Add skills) to add it. The prompt editor also marks the skill: hover it and select Add to allowed skills.

A listed skill shows as Unavailable when it was deleted, or when it isn't shared with you or is off for you. Remove it only if it was deleted: the run uses the creator's access, not yours.

When Agent0 creates or edits an automation for you, it adds each skill the prompt references as /name to the list and keeps the skills already on it.

Required Tool Calls

Tools that Agent0 must call for the automation to succeed.

Set Required in Tools & Skills → Configure tools, not in a separate Guardrails field. Required tools are force-included even if an API-configured allowlist would otherwise exclude them. Requiring a tool does not grant integration access or guarantee that its call succeeds. To revoke access, remove the requirement as well as denying the tool.

Why Use This

Agent0 sometimes writes a summary and exits without taking action. For example:

  • Automation should post to Slack, but Agent0 only analyzes data
  • Automation should query metrics, but Agent0 responds from memory
  • Automation should post findings, but Agent0 just writes a report

Required tool calls ensure critical actions happen.

How It Works

If Agent0 finishes without calling a required tool:

  1. Agent0 gets one retry with an explicit reminder to call the missing tool
  2. If still missing, the run is marked as guardrail_failure
  3. You can see which tools were called in the run history

Example Use Cases

Slack alert automation:

  • Require slackSendMessage
  • Requires a call to the message tool. Review the tool result to confirm the post succeeded.

Metric analysis:

  • Require getMetricQuery
  • Ensures Agent0 queries fresh data instead of guessing

Data-driven investigations:

  • Require both getMetricQuery and getLogRecords
  • Ensures Agent0 checks multiple data sources, not just one
Note

In API definitions, requiredToolCalls uses bare tool names such as slackSendMessage, not namespaced names such as slack:slackSendMessage. In the editor, use the selected tool's Required switch.

Concurrency

Controls how many runs of this automation can be active at once and what happens to additional triggers. The limit applies across all triggers of the automation, even when they refer to different tickets, pull requests, or other entities.

Policies and Limits

PolicyActive runsWhen the limit is reached
Parallel (default)Up to Max parallel runs, defaulting to 50Additional triggers wait in a queue.
QueueOneAdditional triggers wait in a queue.
SkipUp to Max parallel runs, defaulting to 50Additional triggers are skipped without being queued.
SupersedeOneA new trigger cancels active runs and starts a new run.

The waiting queue holds up to 100 triggers for Parallel and Queue. Further triggers are dropped when the queue is full.

Max parallel runs is available for Parallel and Skip. The editor accepts values from 1 to 50. Queue and Supersede always allow one active run and ignore this setting.

The API also accepts guardrails.concurrency.maxParallel with either parallel or skip. The value 50 is the default, not an API-enforced maximum. Other organization-level dispatch limits still apply.

For example, choosing Skip with Max parallel runs set to 3 allows three active runs. Any trigger received while all three are active is skipped. Choosing Skip alone does not restrict the automation to one run: set the limit to 1 for that behavior.

When to Change

Most automations work fine with Parallel (the default). Consider changing if:

  • Automation posts sequential updates or updates a shared resource → Queue
  • Automation takes long and new data makes old runs obsolete → Supersede
  • Automation should skip new triggers while a run is active → Skip with Max parallel runs set to 1
  • Automation should process several events at once without building a backlog → Skip with the parallel limit you need

Debounce

Delays automation execution until events of the same trigger kind stop arriving.

How It Works

  • Leaving Debounce empty uses the default of 10 seconds.
  • Positive values below 10 seconds use a 10-second window.
  • Setting Debounce to 0 disables debouncing. Each trigger reaches the concurrency policy immediately.

With debouncing enabled, a matching event starts a timer. Another event of the same trigger kind replaces the pending event and resets the timer. When the timer expires, the automation processes the latest event. If a different trigger kind arrives, the pending event is processed immediately and the new event starts its own debounce window.

Example: Set to 10 seconds

  • Message arrives → timer starts
  • Another message arrives 5 seconds later → timer resets
  • No messages for 10 seconds → automation processes the latest message

When to Use

Useful when events arrive in bursts:

  • Multiple Slack messages about the same issue
  • Several commits pushed to a PR in quick succession
  • Rapid check failures during an incident

Debounce groups events by trigger kind, not by ticket, pull request, or other entity. Events for different entities can therefore replace each other when they share a trigger kind.

Pitfall

If events of the same trigger kind keep arriving more frequently than the debounce window, the timer keeps resetting and the pending event does not run.

Tip

To process every matching event, set Debounce to 0. Leaving it empty does not disable debouncing. Concurrency policies and organization-level dispatch limits still apply, so a trigger can still be queued, skipped, or rejected.

Credit Budget

Caps how many credits an automation can spend within a rolling time window.

Credit budget configuration showing budget amount, warning threshold, and notification channels

How It Works

  • Credit budget: The number of credits allowed per rolling window (for example, 250 per 1 week). Every new automation gets a default budget of 250 credits per week.
  • The budget is checked before each run starts, using recorded run costs. Once recorded spend within the rolling window reaches the budget, new runs are blocked.
  • Active runs are not canceled when the budget is hit. Concurrent runs can each pass the check before their costs are recorded, so overspend can include the costs of multiple in-flight runs.
  • Leave the field empty for no budget.

Warn At

Set a percentage threshold (default 75%) to receive a warning before the budget is fully consumed. Once rolling spend crosses this percentage, a budget warning notification fires. Leave empty to disable warnings.

Notify on Budget Warning

Select one or more notification channels to receive an alert when the rolling credit budget crosses its warning threshold. This uses the same notification channels configured in Settings → Notifications.

Slack message showing a credit budget warning at 75% of the budget used

When to Use

  • Prevent runaway costs: Cap spend on automations that could loop or run more often than expected.
  • Budget accountability: Give each team-owned automation its own spend limit instead of relying on org-wide monitoring.
  • Early warning: Route the warning notification to the automation owner so they can investigate before the budget is exhausted.
Note

When a run is blocked because the credit budget is exceeded, its status shows as Guardrail Failure. See Run Fails with Guardrail Failure for details.

Tool Parameter Overrides

Force specific values for tool parameters, overriding what Agent0 chooses.

When to Use

Lock down Slack channels:

  • Always post to #incidents regardless of what Agent0 decides
  • Prevents posting to wrong channels

Enforce time ranges:

  • Always query the last 1 hour
  • Prevents Agent0 from using different timeframes

Pin dataset:

  • Ensure queries use the automation's dataset
  • Prevents accessing wrong data

Configuration

Use the tool's panel in Manage tools:

  1. Open Tools & Skills → Configure tools and select the tool, for example slackSendMessage.
  2. Turn Allowed on if needed.
  3. Under Parameter overrides, enter the value in its parameter field, for example C12345678 for channelId. Expand nested fields when needed.
  4. Values can include variables such as {{slack.channel.id}}. Use variables available for every trigger that can call the tool.
  5. Close the dialog and save the automation. Invalid override values must be corrected before saving.

Example Use Cases

Force Slack responses to triggering channel:

  • Tool: slack.slackSendMessage
  • Override: channelId = {{slack.channel.id}}
  • Result: Agent0 always responds in the same channel where the trigger fired

Pin metric query timeframe:

  • Tool: dash0.getMetricQuery
  • Override: timeframe.from = now-1h
  • Result: Agent0 always queries the last hour

Common Issues

For detailed troubleshooting, see:

Best Practices

  • Start restrictive: Begin with No Network, minimal Allowed Tools, and test thoroughly before enabling full access
  • Use defaults when possible: Leave tool settings unchanged to use the default policy based on trigger type
  • Require critical tools: If posting to Slack is the automation's main purpose, require slackSendMessage
  • Test with manual runs: Click Run Now to verify guardrails work as expected before enabling the automation
  • Choose whether events can be combined: Use debounce when only the latest event matters. Set it to 0 when each event needs its own run, then choose a concurrency policy for overlapping runs.

Further Reading