What it is
Autonomy levels describe how much an AI agent is allowed to do on its own before a person has to say yes. At one end, the AI only makes suggestions and you do everything. At the other end, it decides and acts by itself, and you might only find out afterwards. Most useful setups sit somewhere in between, and the skill is choosing where.
The idea is older than AI chatbots by decades. In 1978, Thomas Sheridan and William Verplank, studying how people control remote machines working under the sea, set out a ten-step scale. At step one the computer offers no help and the human does everything. In the middle the computer narrows the options, suggests one, then carries it out only if the human approves. Higher up, it gives the human a short window to veto before acting, then acts and tells the human afterwards, then tells them only if asked. At step ten it decides everything, acts on its own and ignores the human. Nearly every later scale, including the ones used for AI agents today, is a simplified version of that ladder.
For everyday use, five rungs are enough. Picture an assistant that handles your customer emails:
- Suggest only. The AI tells you what it would do ("this customer probably wants a refund; here are the options"), and you do the work yourself.
- Draft for approval. The AI prepares the actual thing, such as a written reply, and you edit it and press send.
- Act with approval. The AI is ready to act and asks first: "Send this reply and issue a £12 refund? Yes or no." One click from you and it happens.
- Act and report. The AI acts straight away and tells you what it did, so you can review it and undo it if needed.
- Act alone within limits. The AI acts without asking or reporting each step, inside boundaries you set in advance, such as "refunds under £20 only" or "only reply to delivery questions". You check a log now and then.
Two points make this more useful than it first looks.
First, autonomy is a choice, not a feature of the model. A very capable AI can be set to run at a low level, and a simple one can be let loose at a high level. In a paper published by the Knight First Amendment Institute at Columbia University on 28 July 2025, the University of Washington researchers Kevin Feng, David McDonald and Amy Zhang argue exactly this: that an agent's autonomy can be a deliberate design decision, separate from what it is capable of. They describe five levels by the role the person plays: operator, collaborator, consultant, approver and, at the top, observer, where the person can only watch the activity log or hit an emergency off-switch.
Second, the level belongs to each action, not to the whole agent. The same assistant can be at rung 5 for filing emails into folders, rung 3 for refunds and rung 1 for anything involving a legal complaint. Asking "how autonomous is my agent?" is the wrong question. Asking "how autonomous should it be for this particular action?" is the right one.
You'll see these settings in real products under names like permissions, approval modes, confirmations and safe mode. They're covered in the examples below.
Why it matters
Risk rises with every rung. A wrong suggestion costs you a few seconds of reading. A wrong action can cost money, data or a relationship. In February 2025, the Hugging Face researchers Margaret Mitchell, Avijit Ghosh, Alexandra Sasha Luccioni and Giada Pistilli published a paper titled "Fully Autonomous AI Agents Should Not be Developed". Their analysis found that risks to people increase with the autonomy of a system: the more control a person hands to an agent, the more can go wrong. They concluded that semi-autonomous systems, which keep some human control, offer a better balance of benefit and risk. You don't have to accept their headline to take the practical point: every step up the ladder should be earned by a reason.
The failures happen when the level doesn't match the stakes. Two well-known agent incidents, covered in more detail elsewhere on this table, both come down to this. In July 2025 an AI agent on the app-building site Replit deleted a live company database during a declared code freeze (see Coding Agents). In February 2026 an OpenClaw agent began deleting a Meta researcher's email after losing her instruction to wait for approval (see Function Calling). In both cases, a destructive, hard-to-undo action ran at a level where no one had to click yes first. The person had asked for a low level in words, but the software was set to a high one.
Too little autonomy fails too, just more quietly. If an agent asks permission for every tiny step, you'll soon approve everything without reading, which is known as rubber-stamping. At that point you have the slowness of a low level and the risk of a high one. Human in the Loop describes the research behind this, including the Uber self-driving test car in Tempe, Arizona, whose safety driver was expected to watch for hours and step in within seconds. Choosing autonomy levels well means asking for approval rarely enough that each request gets real attention.
Three questions set the level. For any action, ask:
- Can it be undone? Filing an email can be reversed in a click. Sending one can't. Deleting data without a backup can't. The harder it is to reverse, the lower the rung.
- What does a mistake cost? A typo in an internal note costs nothing. A wrong refund, a double booking or a public post with a false claim costs money or reputation. The higher the cost, the lower the rung.
- Who else is affected? An action that only touches your own drafts is your business. One that reaches a customer, a colleague, a supplier or the public affects people who never agreed to your experiment. The more people it reaches, the lower the rung.
Trust should be earned, and it can be lost. Nobody hands a new employee the company credit card on day one. They start by drafting, then act with sign-off, then act and report, and only after a track record do they act alone within limits. Agents deserve the same treatment. Start low, keep a simple record of how often the agent's proposals were right, and raise the level for one kind of action at a time when the record supports it. If something goes wrong, drop it back down. This is how the ladder becomes a tool rather than a one-off setting.
Settings beat instructions. "Always ask me before deleting anything" typed into a chat is a request the AI might forget, misread or lose when a long conversation is summarised. A permission setting in the software is a rule it cannot skip. Wherever a tool lets you set the level in its settings, do that, and use your written instructions as a backup, not the main control. Guardrails covers the wider family of controls.
Real-world examples
Driving automation levels, and the gap between a name and a level (2014 to 2026)
The best-known autonomy ladder is for cars. In January 2014, SAE International, the standards body for the vehicle industry, published a document called J3016 that defines six levels of driving automation, from Level 0 (no automation) to Level 5 (full automation). It has been revised several times since, most recently in April 2021. The key line in it falls between Level 2 and Level 3. At Levels 0 to 2, the features only support the driver, and the person is still driving even with their feet off the pedals and hands barely on the wheel: they must supervise constantly and steer, brake or accelerate whenever needed. At Level 3, the system drives in certain conditions, but the person must take over when it asks. At Levels 4 and 5, the system will not need the person to take over at all.
That line maps directly onto AI agents. Levels 0 to 2 are like rungs 1 to 3 of the ladder above: the human stays responsible for every outcome. Level 3 is like "act and report", with the human expected to catch the handover. Levels 4 and 5 are "act alone within limits" and beyond.
The trouble starts when a product's name suggests a higher level than its real one. Tesla sold driver-assistance features under the names "Autopilot" and "Full Self-Driving". On 12 December 2023, Tesla filed a safety recall with the US National Highway Traffic Safety Administration (NHTSA) covering 2,031,220 vehicles in the United States. The recall report itself describes Autosteer as an SAE Level 2 feature, one where the driver remains the operator, responsible for the vehicle with hands on the wheel at all times. It stated that the prominence and scope of the feature's controls may not be sufficient to prevent driver misuse. The fix was a software update that added more prominent alerts and extra checks, and could suspend Autosteer for drivers who repeatedly failed to stay engaged.
In April 2024, Tesla renamed its Full Self-Driving software "Full Self-Driving (Supervised)". Then, on 16 December 2025, the California Department of Motor Vehicles adopted a judge's decision that Tesla's use of "Autopilot" and "Full Self-Driving Capability" in its marketing was misleading, because the cars could not, then or now, operate as autonomous vehicles. The DMV stayed a threatened licence suspension and gave Tesla 60 days to deal with the "Autopilot" wording. In February 2026 it announced that Tesla had stopped using the term in its California marketing.
The lesson for anyone setting up an AI agent is simple. The level that matters is the one in the settings, not the one in the name. A tool marketed as "autonomous" or "hands-free" may still expect you to supervise every step, and if you don't, the responsibility is still yours.
Coding tools put the ladder in a settings menu (April 2025 onwards)
AI coding tools were among the first everyday software to make autonomy levels a visible setting. On 16 April 2025, OpenAI released Codex CLI, an open-source coding agent that runs in a computer's terminal (the text window programmers type commands into). Its launch documentation offered three approval modes. In Suggest, the default, the agent could read any file in the project but needed approval for every change to a file and every command. In Auto Edit, it could change files by itself but still needed approval for every command. In Full Auto, it could read, write and run commands without asking, but every command ran with the internet switched off and confined to the project folder. The tool also warned you if you started one of the more autonomous modes in a folder that wasn't backed up with version control, a system that keeps a history of every change so it can be undone.
That design is a neat picture of this whole article. Three rungs on the ladder. The riskiest rung only allowed inside a fenced area, with a check that an undo button exists before you climb.
Other tools followed similar patterns. At the time of writing, Anthropic's Claude Code, for example, has a default mode that asks before each new kind of action, a mode that accepts file edits automatically, a plan mode in which the agent explores and proposes but doesn't change your files, and a mode that skips permission prompts. Its documentation says to use that last one only in isolated environments, such as a container or virtual machine, where it can't cause damage. It also notes that its permission rules are enforced by the software, not by the model, and that instructions in a prompt shape what the AI tries to do but don't change what the tool allows. That is the "settings beat instructions" point, written into the manual. Mode names and details change often, so check your own tool's current documentation.
The browser and computer-using agents covered in Browser Agents and Computer Use use the same idea in a different form: they are typically designed to pause and ask before purchases, sending messages or entering sensitive information.
An everyday case: the bookkeeping assistant that earns its promotion
Here is an illustrative scenario, not a real company. Priya runs a small design studio and connects an AI agent to her accounting software and inbox to help with bills.
In month one she sets everything to rung 2: the agent drafts, she does. It reads incoming invoices, drafts entries in the accounts and drafts payment runs, and she reviews all of them. She keeps a tally. Of 60 invoice entries, 58 are right; the two mistakes are the same supplier who uses an odd invoice layout.
In month two she moves invoice entry to rung 4, act and report. The agent enters invoices itself and sends her a daily summary. She fixes the problem supplier by giving the agent an example of their layout. Payments stay at rung 3: the agent prepares the payment run and she approves it with one click, because a payment to the wrong account is costly and hard to reverse.
In month three she moves routine filing and receipt matching to rung 5, act alone within limits, and checks five random entries every Friday. Payments stay at rung 3 for good, and anything above £2,000 needs her to approve it in the banking app itself, not just in the agent. Chasing overdue clients stays at rung 2, because a badly worded chaser can cost her a client relationship.
Nothing about the AI changed over those three months. What changed was the evidence she had, and each level now matches what the action risks.
Try it yourself
You need 30 minutes, a pen or a spreadsheet, and any AI chatbot for the optional prompts. Pick three tasks you might hand to an AI agent, ideally one small, one medium and one that makes you nervous. For example: sorting your inbox into folders, replying to customer questions, and paying supplier invoices.
- Write down the three tasks, one per row, and describe the action in a sentence ("move newsletters to a Reading folder", "reply to questions about delivery times", "pay approved invoices from the business account").
- Score each task on four questions, giving 0, 1 or 2 points each. Reversible? Undone in a click is 0, undone with effort is 1, can't be undone is 2. Costly? A mistake that costs nothing is 0, some time or a small sum is 1, real money, legal trouble or reputation is 2. Affects others? Only you is 0, people you know well is 1, customers, the public or anyone's rights is 2. Track record? Checked on this exact task 50 or more times with no serious error is 0, checked a handful of times is 1, never checked is 2.
- Add up each row and choose a starting rung. As a rough guide, 0 to 1 points: act alone within limits. 2 to 3: act and report. 4 to 5: act with approval. 6 to 7: draft for approval. 8: suggest only. If "Reversible?" scores 2, never go above act with approval, whatever the total.
- Write the limits for any task at rung 4 or 5. Be specific: a money cap, a list of allowed recipients, times of day, folders it may touch. Limits are what make higher rungs safe.
- Find the matching setting in your tool. Look for words like permissions, approvals, confirmations or modes. If the tool has no setting for the rung you chose, use a lower rung. Don't rely on typing the rule into the chat.
- Set a review date. In two or four weeks, look at the track record and decide whether each task moves up a rung, stays or moves down.
A prompt to help you score your tasks:
I'm deciding how much independence to give an AI agent. For each task
below, score it 0, 1 or 2 on four questions: Can it be undone (0 = easily,
2 = not at all)? What does a mistake cost (0 = nothing, 2 = real money,
legal trouble or reputation)? Who else is affected (0 = only me,
2 = customers or the public)? How proven is the AI on this task
(0 = checked many times, 2 = never checked)? Show the scores in a table
with a one-line reason for each, then suggest one of these levels:
suggest only, draft for approval, act with approval, act and report,
act alone within limits. Ask me if you need details you don't have.
Tasks:
1. [task one]
2. [task two]
3. [task three]
A prompt to write the limits for a higher rung:
I'm letting an AI agent do this task with limited independence:
[describe the task and the level you chose].
Suggest five specific, checkable limits that would keep a mistake small,
such as money caps, allowed recipients, allowed folders or times.
Then list the three warning signs that should make me move it back to
a lower level.
Treat the answers as a first draft. The scores depend on your business, and you know it better than the chatbot does.
Common mistakes and misunderstandings
Setting one level for the whole agent. "My agent is fully autonomous" or "my agent always asks" is too coarse. Set the level per action: high for low-stakes, reversible jobs, low for anything costly, permanent or public.
Trusting the product name. Words like "autopilot", "autonomous" and "hands-free" are marketing. What counts is what the settings actually allow and what the terms say you are responsible for. The Tesla case shows how far those can drift apart.
Putting the level in the prompt instead of the settings. A typed instruction can be lost, especially in long sessions. Use the tool's permission settings, spending limits and access controls, and treat the prompt as a reminder.
Starting high and planning to dial down later. The first serious mistake may be the one you can't undo. Start low, collect a track record, then climb. It's much cheaper to relax a cautious setup than to recover from a bold one.
Climbing because it's tiresome to approve. Approval fatigue is real, but the fix is to approve fewer, more important things, not to switch approvals off across the board. Move the boring, safe actions up a rung and keep the risky ones where they are.
Forgetting that "act and report" needs someone to read the reports. Rung 4 only works if a person looks at what was done soon enough to undo it. If nobody reads the daily summary, you're really at rung 5 without the limits. Observability covers how to make agent activity easy to review.
No off-switch. Every rung above "suggest only" needs a way to pause or disconnect the agent that you've actually tested. At the highest rungs, this is often the only control left.
Thinking higher autonomy means a smarter AI. Capability and autonomy are separate. A strong model at a low level is often more useful than a weaker one at a high level, because you get its best ideas without its worst actions.
Setting it once and forgetting it. Tools update, tasks grow and your business changes. Revisit the levels whenever the tool, the task or the stakes change, and after any mistake.
Related elements
- Agent: the AI systems whose independence these levels describe.
- Human in the Loop: where the person sits at each level, and why human review can fail.
- Guardrails: the automatic limits that make the higher levels safer.
- Coding Agents: the field where permission modes became everyday settings, and the Replit database case.
- Function Calling: how an AI triggers real actions, and the OpenClaw inbox case.
- Browser Agents: agents that pause before purchases and messages on the web.
- Computer Use: agents that operate a whole computer, where the level you choose matters most.
- Observability: the logs and summaries that make "act and report" work.
- Triggers: what starts an agent without a person asking, which raises its effective autonomy.
- Scheduled Tasks: jobs that run on a timetable while nobody is watching.
- Evals: testing an agent's track record before you give it more independence.
- Alignment: why the more an AI does on its own, the more it matters that it wants what you want.