Last updated:
Set Guardrails
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.
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.
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
- Open Tools & Skills in the automation editor, or Tools if custom skill selection is not available.
- Click Configure tools to open Manage tools.
- Search for and select a tool. Turn Allowed on to permit it, or off to block it.
- 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.
- To pin inputs, fill in Parameter overrides in the same tool panel. Leave a field blank to let Agent0 choose its value.
- Close the dialog to apply the changes to the form, then save the automation.
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.
Default Behavior (Recommended)
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
slackSendMessagein 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:slackSendMessagebut notslack: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:
- Open Tools & Skills → Configure tools.
- Find and select the tool you want to block.
- 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:
- Agent0 gets one retry with an explicit reminder to call the missing tool
- If still missing, the run is marked as
guardrail_failure - 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
getMetricQueryandgetLogRecords - Ensures Agent0 checks multiple data sources, not just one
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
| Policy | Active runs | When the limit is reached |
|---|---|---|
| Parallel (default) | Up to Max parallel runs, defaulting to 50 | Additional triggers wait in a queue. |
| Queue | One | Additional triggers wait in a queue. |
| Skip | Up to Max parallel runs, defaulting to 50 | Additional triggers are skipped without being queued. |
| Supersede | One | A 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
0disables 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.
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.
How It Works
- Credit budget: The number of credits allowed per rolling window (for example,
250per1week). 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.
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.
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
#incidentsregardless 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:
- Open Tools & Skills → Configure tools and select the tool, for example
slackSendMessage. - Turn Allowed on if needed.
- Under Parameter overrides, enter the value in its parameter field, for example
C12345678forchannelId. Expand nested fields when needed. - Values can include variables such as
{{slack.channel.id}}. Use variables available for every trigger that can call the tool. - 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:
- Agent0 Doesn't Call Expected Tools — Why Agent0 skips tools or can't post to Slack
- Run Fails with Guardrail Failure — Understanding guardrail violations, including credit budget failures
- Automation Doesn't Trigger — Issues with debounce and concurrency
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
0when each event needs its own run, then choose a concurrency policy for overlapping runs.
Further Reading
- Write Prompts — Create effective instructions for Agent0
- Configure Triggers — Define when automations run
- Configure General Settings — Set up basic automation information
- Use Templates — Start with pre-configured guardrails



