Autonomy Is a Dial, Not a Ladder

Most teams treat autonomy like a ladder: start in a chat window, move up to a supervised agent, eventually “graduate” to something fully autonomous. Progress means climbing.

I’ve come to think that’s the wrong picture. Autonomy behaves more like a mixing board than a ladder — levels you set per task, not one fader pushed toward the top. Four positions are worth naming, and none outranks the others.

Four Positions, Not Four Stages

A chatbot has no hands: it gives you an answer, and you carry it into whatever system the model can’t reach. Fine for questions — nothing here can act without you.

Human-in-the-loop means someone stays present for the session — watching, reachable, able to step in — while routine steps clear without asking. That presence is the definition, not how many approval prompts you clicked. It’s also where you learn what the model is weak at — which files need pointing out, which instructions it over-follows.

An agentic workflow runs off a trigger — a cron schedule, a pull request, a filed issue — along a path someone designed in advance. The path is fixed; the reasoning inside each step isn’t — unlike a shell script on a timer. Claude Code’s GitHub Actions integration and OpenAI’s Codex both ship a runner built for this: a person sets the trigger and allowed tools, the runner disappears after each run, and the model underneath can be swapped without touching the workflow.

An autonomous agent decides its own next step with nobody watching in real time. It suits open-ended work — but only work you’re set up to check afterward, because when this mode fails, it tends to fail expensively, with no one around to catch it early.

What Doesn’t Transfer

The pull toward the far end is strong, partly because industry language treats “more autonomous” as automatically more impressive. Worth noticing: the people building these systems don’t say to default to it. Anthropic’s own engineering guidance (Building Effective Agents) is direct — find the simplest approach that works, and add complexity only once it earns its keep, because “this might mean not building agentic systems at all.” Andrew Ng has made a related point on X, arguing against defaulting to agentic architectures when a simpler pipeline would do. One of those two has every incentive to sell you on autonomy; the other has no stake in the answer at all — and they land in the same place.

Moving rightward, research and planning hand over easily, and most early implementation does too — that’s most of the value on offer. Verification is the piece that doesn’t transfer cleanly. At best, at the far end, it’s shared custody: the agent checks its own output, and a person still signs off before anything ships. That only happens if someone built the checking step on purpose. Skip it, and running unattended doesn’t buy you autonomy — it buys you a process nobody happens to be watching.

A Second Dial, Set Separately

There’s another dial, easy to confuse with the first: effort, meaning how hard a model works on a given turn. It’s a reasoning-depth setting, not a choice of model — Claude’s effort parameter controls it directly. Turn it up and the model spends more computation before committing to an answer; turn it down and you get something faster and shallower, out of the same model either way.

Raise it for multi-step reasoning, or an agentic run where an early wrong turn is costly to unwind — counterintuitively, more effort can lower the total bill, because it heads off wrong turns rather than speeding through more of them. Lower it for small, bounded work — a lookup, a format change — where the extra depth just sits there unused.

What effort doesn’t fix is worth being clear about, since it’s the mix-up I run into most. It doesn’t fix verbosity: a rambling answer at high effort is just a more careful ramble. And it doesn’t fix missing context — a model never told what it needed to know will think longer and still guess.

Model choice and effort aren’t substitutes; they compound. A cheap model thinking hard still has less judgment than a strong one. A strong model rushed through on low effort leaves most of what you paid for on the table.

Set both dials for the task in front of you, not once for the whole org. If a tool you rely on doesn’t expose the effort dial at all, that’s worth finding out before you need it, not after.