# Andon drives

Andon drives is one switch that keeps the board going without you, overnight say. While it is on, Autopilot runs for
every team, and Andon answers the questions and routine review steps that would otherwise wait for you. Every answer is
on the run's history with its reason, so you can read back what was decided for you.

## Turn it on

1. Find the **Andon drives** toggle in the corner dock, beside the chat button. On a phone it is in the menu, under
   the org's name.
2. Turn it on. Only owners and admins can; everyone else sees the toggle only while it is on.

Turn it off the same way. The teams go back to how they were and the answering stops. Work already building carries on.

## What changes while it is on

- **Autopilot is on for every team that had it off.** A team you paused stays paused, and a team whose cards are done by
  hand stays by hand. When the switch goes off, each team gets its own setting back, unless you changed that team in
  the meantime.
- **Pause all autopilots is lifted.**
- **A run's questions are answered.** When a run stops on a multiple-choice question, Andon picks the option a careful
  engineer who knows the card would, and the run carries on. A question asked in words (the `andon.ask` tool) gets an
  answer in words, as your own reply would.
- **A finished turn that waits on you gets a reply.** When a session ends its turn on a question or a request for a
  go-ahead ("Shall I open the pull request?"), Andon replies. A turn that asks nothing is left alone. Decisions listed in
  a run's report are answered too, one choice each.
- **Review steps are taken.** Andon approves outputs (pages, images, files a run made) that match the card, but never
  rejects: asking for a revision is yours, and a study's outputs still come to you. It accepts a proposed plan when the
  steps together do what the card asks, and retries a blocked step when the failure looks passing, such as a flaky
  check, a timeout or a machine that went away.
- **On a Code change or Bug card, everyday tool calls are allowed**: reading and editing files, running the tests, the
  linter, the type checker or the build, installing the project's dependencies, committing, pushing the card's own
  branch and opening its pull request. A choice a run shows on its own screen (a Codex or Gemini CLI approval) gets one
  of its options the same way.
- **Every choice heads for review and merge.** Of the ways forward, Andon takes the one that gets the card's pull
  request opened with no one's hands on it: the session does the step itself, commits, pushes its branch and opens the
  pull request (ready for review, or a draft when the team's settings make it one), and Andon's own review, the checks
  and the merge follow. A card whose work isn't delivered through a pull request is finished and reported instead. An
  option that hands a step to you ("I'll do it myself", "open the pull request yourself", "test it by hand", "stop
  here") is not picked when the session could do the step. A push to main or master always comes to you.

Andon never denies a permission or rejects work: what it doesn't take comes to you as before.

## See what Andon decided

- **While it answers.** A card waiting on a question or a decision says so in its **Needs you** box: *Andon is
  driving: it is answering this now*, with Andon at work beside it. You can still answer it yourself; whichever answer
  lands first counts. When Andon leaves a question to you, the box says why.
- **Afterwards.** Each decision is a line in the card's history with Andon's mark, so it reads apart from what the run
  did: what it decided (*Andon drives: answered "Postgres"*), and under it the question it answered and why
  (*Which store? → Postgres · Why: the card names Postgres*). The card's Chat marks those answers *Andon answered*.

## Limits

| Andon answers at most | Then |
|---|---|
| 5 messages a card an hour (replies and `andon.ask` answers together) | the card is yours again, so two models can't keep each other going |
| 40 tool calls allowed a card an hour | they come to you |
| 2 retries of a blocked step a card a day | the step is yours |

Andon tries for 10 minutes to deliver an `andon.ask` answer to a headless run still finishing its turn, then leaves the
question for you. A machine asked to answer (below) gets 5 minutes.

## What it never does

- **Allow tool calls on other cards.** On any card that isn't a Code change or Bug, a request to run a command or edit a
  file waits for you. So does a run waiting in its terminal with nothing to pick.
- **Allow anything risky.** A call that looks destructive or reaches outside the repository comes to you without
  asking the model: a force push, `rm -rf`, `sudo`, a hard reset, a deploy, a publish, a merge, a download piped into a
  shell, anything naming a secret, a token or `.env`. So does a choice about money (a usage-credits or billing prompt),
  and a call too long for the model to read whole.
- **Answer when only you know.** An option that loses work for good, spends money, sends something outside the
  repository or exposes a secret is never picked: the question comes to you.
- **Reply to a turn that reports done.** Done ends the session and moves the card.
- **Answer a Codex or Gemini CLI session's own question prompts.** Their `andon.ask` questions and finished turns are
  answered.
- **Merge protected paths.** Whether a pull request that changes migrations or CI config merges by itself is the team's
  **Protect the standard paths** setting.

## Who answers

Andon asks the workspace's AI backend ([AI backends](https://andon-docs.pages.dev/machines/ai-backends.md)): by default the Gemini key, the organization's
then the server's, then the Vercel AI Gateway key, or a machine that serves model calls when the backend is **On a
machine**. `GEMINI_TRIAGE_MODEL` and `AI_GATEWAY_TRIAGE_MODEL` pick the model.

When none of these can answer, **the run's own machine answers**. Its Claude Code gets the same brief with no tools, no MCP servers,
none of your settings or hooks, and no saved session. The machine is asked only when it is online, runs Claude Code,
doesn't require signed commands, and allows it:

```sh
andon policy drive-answers on    # the default
andon policy drive-answers off
```

## Machines that require signed commands

A machine set to `andon policy signatures require` refuses anything unsigned, and Andon's answers and allows are
unsigned. On such a machine its questions and permissions wait for you, even while Andon drives.
