Levels of Autonomy
Every team adopting AI agents wants the same thing: more of the work done without more risk. The hard part is knowing how far that has actually gone. Levels of autonomy give that progress a name. They describe a ladder, from a tool that only suggests the next line to an agent that takes an entire task from intent to result on its own, so a team can say where it really stands instead of guessing.
Overview
The scale is borrowed from self-driving cars, where driving automation runs from level 0, a fully manual car, to level 5, one that needs no driver at all. In 2026 Dan Shapiro mapped the same idea onto software development, and the analogy stuck because it captures something teams feel but struggle to articulate: adding AI to your workflow is not one step, it is a climb, and each rung changes who does what.
The levels matter because they separate the feeling of progress from the fact of it. A team can ship more code per engineer than ever and still find that major launches take just as long, because the work moved but the bottleneck did not. The ladder explains why. At the lower rungs the agent assists and the human authors; in the middle the agent writes and the human reviews every diff; near the top the human writes a spec and the agent builds against it. Naming the rung you are on, and the one you are reaching for, is the first step to moving.
How it works
Levels of autonomy describe a climb, not a switch. Four things are worth holding in your head as you read the ladder:
A scale borrowed from self-driving
The model maps onto the levels of driving automation, the same 0-to-5 ladder used for cars. Dan Shapiro adapted it to software in 2026: from manual coding, to AI pairing, to a human reviewing every diff, to writing a spec and letting agents build. It gives teams a shared vocabulary for where they actually stand.
The human's role moves up the stack
Climbing a level does not just mean the agent types more. It changes the person's job: from author, to reviewer of every line, to writer of specs and policies who checks outcomes. Higher autonomy means the human governs intent instead of operating each step.
Autonomy is set per workflow, not globally
A team is rarely at one level for everything. A low-risk changelog update can run near-unsupervised while a payment migration stays under line-by-line review. The right level is tuned to the risk and reversibility of each task, which is where guardrails and human-in-the-loop come in.
Climbing takes more than a better model
Most teams stall at level 3, reviewing every diff, because trust does not compound, verification does not scale, and specs are not load-bearing. Reaching a durable level 4 requires compounding memory, verification that runs faster than generation, encoded governance, and auditable logs.
Example in practice
A team has been running agents for six months and feels stuck at level 3: agents generate most of the code, and every engineer's day is spent reading diffs. Rather than try to raise autonomy everywhere at once, they pick one workflow. Changelog updates are low-risk and easy to reverse, so they let an agent draft, verify, and open the change with only after-the-fact review, operating that workflow at level 4. A database migration is high-risk and hard to undo, so it stays at level 3, with a senior engineer approving the plan and reviewing every line. Same team, same agents, two different levels, each chosen to fit the stakes of the task rather than a blanket policy.
What is Levels of Autonomy?
Levels of autonomy are a maturity scale describing how much an AI agent decides and executes on its own versus how much a human directs and reviews, running from tools that only assist to agents that take an entire task from intent to result with little supervision.
Comparison: Levels of autonomy vs. the Human-in-the-loop
The two are not rivals. Levels of autonomy describe the maturity a workflow is reaching for; human-in-the-loop is how you operate that level safely, by keeping a person at the decisions that carry risk.
Climb past level three
Overcut gives agents the memory, verification, governance, and audit trails it takes to raise autonomy on a workflow without losing control of it.
Get a demoRelated content
Build vs Buy Your SDLC Orchestration Layer: The Legacy Clock Starts at Commit One
Why homegrown AI orchestration becomes legacy infrastructure from the first commit, and why your engineering attention belongs on the product instead.
Agentic SDLC Orchestration vs. Synchronization
Why centralized workflow engines fail AI-driven engineering teams, and how modular SDLC orchestration enables agent autonomy and event-driven agility.
The Plateau at Level Three
Why most AI-native teams stall at level 3 of agentic development, what it takes to climb to level 4, and where the road leads after that.