Essays • AI and engineering • • 5 min read

Agent Mode vs Autonomous Mode: The Difference Is Who Closes the Loop

Agent mode and autonomous mode get used interchangeably. The difference is who closes the loop, you after every task, or the system, running many steps before anyone looks.

Two matching steering-wheel control panels on a bench, labeled Agent Mode and Autonomous Mode, a hand gripping only the first

Agent mode and autonomous mode get used as if they were synonyms. The difference matters more every month, because it decides how much of your system you are actually supervising.

In agent mode, you close the loop. In autonomous mode, the system does.

Agent mode, directed and verified by you

Agent mode is when you give an AI real access to your codebase and direct it through tasks, read the repo, make the change, run the tests, report back. The agent does the work and you do the judgment. Every task ends at your desk. You read the diff, you approve or reject, and nothing ships that you did not see.

I wrote the full definition in What Is Agent Mode? The key property is that the human is inside the loop at task granularity. The agent's autonomy lasts exactly one assignment.

Autonomous mode, started by a schedule or a condition, supervised differently

Autonomous mode removes your hand from the individual step. The agent plans, acts, checks its own work and repeats until the task is done or it gets stuck. You may have started it a minute ago on a branch, or a trigger, a schedule or a condition started it, the nightly job that triages new issues, the pipeline that retries and self-heals, the agent that watches a queue and acts on what arrives. You still set the boundaries, you just do not approve each action, because you are not there when it happens.

The full definition lives in What Is Autonomous Mode? The key property is that verification moves from each task to the boundary. You review the rules, the limits and what came out, instead of each act.

It is a dial, not a switch

In practice the two are ends of a dial, and the dial is labeled trust. Work I cannot yet predict gets agent mode: I direct, I read closely. Work the agents have done correctly fifty times starts earning slack. First I stop watching it run and just read the result. Then the result only comes to me when something is unusual. Somewhere along that slope the work has quietly crossed into autonomous mode, and the engineering question is whether you noticed the crossing.

Autonomy by erosion is the failure mode to respect. You do not decide to stop supervising, the supervision just thins. The fix is to make the crossing explicit. When a task graduates from agent mode to autonomous mode, that should be a decision with a date on it, the way a deploy is, with the boundaries written down, what it may touch, what it must never touch, what gets escalated.

When to use which

Agent mode is for anything novel, anything touching production state, anything where the cost of a confident wrong answer is high, and anything you have not watched succeed repeatedly. Which, when you are starting, is everything.

Autonomous mode is for work that is frequent and reversible and boring, triage, formatting, dependency bumps, report generation, the rebuild that runs every night whether you watch it or not. Frequent earns the trust, reversible caps the damage, and boring is what makes supervising each task a waste of a human.

It is not only about trust

Trust is the main axis, and the dial also turns on constraints, on cost and on plain utility, so a choice read as risk alone misses those. Sometimes the environment decides for you, a locked-down setup, a policy, no network, and the choice is made before you make it. Sometimes it is cost, because an autonomous loop left running can burn through tokens and compute that a few surgical passes would not, or the reverse. And often it is just utility, which way of working gets this particular job done with the least friction. The answer to "agent or autonomous" is often "it depends," and the things it depends on are worth naming.

You also do not have to pick one for the whole day. I routinely run both at once: an agent grinding autonomously on a throwaway branch while I work surgically beside it on the part I actually care about. The detail that dissolves the question almost entirely is that the same tool does both. Claude Code has a permission mode you can flip. Leave it asking before each step and it is surgical, one approved action at a time. Switch it to allow-all, or auto-accept, and that same agent runs the loop on its own. The other agentic tools have the equivalent. So the mode is a setting you choose, per task, for your own reasons, whatever tool you reached for, and knowing why you put the dial where you did is the actual skill.

The deeper shift behind both modes, what it does to how you think about engineering work at all, is the subject of Agent Mode Changes the Shape of Thought. And the day-to-day method for working this way, including how trust gets earned task by task, is in The AI-Assisted Engineering HOWTO.

One loop closed by you, one closed by the system, and most of the safety is in knowing which one you are in.