Who decides the next step
In the last lesson you learned to tell an assistant from an agent by asking what it can do without another prompt, and you saw that the harness holds a permission check between a tool request and the tool. This lesson puts that check on a scale. Agents with the same tools can be far apart on it, and one agent can move along it with a change of settings. By the end you can place any product or workflow on the scale by asking one question, and you can say what would move it one step up or down.
Three points on one scale
Section titled “Three points on one scale”The degree of autonomy of a workflow is how much the system may do before a person sees it. The scale has many points, and three of them are enough for most conversations.
- Suggests. The system proposes, and a person does every action. A drafted email that waits for you to press send, or a proposed code change that waits for you to accept it, sits here.
- Acts, and asks before anything hard to undo. The system takes the ordinary steps on its own and stops for approval at the steps that can’t be taken back. An agent that changes files in a folder by itself and asks before it runs a command that reaches outside the folder sits here.
- Runs unattended. The system finishes the whole task, and a person looks at the result afterwards, if at all. A job that runs overnight and posts its result to a channel sits here.
The points share one question, and it isn’t “how much did the model write”. It is “who decided the next step”. At the low end a person decides every step. In the middle the system decides most steps and a person decides the ones that matter most. At the high end the system decides every step [1].
Who decides the next step?
Section titled “Who decides the next step?”The amount of text a system produces tells you nothing about its autonomy. Autocomplete in a code editor can write a whole function from one comment. It is still at the low end, because nothing goes into the file until the programmer presses a key to accept it. A person decided every step. A small job that renames one file every night with no one watching is at the high end, because nobody decided anything after it was set up.
So when you place a workflow, ignore the size of the output and the name on the box. Follow one task from the prompt to the end, and at each step ask who chose it. The harness from the last lesson is where the answer is written down: the permission check either asks a person, or it lets the action through [2]. Count how often it asks, and at which steps, and you have the workflow’s place on the scale.
Where does each workflow sit?
Section titled “Where does each workflow sit?”The lesson gives a three-point autonomy scale: suggests (a person does every action), acts and asks before anything hard to undo, and runs unattended. The place on the scale comes from who decides the next step, never from how much text the system produces.
For each one, follow the task to its end. Who decided the steps along the way, and at which steps did a person get asked?
Where does the autocomplete sit?
Section titled “Where does the autocomplete sit?”The autonomy scale runs from suggests, through acts and asks before anything hard to undo, to runs unattended. The place comes from who decides the next step, and the amount of text produced says nothing about it.
An editor’s autocomplete writes a fifty-line function from a one-line comment. Where is that workflow on the autonomy scale?
After the function appears on screen, who decides whether it goes into the file?
One agent, three settings
Section titled “One agent, three settings”Autonomy is a setting chosen for a task, and the same product can sit on each of the three points in turn. Take a coding agent that runs in a programmer’s editor. Its vendor documents a set of permission modes, and the mode decides which actions the agent takes without asking [3]. Described in plain words:
- In its manual mode, the agent reads files and runs a few read-only commands on its own, and asks before every edit, every other command and anything that reaches the network. Every change waits for a yes. This is the low end of the scale.
- In its accept-edits mode, the agent edits, moves, copies and removes files inside the project folder by itself, and asks before any other command. It acts inside the folder, and it asks before the steps that reach past it. This is the middle.
- In its skip-all-checks mode, the agent runs nearly everything without a prompt. The vendor’s page says to use this mode only inside an isolated container or virtual machine, a place where a mistake can’t reach the rest of the computer. This is the high end.
The agent, the model and the tools are the same in all three, and the agent is at three places on the scale. One setting in the harness made the difference, so a product on its own can’t be placed. A product page that says “agent” describes a range, and the place on the scale is fixed only once someone picks the setting for a task [3].
Which setting fits a task depends on how costly a mistake is and how easily it can be undone. Edits in a folder under version control are cheap to undo, so a person can let the agent make them and read the result afterwards. A command that deletes files, sends a message or spends money is costly or impossible to take back, so the agent should stop there. Where both answers are “cheap and easy”, the high end is fine. Where either answer is “costly” or “hard”, pick a setting that asks before that step.
Which setting for this task?
Section titled “Which setting for this task?”A coding agent has three permission settings: manual (asks before every edit and nearly every command), accept-edits (edits, moves, copies and removes files in the project folder by itself and asks before any other command) and skip-all-checks (nearly no prompts, for use inside an isolated container only). The right setting depends on how costly a mistake is and how easily it can be undone.
A writer asks a coding agent to fix the spelling in forty documentation files that version control tracks, and then to run the command that publishes the site. She works on her own laptop. Which setting fits?
Which steps of this task are cheap to undo, and which one isn't?
Same product, one report
Section titled “Same product, one report”The autonomy scale runs from suggests, through acts and asks before anything hard to undo, to runs unattended. One agent product can sit at different points depending on its permission setting, because the setting decides which actions the harness lets through without asking.
Two teams use the same coding agent. One runs it in manual mode, and the other in a mode that skips every prompt inside a container. A colleague writes “this product is a low-autonomy tool” in a report about it. What is wrong with that line?
What is the report about: the product, or the product as each team runs it?
What moves a workflow a step
Section titled “What moves a workflow a step”Once a workflow has its place, ask what would move it. The answer is always a step where the decision changes hands, and naming it makes the design choice visible.
Take an agent that fixes a bug and opens a pull request for a person to review and merge. It acts, and a person approves the step that changes the shared code. Let the same agent merge the pull request itself, and it moves up a point: the change reaches everyone without a person seeing it first. If the same agent is changed to display the proposed change without touching any file, it moves down a point, to suggests.
The moves in the other examples work the same way. The mail assistant that drafts a reply moves up when it is given a send tool and permission to use it. The nightly job that closes duplicate tickets moves down when it is changed to list the duplicates for a person to close in the morning. In each case the tool list may not change at all. The change is which step a person decides, and that is a choice someone made, or left to the product’s default.
Which changes move it up?
Section titled “Which changes move it up?”A workflow moves up the autonomy scale when a step that a person decided is handed to the system, and down when a step the system decided is handed back to a person. The lesson's example is an agent that opens a pull request, which moves up if it also merges it.
An agent fixes bugs and opens a pull request for a person to review and merge. Which of these changes move the workflow up the scale?
For each change, ask whether a step a person used to decide now happens without them.
Which change moves it down?
Section titled “Which change moves it down?”A workflow moves down the autonomy scale when a step the system decided is handed back to a person, and up when a step a person decided is handed to the system. The tool list may stay the same.
A nightly job reads the support inbox and closes the tickets it judges to be duplicates. Which change moves it one step down the scale?
Which change puts a person back in front of a step the job used to take on its own?
Exercise
Pick one coding agent, either the one from this lesson or one your team uses. Read the vendor’s page on its permission settings. For three of the settings, write one line each in a note: the name of the setting, which of the three points on the scale it lands on, and the one sentence that explains why (who decides which step). Then, for each line, add what would move that setting’s workflow one step up and one step down. Fifteen minutes is enough.
In a good result, each placement names a step and who decides it. “The agent edits by itself and asks before a command” is a placement, and “it is pretty autonomous” isn’t. Each move names a step that changes hands, such as “let it merge” or “make it show the change instead of writing it”. If two of your three settings landed on the same point, say what still separates them, because the scale has more points than the three named here.
Stretch: Do the same for one agent product you use that isn't a coding agent, such as a mail assistant or a meeting notetaker. Find its permission settings on the settings screen, and write down which of the three points each setting lands on.
Recap
- The degree of autonomy of a workflow is how much the system may do before a person sees it. Three points cover most conversations: suggests, acts and asks before anything hard to undo, and runs unattended [1].
- Place a workflow by asking who decides the next step, never by how much text the system produces. Autocomplete that writes a whole function is low autonomy, because a person accepts each suggestion.
- Autonomy is a setting chosen for a task. One coding agent lands on three different points in three permission modes, and the choice depends on how costly a mistake is and how easily it can be undone [3].
- To move a workflow one step, change which step a person decides. An agent that merges its own pull request has moved up. An agent that shows a change instead of writing it has moved down.
- The safety course’s human in the loop section picks the steps that need a person, and the using-agents course’s choosing autonomy section applies the same scale to a task you delegate.
You can now
- Places a product or workflow on the autonomy scale
References
Section titled “References”- DeepLearning.AI. Agentic AI: M1 workflows and autonomy, M2 reflection, M4 evals and error analysis, M5 autonomous agents. DeepLearning.AI. Course.
DLAI-11 - Addy Osmani, Ivar Soares Urdalen, Leo Simons. What are AI agents: model versus agent, autonomy levels, when a prompt suffices. Agent Engineer Course. Course.
AEC-01 - Anthropic. Choose a permission mode. Claude Code documentation. Reference.
Claude Code permission modes