AutoMerge is generally available

Last updated:

Key Concepts

Core concepts and terminology for understanding Dash0 Automations.

Understanding automations requires familiarity with a few core concepts that govern how they're defined, triggered, and executed.

Automation Definition

An automation's settings include:

  • General settings: Name, description, and whether it's enabled
  • Triggers: One or more event types that fire the automation
  • Prompt: The instruction Agent0 receives when the automation runs
  • Sandbox: Setup for the command runtime and reusable prompt parameters
  • Guardrails: Constraints that control what Agent0 can do

When you create an automation, all these components work together to define its behavior.

Triggers

Triggers define when an automation runs. Each trigger watches for specific events:

  • Slack messages containing certain keywords
  • Failed checks in Dash0
  • GitHub pull requests being opened or updated
  • GitLab merge requests or comments on connected projects
  • Scheduled times based on cron expressions
  • Linear events such as comments on issues and status changes of issues, projects, and initiatives
  • Webhook requests sent to the automation's unique URL

Multiple triggers can be defined for one automation. When any trigger matches an incoming event, the automation executes.

Each trigger type exposes specific variables to your prompt. For example, Slack triggers provide {{slack.channel.name}} and {{slack.message.text}}, while check triggers provide {{check.name}} and {{label.service}}.

Variables

Variables are placeholders in your prompt that get replaced with real values when the automation runs.

Built-in variables work in every automation:

  • {{now}} — Current timestamp
  • {{today}} — Current date
  • {{dash0.dataset}} — Your Dash0 dataset

Trigger variables come from the event that fired:

  • {{slack.message.text}} — Message content (Slack triggers)
  • {{check.name}} — Failed check name (check triggers)
  • {{github.repository}} — Repository name (GitHub triggers)
  • {{gitlab.project}} — Project path (GitLab triggers)

Parameters are custom prompt values you define under Sandbox → Parameters:

  • {{environment}} — Could be set to "production"
  • {{alert_channel}} — Could be set to "incidents"
  • {{team}} — Could be set to "platform-team"
Tip

Built-in variables like {{dash0.dataset}} cannot be overridden by trigger data or parameters. This prevents external events from spoofing internal values.

Sandbox

The Sandbox section holds the automation's Setup script, Setup variables, and Parameters. Setup variables are passed only to the setup script; parameters are substituted into the prompt. Neither is secret storage. Deployment-specific controls can replace the setup fields with an Environment selector or add resource profiles.

See Configure Sandbox for setup timing, passing non-secret values to the agent's shell, credentials, and the available editor variants.

Guardrails

Guardrails control what Agent0 can do during execution:

Network access:

  • 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, webhooks).
  • Trusted hosts only: The sandbox can reach only a curated allowlist of pre-approved hosts (see the trusted hosts list).
  • Full Network: Agent0 can make any outbound request, including sandbox-native operations like git/gh CLI and webhooks

Timeout:

  • Maximum time Agent0 can run before stopping (default: 10 minutes)

Allowed tools:

  • Which Dash0 features and integrations Agent0 can use
  • By default, read tools are allowed and write tools require a matching trigger namespace. Required tools and non-destructive internal tools are also included. Sandbox CLI access is separate; see Allowed Tools.

Required tool calls:

  • Tools that must be called for the run to succeed
  • Required tools are force-included even when an allowlist would exclude them. A call still needs integration access and valid parameters; requiring it does not guarantee a successful external action.

Configure tool access, required calls, and parameter overrides together in Tools & Skills → Configure tools, not in the Guardrails section. Select custom skills in the Skills field when available.

Concurrency:

  • How simultaneous triggers are handled (parallel, queue, skip, or supersede)

Debounce:

  • Delay that waits for events to stop arriving before running

Credit budget:

  • Caps credits spent within a rolling window (default: 250 credits per week)
  • Blocks new runs once recorded rolling spend reaches the budget. Active runs are not canceled, and concurrent runs can exceed the budget before their costs are recorded.
  • Can warn a notification channel once spend crosses a configurable percentage (default: 75%)

Tools and Integrations

Tools are the actions Agent0 can take:

Dash0 tools query your observability data:

  • Metrics, traces, logs, services, and checks
  • Always available, no integration needed

Slack tools interact with your workspace:

  • Post messages, read channels, respond in threads
  • Requires Slack integration

GitHub tools read repositories:

  • List repositories
  • Requires GitHub integration. For PR comments, use gh CLI via bash with Trusted hosts only or Full Network and repository write access.

Linear tools access issues:

  • Search issues, get details, list teams and projects
  • Requires Linear integration. Issue and comment write tools are available only when enabled for your organization and permitted by the automation's guardrails.

Custom skills: an automation uses only the custom skills on its allowed skills list.

For scheduled Slack posts, explicitly allow or require slackSendMessage. Tool selection does not guarantee a successful post; integration access and valid parameters are still required.

Concurrency Policies

When an automation is triggered again before a previous run has finished, the concurrency policy determines what happens:

Parallel (Default):

  • Run multiple instances at once, up to the configured Max parallel runs limit
  • Further triggers wait in a queue
  • Best for read-only analysis with controlled parallelism

Queue:

  • Only one run of the automation is active at a time
  • A new trigger waits until the current run finishes, then runs next
  • Best for operations that shouldn't overlap

Skip:

  • Run multiple instances at once, up to the configured Max parallel runs limit
  • Skip further triggers without queuing them while the limit is reached
  • Best when overlapping runs are useful but a backlog is not

Supersede:

  • New triggers cancel all currently running instances and start fresh
  • Best when fresh context is more valuable than completing old runs

See Concurrency settings for defaults, queue capacity, and how to configure each policy.

Runs

Each time an automation executes, it creates a run record showing:

  • Status: Success, error, or guardrail failure
  • Summary: Agent0's description of what it did
  • Tool calls: Every action Agent0 took with arguments and results
  • Duration: How long the run took
  • Trigger: Which event fired the automation

Run history is available in the automation's Runs tab. You can filter by status, review what Agent0 did, and provide feedback to improve future runs.

The automation overview also shows credit metrics for the last 7 days: total runs, failed runs, total credits used, average credits per run, and credits spent against the configured credit budget.

Debounce

Debounce waits for events of the same trigger kind to stop arriving, then processes the latest event. Another event of that kind replaces the pending event and resets the timer. Events for different entities can replace each other if they share a trigger kind. A different trigger kind flushes the pending event immediately and starts a new debounce window.

An empty setting uses the default debounce window. Set Debounce to 0 to process triggers immediately through the concurrency policy. Disabling debounce does not disable concurrency or dispatch limits.

See Debounce settings for the default window, minimum duration, and examples.

Templates

Templates are pre-built automations for common scenarios:

  • Incident triage when checks fail
  • PR review assistance for GitHub
  • Scheduled service health reports
  • Slack-driven queries and investigations

Templates include working trigger configurations, well-crafted prompts, and appropriate guardrails. Start with a template and customize it for your needs.

Datasets

Automations run within a specific Dash0 dataset, which determines what observability data Agent0 can access. The dataset is set when you create the automation and cannot be changed later.

All queries for metrics, logs, traces, and services use the automation's dataset. This ensures automations only access data within their intended scope.

Further Reading