"Autonomous" is the most oversold word in developer tooling right now. It's stamped on autocomplete, on chat assistants, on agents that need approval for every file write, and on systems that run for an hour untouched — as if those were the same thing. They aren't, and the confusion costs real money when a team buys "autonomous" and discovers it means "watches you type." The car industry solved a version of this problem in 2014 with the SAE levels of driving automation: a shared 0-to-5 scale that made "self-driving" a precise claim instead of a marketing adjective. Coding agents need the same discipline. This is that scale — a way to place any tool, from Copilot to Cursor to Devin, on a rung you can actually reason about.
The scale is deliberately vendor-neutral until the last section. If you only want the framework, you can stop before you get to us.
The two things people conflate
Before the levels, one distinction that the word "autonomous" hides. Two different things can run without you, and tools mix them freely:
Execution autonomy is how much of the doing happens unattended. At the low end you approve every keystroke; at the high end the agent writes, compiles, tests, and fixes its own errors while you're in another meeting.
Task selection is whether the agent decides what to work on. Almost every tool on the market leaves this entirely to you — it acts only on the task you handed it. A small number read a backlog and pick.
These are independent. A tool can be highly autonomous at execution and have zero selection autonomy — that's Copilot's coding agent, which will run a whole ticket untouched but never chooses which ticket. The SAE analogy holds because driving has the same split: staying in a lane (execution) is a different capability from deciding the destination (selection). Most of the "is this really autonomous" arguments are two people each measuring a different axis.
The levels
Here's the scale. Each level is defined by what the human still has to do, because that's the only definition that matters when you're the human.
Level 0 — Autocomplete. The agent suggests the next tokens; you accept or reject each one. It has no memory of a task, no plan, and no ability to act across files. You are doing 100% of the work; it's making the typing faster. Classic Copilot autocomplete and every inline suggestion tool lives here. Calling this autonomous is like calling cruise control self-driving.
Level 1 — Assisted / chat. You ask, it answers. The agent generates a snippet, explains an error, or drafts a function on request, but you copy the output into place and you drive every step. It's reactive: no action happens without a prompt, and the prompt is one turn. The unit of work is a question.
Level 2 — Supervised in-editor agent. The agent takes a task and executes multiple steps — edits several files, runs a command, reads the error, tries again — but you're watching in real time and approving as it goes. This is agent mode in Copilot, Cursor, and Cline. The execution autonomy jumps here: it's genuinely doing multi-step work. But it's supervised by construction. Look away for ten minutes and it's either done or stuck waiting for you. Selection autonomy is still zero — you picked the task and you're in the loop for every meaningful decision.
Level 3 — Unattended task. You hand over one scoped task and walk away. The agent works in a sandbox for minutes to an hour, writes the code, runs the tests, and returns a draft pull request you review. You are not in the loop during execution — that's the real line between Level 2 and Level 3. But you still chose the task, scoped it, and dispatched it, and you're the gate before anything merges. This is where Copilot's coding agent, Devin, and Sweep operate. Most tools marketed as "autonomous" mean exactly this: unattended execution of a task you selected.
Level 4 — Unattended selection and execution. The agent reads your backlog, chooses what to work on against rules you set, and ships PRs — the selection loop is automated, not just the execution. A human still reviews and merges, and the agent's domain is bounded (it works your tracker, not your whole job). The difference from Level 3 is the one that touches your backlog: nobody dispatches each ticket. This is a small category, and it's where the "drowning in backlog" problem actually gets solved, because the bottleneck at scale is dispatch, not typing.
Level 5 — Full autonomy. The agent picks work, writes it, reviews it, merges it, and deploys it with no human gate anywhere. Nobody ships this responsibly today, and the honest vendors say so. The reason isn't model capability — it's that code review is a trust boundary, and removing the human from it removes the thing that catches the confident, wrong PR. Treat any Level 5 claim as marketing until proven otherwise.
Where the tools actually sit
Map the market onto the scale and the marketing noise resolves into something you can shop against. Most tools span a range because they bundle features from several levels.
| Tool | Levels it covers | What it automates |
|---|---|---|
| Copilot autocomplete | L0 | Typing |
| Copilot / Cursor chat | L1 | Answering |
| Copilot / Cursor / Cline agent mode | L2 | Supervised multi-step editing |
| Copilot coding agent | L3 | Unattended execution of an assigned issue |
| Devin | L2–L3 | Prompt-driven task, unattended per task |
| Sweep | L3–L4 | Issue-to-PR, some backlog selection |
| Codowave | L3–L4 | Backlog selection + unattended ticket-to-PR |
The single most useful thing this table tells you: "Copilot" and "Cursor" aren't points on the scale, they're ranges. Copilot covers L0 through L3 depending on which feature you're using. When someone says their team "uses Copilot," that sentence is compatible with four different levels of autonomy, which is exactly why the word alone tells you nothing.
What still needs a human at every level
The honest part. No level on this scale removes the human from the two places that matter most, and the good tools are explicit about it.
Every level below 5 keeps a human at the merge gate. The PR is the artifact, and review is where a person catches the change that passes all the tests and still does the wrong thing. An agent that runs your suite proves the code does what the code does — not what the ticket meant. That gap is a judgment call, and judgment is the thing we're not automating away, at any level.
And every level requires a human to define the work well. A Level 4 agent that picks its own tickets is only as good as the filters and the issue quality you give it. "Autonomous" never meant "reads your mind." It meant "doesn't need you standing over it for the parts that don't need judgment." The parts that need judgment — what to build, whether it's right — stay yours.
Autonomy is a measure of how much of the work doesn't need judgment. It is never a claim that judgment stopped mattering.
Where we put Codowave, and how to use the scale
We build Codowave, and on this scale it's a Level 3–4 agent: it reads your tracker (GitHub Issues, Jira, Linear, Trello), selects work against filters you set, runs each task unattended in an isolated container, and opens a PR for review — with a watch-only default that earns auto-merge as you build trust. We put it there deliberately. We don't claim Level 5, because the merge gate is a feature, not a limitation, and we designed the graduated-trust ramp around keeping a human on it until you decide otherwise.
The reason to care about the scale isn't to rank tools — it's to match a level to your bottleneck. If your team is slow at typing, buy Level 2 and stop. If your bottleneck is a backlog nobody has picked up, no amount of Level 2 will help, because you don't have an execution problem, you have a selection problem — and only Level 4 touches it. The mistake that wastes budget is buying a higher level of the wrong axis. Place your bottleneck on the scale first. Then place the tools. Buy where they line up.