Agent0 is built around a single Agent0 orchestrator, named "the brain", which selects what to do based on your request, the tools available, and the context that it can read from your environment.

The orchestrator takes its input from your configurations, your interactions with Agent0, and your context. It routes its output to Dash0, your codebase, and your infrastructure. The middle layer is where the work happens.

These aspects distinguish Agent0 from a general-purpose AI chat assistant layered on top of telemetry data:

It runs, it does not simply talk. Agent0 executes inside a sandboxed runtime that can clone code, run commands, and complete real workflows. It produces working assets, not suggestions to paste somewhere else.
It validates before it creates. Agent0 checks that the underlying queries return data before generating dashboards, alerts, or other artifacts. If a query doesn't resolve, it reports that instead of emitting something broken.
It reads OTel natively. Agent0 works directly with your OpenTelemetry data in its native structure, without translation or proprietary intermediaries, which keeps the semantic context intact during investigations.

Terminology

Agent0's terminology, alphabetically ordered, is as follows.

Agent0

The orchestrator. Agent0 receives a request, decides the skills to apply, the tools to call, and the output to produce. It executes inside a sandboxed runtime that can clone repositories, run commands, and call connected tools the same way a developer would on their own machine.

Artifact

Anything Agent0 produces and emits into your environment: an alert, a dashboard, a pull request, a runbook entry, a query result, a documentation page. Artifacts are validated against your live data before they are created.

Chat

The live, interactive interface to Agent0. You ask, Agent0 responds. Chat is conversational and contextual. It carries thread state across messages and can be opened on any page in Dash0.

Configurations

The settings that shape how Agent0 behaves on a given task.

Trigger — what causes Agent0 to act e.g., a user request in Chat.
Prompt — the instruction Agent0 receives, e.g., typed live.
Model — the underlying language model used for reasoning.
Guardrails — constraints that limit what Agent0 can do (read-only mode, approval requirements, scope limits).
Connectors — the external systems Agent0 is allowed to connect to for this task.
Skills — the internal capabilities Agent0 can apply (see Skills below).

Connectors

AI-specific integrations to retrieve data from or send actions to external systems. GitHub and Linear are first-class connectors configured in Settings → Integrations. Custom MCP servers are added by providing a server URL and configuring tool access.

Context

What Agent0 knows about your environment at the moment it acts. Context has two parts:

Facts — what Agent0 can read: your Dash0 telemetry and connected external systems.
Behaviors — how Agent0 acts on what it knows: the skills it can apply and the guardrails that constrain it.

Guardrails

Constraints on what Agent0 can do for a given user, scope, or configuration. Guardrails include read-only mode, required approvals for destructive actions, and per-tool restrictions.

Hypothesis tree

The reasoning trace produced during an investigation: the hypotheses Agent0 tested, the evidence it found, and the conclusions it reached. Surfaced in Chat as part of investigation outputs.

Integrated Experience

Context-aware Agent0 prompts that appear on every page of Dash0. The prompts available change based on what you are looking at: a selected span, a failed check, a metric panel, a log row, a dashboard being edited. Side-panel mode lets the conversation continue while you navigate.

Live Insights

A per-service rail on the Agent0 landing page that surfaces what is actively going wrong in your environment: failing checks, error rate spikes, latency spikes, pod saturation, recent deployments, slow database calls, and services with elevated errors or latency but no active alert coverage. Each entry is service-scoped and severity-ranked, with a template prompt for one-click investigation.

MCP (Model Context Protocol)

The open standard for connecting AI systems to external tools. Agent0 supports any MCP-compatible server as a connector, including read-only and destructive operations, and respects the tool's declared hints.

Run

A single execution of Agent0 in response to a trigger, e.g., a user message in Chat.

Sandboxed runtime

The isolated execution environment Agent0 uses to run commands, clone repositories, and execute multi-step workflows. Each run gets its own sandbox and cannot affect your production systems directly.

Skills

Encoded workflows that Agent0 uses to perform specific kinds of tasks: querying span data, building a PromQL query, creating a Perses dashboard, working with GitHub, and so on.

Agent0 loads and applies skills autonomously based on request. You do not configure skills directly.

Sub-agent

A parallel instance of Agent0 spawned by the orchestrator to handle a delegated subtask in its own context. Sub-agents let the parent run stay focused while specialized work happens alongside it.

Tools

Built-in capabilities Agent0 can invoke in every session without configuration:

SQL for querying connected databases.
Bash for running bounded shell commands inside its sandboxed runtime.
Connectors (GitHub, Linear, MCP servers) expose additional tools to Agent0 once configured.

Validation before action

Agent0 verifies that a query returns real data before creating an asset based on it. Dashboards are not generated against PromQL that doesn't resolve; alerts are not created against metrics that don't exist. If validation fails, Agent0 reports the failure rather than emitting a broken artifact.

Key Concepts