Overview
Coding agents accelerated feature work and moved the bottleneck to everything after the commit: the work that keeps software reliable, secure, cost-efficient and supportable. A common workaround is to add a few skills to a coding agent and run it from a laptop when needed. This works until the engineer is unavailable or doesn't know what to ask, or until the skills go stale as systems change. A coding agent's output depends on who prompts it and on the model behind it. That suits novel feature work. It fails repetitive operational work that has to produce the same quality of result every time.
Autoheal is a self-improving software factory for that post-coding work. It turns ad-hoc agent workflows into a shared, cloud-based system that runs in the background, 24x7, in a governed environment. One engineer's practices then become available to every engineer and agent. The factory has two planes and one loop:
- The context plane: what every agent reads before it acts, and what Autoheal improves.
- The control plane: how every agent runs and is governed.
- The self-improvement loop: the Evaluator and Healer, which keep agents accurate and cost-efficient as your systems change.
Get started
Build an agent that reviews a real pull request, in about 10 minutes, in the browser.
Grow that agent step by step: YAML, model, skills, tools, triggers, Git, the Assistant and the CLI.
Organizations, projects, agents, skills, tools, triggers and runs on one page.
What you can do
Autoheal groups agents by the post-coding work they take on.
| Area | Agents |
|---|---|
| Production operations | Incident Response · Alert Triage |
| Security | Vulnerability Remediation |
| Developer experience | AI Coding Cost Efficiency: an agent owned by your DevEx team that lowers your coding agents' cost per task. It does not change which coding agents developers use |
Autoheal doesn't manage or replace the coding agents your developers already use, such as Claude Code, Codex or Cursor. It changes the context they read, through the CLI, so an improvement made for one agent reaches every agent, coding agents included.
Any other step that you can describe in plain English can become an agent of your own. It gets its own trigger, instructions, and rules for the integration tools that it can call. See Build Your Own Agents.
How it works
Context plane
The context plane is what every agent reads before it acts, and it is the part of the factory the self-improvement loop changes. It has two parts:
- A context graph that links your repositories, services, teams and people, with tickets and releases read live from the connected integrations. This is the Engineering Context Graph and its entities.
- A skill and memory registry that holds the skills, AGENTS.md files and memories agents read for each task.
The graph connects four layers of your environment:
Services, dependencies, topology, deployment targets, and resource configurations. The ECG knows how your systems relate to each other.
Repositories, recent deployments, pull requests, CI/CD pipelines, and change history. The ECG knows what changed and when.
Observability platforms, incident management systems, documentation wikis, and custom internal tools, all connected via MCP integrations.
Skills, past incident RCAs, service ownership, debugging procedures, and team expertise.
Control plane
The control plane is how every agent runs. Agent definitions, budgets, model selection, identity, roles and approval policy live in one governance layer, so a team governs every agent the same way.
| Capability | What it means |
|---|---|
| Agent definitions as code | Agent definitions are versioned, diffed, and promoted through the review workflow your team already uses for services (GitOps coming soon) |
| Budgets and model selection | Spend is tracked per agent and per team. Frontier models handle complex reasoning such as hypothesis formation and root cause analysis. Lower-cost or open-weight models take the steps where evaluations show they perform well |
| Identity and roles | Agents and people act under roles and SSO identity, and every action is attributed |
| Approval policy | Organization-wide governance policies pause any matching tool call, such as every write, until a person approves it. A run that needs a decision pauses as waiting for input instead of acting |
| Escalation | When a step calls for it, an agent escalates to your DevEx, DevOps or SRE team for input or approval |
| Observability and audit | Every run records its trigger, the integrations it queried, the context it loaded, each step it took, and its conclusion. The audit trail holds this record, with the evidence behind it. Insights shows the totals for a project, or for all projects. It shows the runs of each agent, how they ended, which runs wait for a person, their cost, and how many an eval scored |
| Sovereign deployment | Fully-managed SaaS by default, or BYOC in your own cloud, connected or airgapped |
Tool gateway
A tool gateway registers, scopes and audits every integration once, for every agent. Agents reach your systems over the Model Context Protocol (MCP) through integrations spanning code and CI/CD, infrastructure, observability, docs, collaboration, and task management.
- Least privilege by default. Many integrations ship only read tools. Where write tools exist, agents use them only when granted, and governance policies can require approval for each write. Each agent has an explicit allow-list enforced by the platform rather than by prompt instructions, and read and write access are granted separately.
- Audited. Every tool call is recorded in the audit trail.
- Real-time data. There are no data syncing or ETL pipelines. Agents query your tools live during a run.
- Extensible. Connect any tool by building a custom MCP server.
See Sovereignty and Security.
Self-improvement
Agents drift as your codebase, production architecture and tools change. For this reason, Autoheal runs two agents whose only job is to keep the others accurate and cost-efficient.
- Evaluator. Scores every run's trajectory and outcome against rubrics generated from downstream signals: review comments, CI re-runs, fired alerts, and the incident's confirmed root cause. It runs continuously on your data, in your isolated organization (SaaS) or your own environment (BYOC). Your run data is never used to train models.
- Healer. Turns weak scores into specific context changes. Examples include an updated skill, an AGENTS.md correction, a new memory, a narrower tool scope or a different model. Each change is back-tested against your run history and opened as a pull request only if it clears a blast-radius threshold.
- Engineer approval. Every change is version-controlled in git and needs an engineer's approval to go live, reviewed like any other pull request.
Because the context is shared, an approved change improves every agent that reads it, including coding agents in the same repositories. The loop only catches what leaves a downstream signal. A failure mode with no review comment, re-run, alert or confirmed root cause stays invisible until someone notices it in a run. See Self-Improvement, the Evaluator and the Healer.
Next steps
- Quick Start: build and run your first agent.
- Build Your First Agent: ten short chapters, from YAML to a trigger.
- Use a ready-made agent: start from the public library.
- Security and Sovereignty: how Autoheal keeps your data and your actions under control.