In Devin Local two settings are often merged into a single "autonomy dial", and that is the first mistake. There are in fact two, and they are orthogonal: agent mode answers what the agent does, while permission mode answers which of that runs without approval. Confusing the axes is what breeds most complaints about an agent that is "too timid" or "too reckless".
The naive model is clear: there is one slider from cautious to autonomous, and sliding it makes the agent bolder in everything at once. From it grows the expectation that "turning on Plan" makes the agent safer, and that "allowing everything" also puts it into planning mode. The expectation is convenient and wrong.
It breaks on the fact that the axes answer different questions. Agent mode is Normal, Plan or Ask: standard execution, a plan before acting (/plan), or answering a question without code changes (/ask). It is about the approach to the task. Permission mode is Normal, Accept Edits, Smart, Bypass or Autonomous: it is about which tool calls pass without a prompt. Ask mode allows and forbids nothing - it simply does not touch the code; Bypass plans nothing - it only removes approvals. The two axes are even set differently: agent mode is switched with slash commands like /plan and /ask right in the course of the dialog, while permission mode is chosen separately, as the level of trust for the session.
It is convenient to lay them out on one table showing how permission mode treats two kinds of action - editing the workspace and shell or fetch. Normal prompts for both. Accept Edits applies edits automatically but prompts for shell. Smart applies edits and, for everything else, has a fast model decide whether it is safe to run without asking, and risk always prompts. Bypass automates everything. Autonomous automates shell and fetch inside a sandbox, but direct editing still prompts. Normal is itself non-uniform: it lets reads in the current directory pass silently but asks for writes and execution, so even the "ordinary" mode already draws a line between observing and intervening.
Why it is split into two axes rather than reduced to one slider. Because "what to do" and "how freely" are independent decisions. You can explore unfamiliar code cautiously through Ask or already knowing the area through Normal, and that is not about permissions. You can grant autonomy narrowly, for edits only, or broadly, with shell in a sandbox, and that is not about approach. One slider would tie together the untied and rob you of half the useful combinations - for instance, planning with auto-applied edits, or standard execution under strict deny.
One restriction acts across both axes and outranks them. Organizational deny and ask work in every mode: neither Smart, nor Bypass, nor Autonomous overrides policy set by an administrator. So permission mode is your freedom inside the frame, not the frame itself. The frame is set by the org config, and the boldest mode does not move it.
| Permission mode | Workspace editing | Shell/fetch |
|---|---|---|
| Normal | Prompt | Prompt |
| Accept Edits | Automatic | Prompt |
| Smart | Automatic | Model decides; risk always prompts |
| Bypass | Automatic | Automatic |
| Autonomous | Direct edit prompts | Automatic inside sandbox |
The dated caveat concerns Smart. It is rolling out gradually and may not yet appear in your selector - its presence is checked in the live interface, not against this page. Building a process on a mode you do not yet have means describing someone else's configuration; while Smart is not visible, its role is covered by Accept Edits plus explicit allow rules for safe commands.
The cost of mixing the axes is concrete. Expecting Ask to make edits safe is pointless - it does not edit anyway, yet it lets you believe "the mode protects". Treating Bypass as a planner gets you an agent that acts at once with no plan and no approvals. And confusing Autonomous with "does everything itself" forgets that direct edits in it still prompt, so you are surprised by a request where you expected silence. Each of these mistakes costs not a crash but lost time: the agent behaves exactly along its axis while you look for the cause on the wrong one.
You should verify the setting on both axes at once. Say aloud two things: which agent mode you work in and which permission mode is active. Then match expectation against fact on a safe action - ask it to read a file and run a test, and see what passed silently and what raised a card. If the picture does not match the table, you mixed up an axis rather than hit a bug.
The typical failures are always about one substitution - two axes taken for one. "I turned on Plan and it still writes code" - Plan is agent mode, and edits were allowed by permission mode. "I set Bypass and it does not plan" - Bypass removes approvals, planning is set by the other axis. "Autonomous, yet it asks about an edit" - that is by design, its deliberate boundary. The sign is the same: the setting is described without saying which of the two axes it concerns. Name both, and the mode stops seeming capricious.