# Who decides the next step

> Place a product or workflow on the autonomy scale by asking who decides the next step, see one coding agent land on three points in three permission settings, and name the step that moves a workflow up or down.

Page: https://schubergphilis.github.io/ai-training/concepts/autonomy-scale/
License: CC BY-SA 4.0, https://creativecommons.org/licenses/by-sa/4.0/

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

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 (Agentic AI: M1 workflows and autonomy, M2 reflection, M4 evals and error analysis, M5 autonomous agents, DeepLearning.AI).

## 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 (What are AI agents: model versus agent, autonomy levels, when a prompt suffices, Agent Engineer Course). Count how often it asks, and at which
steps, and you have the workflow's place on the scale.

#### Checkpoint: Where does each workflow sit?

Buckets:

- Suggests
- Acts, asks before the hard-to-undo step
- Runs unattended

Items:

- Autocomplete in an editor writes a whole function, and the programmer presses a key to accept it
- A mail assistant drafts a reply and waits for you to press send
- A coding agent changes files in the project folder on its own and stops to ask before it sends anything to a shared server
- A travel agent app fills in the booking for the flights it finds, and asks you before it pays
- A nightly job reads the support inbox, files each ticket under a category and closes the duplicates
- A research agent searches, reads and writes a report while you sleep, and you read it in the morning

## 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
(Choose a permission mode, Claude Code documentation). 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 (Choose a permission mode, Claude Code documentation).

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.

#### Checkpoint: Which setting for this task?

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?

- Manual, so that she approves each of the many small edits by hand.
- Accept-edits, so the edits run on their own and the agent asks before the publish command.
- Skip-all-checks, because the edits are tracked and the publish command is routine.

## 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.

#### Checkpoint: Which changes move it up?

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?

Select exactly 2.

- The agent merges the pull request itself once the checks pass.
- The agent is given a faster model so the fix arrives in half the time.
- The agent also deploys the merged change to production without a prompt.
- The agent writes a longer description in the pull request.

#### Pitfall: The default nobody looked at

A team lead installs a coding agent for her team and tells everyone it
asks before it changes anything, because that is what she remembers from
a demo a few months back. Nobody checks. On the plan the team is on, the
vendor's built-in starting mode isn't the one she remembers from the
demo. A fresh session starts in a mode where a second model approves
actions instead of the person at the keyboard (Choose a permission mode, Claude Code documentation).
A week later a colleague finds that a run has rewritten files she meant
to review first. Nothing went wrong that couldn't be undone, but the
team had placed the product on the scale from memory, and the setting
was another one. The setting decides the place, so the first thing to read
when you install an agent, and again after each big update, is which
mode it starts in.

## 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

1. 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 (Agentic AI: M1 workflows and autonomy, M2 reflection, M4 evals and error analysis, M5 autonomous agents, DeepLearning.AI).
2. 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.
3. 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
   (Choose a permission mode, Claude Code documentation).
4. 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.
5. The safety course's [human in the loop](https://schubergphilis.github.io/ai-training/safety/agent-risk/#human-in-the-loop)
   section picks the steps that need a person, and the using-agents
   course's [choosing autonomy](https://schubergphilis.github.io/ai-training/using-agents/delegating/#choosing-autonomy)
   section applies the same scale to a task you delegate.

## References

- Agentic AI: M1 workflows and autonomy, M2 reflection, M4 evals and error analysis, M5 autonomous agents, DeepLearning.AI, https://www.deeplearning.ai/courses/agentic-ai
- What are AI agents: model versus agent, autonomy levels, when a prompt suffices, Agent Engineer Course, https://lsimons.github.io/agent-engineer-course/01-what-are-ai-agents/
- Choose a permission mode, Claude Code documentation, https://code.claude.com/docs/en/permission-modes