Six Levels of AI Agent Autonomy: Capability vs Orchestration
This article introduces a two-axis framework (agent capability and orchestration capability) defining six autonomy levels for AI agents, from Level 0 assistance to Level 5 exception-management orchestration, with concrete examples from Claude Code and Codex, metrics for measuring autonomy, anti-patterns, and a calibration exercise for safe adoption.
In most discussions of agent engineering, the focus has shifted from prompts to execution. The frontier now includes software factories, goals, loops, background sessions, sub-agents, hooks, sandboxes, and approval agents. Engineers use low autonomy to limit risk and increase reversibility, but also employ higher autonomy in well-defined activities, letting parallel agent clusters safely refactor large codebases. The core question for any action is: what level does this task deserve, and what verification makes that level defensible?
The cutting edge is the manager agent: it wakes on a trigger, delegates to helpers, continuously verifies their output, and returns only decisions that must be made by humans. Users of this setup may already run hundreds or thousands of agents, mostly on evergreen codebases. As with almost all thinking about autonomy, how you perceive scale remains different for everyone.
The most cited scale is Steve Yegge's single-axis ladder (from "Welcome to Gas Town" and The Pragmatic Engineer). It gives a single number measuring trust in a single agent. However, by early 2026, work has begun shifting from delegation to orchestration, and many skill combinations have gained importance and leverage when running many agents simultaneously. A single ladder cannot locate multi-agent capability.
Almost every debate about autonomy conflates two separate questions: how far we let a single agent stray, and how well we coordinate many agents. To capture these dimensions separately, the article proposes two axes: agent capability and orchestration capability .
Two Axes
On the agent capability axis, the low end includes proposing candidate actions and waiting for a decision . The mid range means the agent handles a specific task but scopes what it does and continuously reports what it did and the evidence, so you can keep steering. At the high end, the agent works toward a goal , experimenting, learning, testing, finding ways around blockers, asking questions, trying different paths, and returning all of it as evidence .
On the orchestration capability axis, low means one agent, one thread. Mid means multiple agents, each in its own worktree, possibly pursuing different goals but isolated from each other. High means an orchestrator that can take a backlog, issue tracker, schedule, or other queue and turn it into continuous work; you only intervene when things fail — "exception management." Products embodying these ideas include:
Claude Code's /plan, /goal, /loop, /background, /batch, /code-review, /security-review modes, sub-agents, hooks, checkpoints, agent delegation and management practices, background sessions, agent team modes, /schedule parameter.
Codex's local/cloud threads, Goal mode, worktrees, Automations, sub-agents, review panels, GitHub code review, hooks, sandboxes, Auto-review and re-run.
These capabilities cannot fit into a single ladder.
Climbing: Three Eras and a Single Stack
Reading the ladder bottom-up imagines climbing both axes simultaneously. In reality, the six levels represent three distinct eras we all traverse:
You sit in the driver's seat; agents mostly help and wait for you to steer.
Agents take on a bounded task or goal, but you still guide and verify.
In the orchestration era, the system can take the reins, dispatch work to many agents, and you mainly intervene when things go wrong — "exception management."
This simplifies things because vertical position on the ladder neatly captures both axes (orchestration only appears near the top), making it a single stable path up the rungs. Yet this climb is part of a transition we are all experiencing. A good engineering day touches multiple rungs, sometimes switching between eras several times in one task.
Six Levels in Detail
Level 0: Assist
The agent proposes mostly good, often perfect suggestions, but you always decide if they are good enough to act on. Think autocomplete, inline edit suggestions, or a chat discussion around a change no one has picked up yet. Suitable for costly mistakes, tiny changes, or when you are still forming your own judgment. Verification happens locally.
Level 1: Supervised Action
The agent edits or runs commands on your behalf, but asks before doing anything consequential. This is most people's default posture. It can happen in a local sandbox with approval before applying changes — each approval is an independent verification that the change is safe — or in an interactive session. The failure mode is approval fatigue; all approvals look the same regardless of what they approve. You might mitigate by squinting at diffs, following heuristics, getting a second pair of eyes, or simply agreeing to let the agent take over. Codex Auto-review solves this by delegating final approval of edge cases to a separate review agent.
Level 2: Scoped Task Delegation
Hand a bounded task to the agent. The task has a clear goal, constraints, and a definition of done. You stay nearby, can interrupt, but basically don't participate. This is the center of gravity in software engineering. Verification shifts from you (you need to sleep) to evidence the agent can produce: passing automated tests, correct types, lint suggestions, screenshots, reproduction steps, provenance from examples, etc.
Level 3: Goal-Driven Autonomy
The agent takes whatever actions are needed to achieve a goal, stopping only when a condition is met. In prompt mode, the prompt becomes the goal (e.g., "Can you get this page's TTI under 1 second?"). In Codex, this is Goal mode: the agent loops plan→act→test→review until success criteria are no longer met. In Claude Code, this is /goal, /loop, and /schedule commands. For this level to be useful, the stop condition must be measurable in an automated way.
Don't let agents chase vague, loose goals like "improve UX overall" or "make the codebase more testable." Pick specific, measurable, automatable goals: find production bugs static analysis misses, reduce load time, ensure strict TypeScript build with no explicit any, prune dependencies to only those we understand and that pass tests, etc. Finally, to find bugs in production, the agent needs to be in a production-like environment.
Level 4: Parallel Delegation
Let many agents work in parallel. Each handles an isolated slice of the task. The biggest bottleneck is decomposition: defining the right slices to delegate. Enabling capabilities include sub-agents, background sessions, /batch, worktrees, agent teams. The failure mode is fake parallelism: letting many agents work on overlapping slices, yielding not more output but merge conflicts and duplicate decisions. To do this well, agents need isolation — each with its own files and state — and each needs its own review queue. Every agent also incurs a cost in tokens proportional to the number running simultaneously. On the human side, orchestration tax makes the marginal cost of adding an agent rise after a few.
Level 5: Exception-Management Orchestration
Define what success looks like and which policies apply. A manager agent wakes on a trigger (new issue, new task, clock), dispatches worker agents, monitors progress, verifies output, retries on failure, escalates to more capable agents or humans when conditions are met, aggregates results, and finally returns work products (e.g., PRs) and evidence to the external system. Think of it as a factory: the issue tracker or backlog is input; the factory's output is fixed issues and bugs. Agents work in appropriately isolated, heavily walled environments (with escape hatches if needed), governed by a single operating system defined by the manager agent.
The design of this OS is left to humans; OpenAI proposed a spec for Symphony centered on a Linear board: every issue gets its own agent workspace, and the agent continuously ensures it is making progress toward the goal defined in the spec file in its workspace. Human review can happen at the height of evidence generation, but the frontier — the most powerful thing in the orchestration world — is building continuous agent factories with hundreds or thousands of agents. As you climb toward this, independent verification becomes critical: independent implementers and reviewers, independent test runners and QA, independent security checks, independent acceptance gates.
Risk and Reversibility Set the Ceiling
An early Anthropic study on Claude Code's hardest tasks showed it asked for clarification more than twice as often as users interrupted. Experienced users (~750 sessions vs. <50 for novices) were more likely to auto-approve and use interrupts to steer progress. They analyzed ~400k sessions from ~235k people (Oct 2025–Apr 2026), revealing humans make ~70% of planning decisions but Claude does ~80% of execution. High autonomy isn't about taking humans out of the loop; it's about shifting humans from executing every step to deciding which direction to go next.
To judge whether a large AI system runs with high autonomy, ask three questions:
How quickly can we discover we were wrong about what it's doing?
How cleanly can we undo what it's doing?
What proves we were right about what it's doing?
If the answers are "not quickly," "extremely difficult," and "trust the summary," it's not high autonomy.
Every agent run should be preceded by a contract defining what it attempts.
Goal: What outcome we want (not activity, not technical means, but result).
Scope: Domain of operation, allowed techniques.
Non-goals: What is explicitly out of scope.
Tools & Permissions: How the agent interoperates with the world.
Stop Condition: When to stop; ideally a measurable variable.
Evidence: Concrete tests, screenshots, logs, DB records, or other metrics (independent of the agent) to confirm completion.
Escalation: Who intervenes under what circumstances (including who runs the agent).
Budget: Time, effort, and token ceiling (tokens are the LLM budget — you can also include max attempts and max parallelism).
Metrics Make Autonomy Slightly More Reliable
Deciding metrics after the fact may not be enough. Metrics can be placed in a concise document upfront, making autonomy feel more reliable and the leap of confidence slightly easier. Consider tracking versions of these metrics for each autonomy level:
Mean time between interventions
Longest successful unattended run with accepted output
Percentage of actions run in sandbox vs. escalated
Auto-approve vs. reject action percentage
Mean agent actions per human instruction
Clarification request rate vs. interrupt request rate
Review time per accepted change
Rework rate by confidence tier
Defect escape rate by confidence tier
Token cost per accepted change
These metrics tell a story: a single agent kept busy by human handoffs is a Level 4 with a dashboard. A conservative agent that won't proceed without automated intake, retries, and decent evidence is a Level 5 with real gates.
Readiness Assessment
Categorize work by risk and ease of reversal. Apply autonomy conservatively, only rising when evidence supports a higher level. A payments-engine refactor protected by strong tests and review agents, with a clear rollback path, can support far higher autonomy than a documentation automation task with no spec ground truth. Autonomy level should follow the verification process, not the task name.
Four Anti-Patterns
Any system easily falls into these four autonomy anti-patterns if not vigilant:
Treating Autonomy as Status — Autonomy rating becomes a meaningless status badge. Higher autonomy is seen as proof of capability rather than safety, and agents run more aggressively than verification supports. Fix: Praise and reward those who pick the right autonomy level and resist overreach.
Permission Washing — Approval fatigue tyranny leads us to grant AI agents and tools far more access than necessary. Fix: Better boundaries are always the fix — sandbox configs, scoped writable roots, command allow-lists, hooks, Auto-review.
Summary Substitution — Replacing review with the agent's summary, assuming the summary is enough. Fix: Package the same evidence pack as a full human review (diffs, tests, logs, screenshots, reviewer findings, risks, gaps) while avoiding cognitive surrender.
Fleet Role-Play — Dozens of agents run in parallel, but humans still manually orchestrate every dependency. Fix: Shared state, ownership rules, and better dependency tracking gradually reduce manual coordination. Smaller WIP limits force focus on coding and recording coordination steps until orchestration automates.
Calibration Exercise
Review your last ten agent-assisted tasks. For each, note the autonomy level used, risk involved, ease of undo, evidence produced for verification, review time, whether rework was needed, and whether the same autonomy level would still be appropriate next time.
How to Climb Safely
Move up one axis at a time. Start with a single supervised agent completing a single scoped task with defensible success evidence (Level 1 if clean). Then expand in three orthogonal directions: parallelize read-heavy exploration (Level 4), add write agents on separate worktrees constrained by file ownership (Level 4), add periodic automation then issue-driven, voice-driven, agent-led orchestration. Each leverage step demands a new set of safety mechanisms (new failure modes).
Name them: longer single-agent runs risk drift, context rot, missed communication, goal drift. Background work risks stale assumptions and weak handoffs. Too much parallelism risks merge conflicts or duplicate decisions. Too much periodic work risks silent token burn or stale prompts. Exception management risks long review queues and alert fatigue. The fix isn't to trust harder; it's to narrow scope, ensure better evidence, enable cheaper rollback paths, harden gates, and define clearer ownership rules.
Using Autonomy Levels
Level 0: Best for fine-grained work and when judgment is still forming.
Level 1: Best for most exploration, provided work stays near well-understood boundaries.
Level 2: Best for most scoped tasks, knowing unknown dependencies and surprise traps may exist.
Level 3: Best when success conditions can be clearly articulated.
Level 4: Best when work can be cleanly split around those success conditions.
Level 5: Best when coordination and communication between success conditions are fully encoded.
Verification will always be the bottleneck.
Despite current hype and tooling, the mature posture of an engineering team collaborating with AI agents is calibrated autonomy .
The bottlenecks are coordination, verification, maintenance, product judgment, and incident learning.
In the near future we'll want loops that know when to work, when to verify, when to ask — but the engineer's skill remains picking the right autonomy level and building patterns and defensible evidence to guard against autonomy's dark corners.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
