D1 · Agentic Architecture › Cluster 5 · Autonomy

5.1 · Autonomy Levels

The supervised → fully-autonomous spectrum

CONCEPT Autonomy is a dial, not a switch

Once you've decided to build an agent, the next architectural decision is how much latitude the loop gets before a human is involved. Autonomy is a spectrum. Turning the dial up buys you speed and throughput; it also enlarges the blast radius — the scope of damage a single bad decision can cause. The architect picks the lowest autonomy that still meets the throughput requirement, then gates the rest (see 5.2).

LevelWho acts / who approvesSpeedBlast radiusFits when…
Supervised Agent suggests, a human approves every side-effecting step Slow (human in the loop)Smallest — nothing runs unreviewed Irreversible / high-stakes actions; early rollout; regulated flows
Semi-autonomous Agent acts; a human can override / interrupt BalancedModerate — bounded by gates & monitoring Most production agents: act on the reversible, gate the dangerous
Fully autonomous Agent acts freely, no per-step human FastestLargest — a mistake propagates unchecked Low cost-of-error, sandboxed, or fully reversible domains
🔑 The governing trade-off: higher autonomy = more speed but a bigger blast radius. You are not choosing "good vs. bad" — you are trading human latency against the cost of an unreviewed mistake.

DIAGRAM The autonomy spectrum

flowchart LR S["🟢 Supervised
suggest → human approves
safe · slow"] --> M["🔵 Semi-autonomous
acts · human can override
balanced"] --> F["🟣 Fully autonomous
acts freely
fast · higher risk"] S -.->|"turn the dial up →
+speed · +blast radius"| F classDef a fill:#d4edda,stroke:#28a745,color:#155724; classDef b fill:#d1ecf1,stroke:#17a2b8,color:#0c5460; classDef c fill:#e2d4f0,stroke:#764ba2,color:#3d1a5b; class S a; class M b; class F c;

CONCEPT Autonomy is per-action, not per-agent

A common mistake is to pick one autonomy level for the whole agent. Real designs set autonomy per tool. The same agent can run read_file fully autonomously while forcing send_email through a supervised gate. This is exactly the reversibility axis of 5.4: cheap, reversible reads auto-run; irreversible writes get a human. The agent feels semi-autonomous overall because its dangerous edges are individually supervised.

CODE Selecting autonomy per tool call

The Messages API is stateless: each turn you re-send the transcript. That gives you the seam to decide, per tool_use, whether to auto-run or hold for approval before continuing the loop.

# Autonomy encoded as a policy the harness consults for each tool the model picks.
AUTONOMY = {
    "read_file":  "auto",        # reversible → fully autonomous
    "list_dir":   "auto",
    "send_email": "supervised",  # irreversible → human approves
    "delete":     "supervised",
}

def level_for(tool_name):
    return AUTONOMY.get(tool_name, "supervised")   # default: safest (deny-by-default)

for block in resp.content:
    if block.type == "tool_use":
        if level_for(block.name) == "supervised" and not human_ok(block):
            result = "Denied by policy: needs human approval."   # see 5.2
        else:
            result = run_tool(block.name, block.input)
Design move: default unknown tools to the safest level. A new tool added without a policy entry should require approval, not silently run fully autonomously.

TRADE-OFFS Turning the dial up

✅ More autonomy

  • Higher throughput — no waiting on humans
  • Lower latency per task; scales to many concurrent runs
  • Humans freed for exceptions, not routine approvals

⚠️ More autonomy

  • Bigger blast radius — mistakes act before review
  • Harder to audit; errors compound across the loop
  • Needs stronger guardrails, budgets, and monitoring
Rule of thumb: start supervised, earn autonomy. Ship a new agent supervised, watch its decisions, then promote reversible actions to auto as confidence grows.

EXAM TRAPS

Trap: "More autonomy is always better because it's faster." → Speed rises but so does blast radius. The right level is the lowest that meets the throughput need, not the highest.
Trap: Treating autonomy as one setting for the whole agent. → Set it per tool. Reversible reads can be fully autonomous while an irreversible delete stays supervised.
Trap: Equating "fully autonomous" with "no guardrails." → Even a fully-autonomous agent still needs budgets, max-iteration caps (5.3), and monitoring — autonomy removes the human, not the limits.
Trap: Assuming default-open. → A safe harness is deny-by-default: an unclassified action requires approval rather than running freely.

PRACTICE

Q1 · A banking agent can issue refunds. Which autonomy level, and why?

Supervised for the refund action specifically. Issuing money is high-stakes and hard to reverse, so a human should approve it — even if the rest of the agent (reading account history, drafting a reply) runs semi-autonomously. Autonomy is set per action.

Q2 · Your agent only reads logs and summarizes them in a sandbox. What level fits?

Fully autonomous. Reads are reversible and the sandbox caps the blast radius, so there's no value in a human approving each step. Reserve human latency for actions that can actually cause harm.

Q3 · Stakeholders want "maximum speed." How do you push autonomy up safely?

Don't flip one global switch. Promote individual reversible tools to auto, keep irreversible ones gated (5.2/5.4), and add budgets + max-iteration caps (5.3). You raise throughput on the safe majority while preserving small blast radius on the dangerous minority.