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

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

Here is the distinction in one line: in agent mode, you close the loop. In autonomous mode, the system does.

Agent mode: directed, verified, yours

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; 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: scheduled, conditional, supervised differently

Autonomous mode removes your hand from the individual step. The system runs on a trigger, a schedule, or a condition: 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 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 per-task to per-boundary: you review the rules, the limits, and the outcomes, not 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 everything. 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 honest engineering question is whether you noticed the crossing.

That is the failure mode to respect: autonomy by erosion. Nobody decides 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 boundaries written down: what it may touch, what it must never touch, what gets escalated.

When to use which

Use agent mode 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.

Use autonomous mode for work that is frequent, 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. Boring is what makes supervision-per-task a waste of a human.

It is not only about trust

Trust is the main axis, but it is not the only one, and treating the choice as purely about risk oversimplifies it. In practice the dial also turns on constraints, cost, and plain utility. 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 honest answer to "agent or autonomous" is frequently "it depends," and the things it depends on are worth naming instead of pretending the rule is clean.

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. And here is the detail that dissolves the question almost entirely: 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 not a property of the tool you reached for. It is a setting you choose, per task, for your own reasons, 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. Know which one you are in. That is the entire distinction, and most of the safety.