Skip to main content
This guide follows one production error to a fix that is reviewed, merged and live, with the error resolved in the release that fixed it. Each hop has its own guide; this page shows how they connect and who acts at each one. It is two linked Autopilot workflows with a person between them. On-call files an investigated, deduplicated GitHub issue. A person decides it should be fixed. The issue worker opens a pull request. A person reviews and merges it, and you ship it.

Before you begin

1

Check both workflows before they run

Both built-ins ship with scenarios that mock GitHub and the agents, so you can see the gates hold without spending tokens:
terminal
All 45 pass (22 on-call, 23 issue worker). never_sets_the_ready_label proves on-call stops at agent:triage. trusted_labeler_opens_pr shows a trusted person’s label ending at a pull request, not a merge.
2

An error becomes an issue

Forge groups errors into issues, ties each to the release it first appeared in, and fires a NewIssue alert for a new one:
terminal
Find which release introduced an error shows how to read the issue.
3

On-call files one GitHub issue

Within a few minutes the activation fires and opens an issue in the mapped repository, labelled agent:triage, with a severity, evidence, a suspected cause and a proposed fix. Its Issue key is the forge issue id, written without dashes, next to a link to the issue in the console.The key is what deduplicates: if the error regresses or spikes while the GitHub issue is open, on-call comments on it instead of filing another. See what it files.
4

Decide whether an agent should fix it

This is the first gate, and only a person passes it. Read the write-up next to the error itself, from your checkout so you also get the suspect commits:
terminal
If the fix belongs to an agent, swap the label:
terminal
Otherwise fix it yourself, or close it as noise. If the release is hurting users now, redeploy the last good release first; nothing rolls back on its own.
5

The issue worker opens a pull request

The label starts a run that writes a failing test and the fix in a worktree, runs your gate_command, and pushes autopilot/issue-<number>. You get a pull request from reliant-labs[bot] that says Closes #<number> and carries agent:authored. If the agent could not finish, the issue gets agent:punted or agent:blocked and a comment saying why (what you get).
6

Review and merge

This is the second gate: Autopilot never approves or merges. Review the change as you would a teammate’s, optionally after the AI pull request reviewer has read it, and merge it yourself. Merging closes the GitHub issue. It does not change the error issue in forge.
7

Resolve the error in the next release

Tie the error to the release that will carry the fix:
terminal
Events from the release live now do not reopen it; an event from any later release reopens it as regressed.
8

Ship the fix and verify it

Cut a release from the merged commit, prove it in staging and promote the same bytes. Then judge production:
terminal
Exit 0 means PASS, 1 a regression, 2 not proven good, 8 the wait ran out (how verdicts work). The error should be listed as resolved and stay that way.

What this does not do

  • It never merges, deploys or rolls back. Autopilot files issues and opens pull requests. A workflow you write yourself can merge with github/pr.merge@1 (merging is a workflow step), but none of the built-ins do.
  • On-call does not read your logs or traces. It works from the error’s title, culprit, first build, console link and the code. For a deeper look, debug production with an agent.
  • Merging does not resolve the error. Resolve it yourself, as in step 7. If the error returns after the fix ships, it reopens as regressed, and because the GitHub issue is now closed, on-call files a new one.

Troubleshooting

Check the activation’s firings and its alert receiver as in the on-call guide’s troubleshooting.
The issue worker’s firing failed before any work. An admin adds an organization AI account, then you label the issue again (details).

Next steps

Alerts to GitHub issues

Turn on on-call and see what it files.

Issues to pull requests

Turn on the issue worker and review its work.

Find the culprit release

Read an error issue and resolve it in a release.

Recover from a bad deploy

Put the last good release back while the fix is written.

Agents in production

How agents operate production safely, and what they never do.

Release verdicts

How a release is judged PASS, FAIL or INCONCLUSIVE.