The autonomy dial

Lesson 3 of 5 in What Is an Agent? The Loop That Changes Everything.

“Is it autonomous?” is the wrong question. Autonomy is not a yes/no property of a product — it is a dial, and well-built agents set that dial differently for every action they can take.

Climb the spectrum from the bottom. Each tier hands the model more authority and the human less visibility — and each step up must be earned by evidence that the tier below worked.

The autonomy spectrum

  1. Fully autonomous — acts, no human in the path

    The agent acts with no human review before or reliably after. Reserve this tier for actions that are reversible, contained, and continuously monitored — and keep a kill switch wired in. Very few actions belong here on day one.

  2. Act and report — acts first, humans audit after

    The agent completes actions and files a record for after-the-fact review. Sampling and traces replace per-action approval — oversight shifts from gate to audit.

  3. Act with approval — proposes, a human gates each action

    The agent prepares the action; a human clicks approve before it fires. This is the human-in-the-loop tier — and an approval gate only counts if the human has the time, context, and authority to say no.

  4. Suggest — drafts, a human executes

    The model proposes; a human performs the action themselves. Wrong suggestions cost minutes, not incidents — which makes this the natural launch tier for anything touching money, customers, or production.

  5. Fully manual — humans act, the system informs at most

    No model authority at all — perhaps a dashboard or a search index. The baseline every other tier is measured against: what error rate, speed, and cost does the human process have?

Here is the design insight most first-time agent builders miss: autonomy is set per action, not per product. A single coding agent typically runs three tiers at once — it reads files fully autonomously, edits them act-and-report, and runs shell commands only with approval. Same agent, three dial positions, because reading is harmless, edits are reversible, and shell commands are neither.

So “how autonomous is your agent?” has no single answer, and that is a feature. The right question — asked once per tool, per action type — is: what is the blast radius if this exact action goes wrong, and how fast would we notice? Walk the logic below.

Set the autonomy dial for one action

Interactive decision tree — outcomes:

  • Fully autonomous

    Reversible and observable — let the agent act. Keep the action logged and the kill-switch wired; earned autonomy is still monitored autonomy.

  • Act and report

    The agent may act, but every action lands in an auditable digest a human actually reads. If the digest goes unread, this tier silently becomes full autonomy — schedule the reading, not just the reporting.

  • Act with approval

    Gate it. And design the gate for a real decision: show the diff, the recipient, the amount. An approval a human cannot evaluate is theatre, not oversight.

  • Suggest only

    If a human can’t verify the action quickly, don’t ask them to rubber-stamp it — keep the human as the executor until you can make verification cheap (better diffs, smaller actions, dry-run modes).

Key terms: autonomy, autonomy spectrum, human-in-the-loop, approval gate, kill switch, blast radius

Interactive checkpoint quiz (1 questions) — open this page in a browser to take it.