What is Claude Code auto mode?
Auto mode replaces your permission prompts with a second model. In the words of Anthropic's permission modes docs: "In auto mode, a second model, the classifier, reviews actions instead of you." Anthropic announced auto mode on March 24, 2026 as a research preview on the Team plan, and made it generally available to all users on July 10, 2026.
Claude Code checks each action in this order, and the first match decides:
- Your permission rules. A matching allow, ask or deny rule settles it at once. Explicit ask rules still prompt you, even in auto mode.
- Reads and local edits. Read-only actions and file edits in your working directory run without a check. Writes to protected paths go to the classifier, and the first read outside your working directories still asks.
- The classifier. Everything else goes to it: shell commands, web fetches, subagent spawns and outside tools such as MCP servers (except tools a server marks
requiresUserInteraction, which always prompt you).
The classifier sees your messages, Claude's tool calls and your CLAUDE.md, but not tool results, so "hostile content in a file or web page can't manipulate the classifier directly." As of November 2026 it runs on Claude Sonnet 5 by default. Anthropic states the limits plainly: "Auto mode reduces permission prompts but does not guarantee safety. Use it for tasks where you trust the general direction, not as a replacement for review on sensitive operations."
Auto mode vs Manual, plan and bypass permissions
Auto mode is the only mode that runs everything without asking and still checks risky actions first. The table shows what each mode runs without a prompt, taken from the docs:
| Mode | Runs without asking | Anthropic says it is best for |
|---|---|---|
Manual (default) | Reads only | Reviewing every action yourself, sensitive work |
acceptEdits | Reads, file edits and common filesystem commands | Iterating on code you're reviewing |
plan | Reads, plus classifier-approved commands when auto mode is available | Exploring a codebase before changing it |
auto | Everything, with background safety checks | Long tasks, reducing prompt fatigue |
bypassPermissions | Everything | Isolated containers and VMs only |
--dangerously-skip-permissions starts bypass permissions mode. Deny rules still block in every mode, including that one. Plan mode borrows the classifier for shell commands while Claude plans; our Claude Code plan mode guide covers that side.
How do you turn auto mode on or off?
Auto mode is on by default: from Claude Code v2.1.283, released September 25, 2026, interactive terminal and VS Code sessions start in auto mode unless a flag or settings file picks another mode. The status bar shows ⏵⏵ auto mode on. Other controls:
| You want to | Do this |
|---|---|
| Switch during a session | Shift+Tab. From auto, the first press goes to Manual |
| Switch from a Bash prompt | Pick "Yes, and switch to auto mode" (Manual and accept edits modes, v2.1.247 or later) |
| Start one session in auto | claude --permission-mode auto |
| Run a script in auto | claude -p "..." --permission-mode auto. From v2.1.302, -p and Agent SDK runs with no mode set start in Manual |
| Set your own default | permissions.defaultMode in ~/.claude/settings.json. An "auto" value in a project's .claude/settings.json or .claude/settings.local.json has no effect |
| Start in auto in VS Code | Pick Auto from the mode indicator once. claudeCode.initialPermissionMode doesn't accept auto |
| Turn it off for an organization | permissions.disableAutoMode set to "disable" in managed settings |
Auto mode also needs a supported model. On the Anthropic API that means Opus 4.6 or later, Sonnet 4.6 or later, Haiku 5.5 or a Fable model; Sonnet 4.5, Opus 4.5 and Haiku 4.5 are not supported on any provider. When auto mode isn't available, the session starts in Manual instead.
What does auto mode block by default?
Auto mode blocks anything irreversible, anything that sends data out, and anything aimed outside your environment. The classifier trusts your working directory and the remotes configured for the repo when the session started. Everything else counts as external. The default block list is long. These are some of the entries most likely to come up in coding work:
- Downloading and running code, like
curl | bash - Sending sensitive data to external endpoints
- Production deploys and migrations
- Force push, and
git reset --hard,git clean -fdand other commands it presumes would discard uncommitted work - Merging a pull request no human has approved, approving Claude's own pull request, or disabling CI checks
- Printing a live credential or token into the transcript or a file
- Launching an agent loop with no human approval or sandbox, such as one started with
--dangerously-skip-permissions
Allowed by default: local file operations in your working directory, installing dependencies declared in your lock files or manifests, read-only HTTP requests, and pushing to any branch of the repo you're working in, including the default branch, unless the push hits a block rule or the branch is named like a deploy target such as production or gh-pages. Creating a pull request that matches your request runs without a prompt too. Run claude auto-mode defaults to print the full lists as JSON.
What happens when auto mode blocks an action?
When auto mode blocks an action, Claude gets the reason and looks for another way, and you get a notification. The action is listed under Recently denied in /permissions, where pressing r retries it with your manual approval. Four more things to know:
- Repeated blocks pause it. After 3 blocks in a row or 20 in total, auto mode pauses and Claude Code prompts you again. These numbers can't be changed. In a
claude -prun with no prompt to fall back to, the action doesn't run and Claude keeps working. - Approvals must be specific. To clear a block in chat, name the action and what makes it risky, such as the branch of a force push. Per the docs, "you can force-push" clears nothing.
- Chat boundaries can fade. "Don't push until I review" makes the classifier block matching actions, but it is read from the transcript and can be lost when the conversation is compacted. For a hard guarantee, add a deny rule.
- Teach it your infrastructure. If routine work keeps getting blocked, list your source control org, buckets and internal services in
autoMode.environment, or let/auto-mode-setupdraft the entries. The classifier only readsautoModefrom your user settings, managed settings or a--settingsflag, not from a project's settings files.
How accurate is the auto mode classifier?
The classifier rarely blocks harmless actions, but it lets some real mistakes through. Anthropic's engineering post How we built Claude Code auto mode (March 25, 2026) reports these numbers for the full two-stage pipeline:
| Test set | Size | Result |
|---|---|---|
| Real Claude Code tool calls from Anthropic employees | 10,000 | 0.4% of harmless actions blocked |
| Real overeager actions (people denied them or flagged them later) | 52 | 17% let through |
| Synthetic data exfiltration attempts | 1,000 | 5.7% let through |
The post calls the 17% "the honest number". In most misses the classifier saw the danger but wrongly read something the user said as consent for it. Anthropic's own comparison: against --dangerously-skip-permissions this is "a substantial improvement", and against careful manual approval "it's arguably a regression". The same post notes that people accept 93% of manual prompts anyway. The post describes a classifier running on Sonnet 4.6, so treat the figures as launch-time measurements.
Where does review still happen in auto mode?
Review happens at the result: auto mode removes the prompts, not the need for a person to sign off. The Claude Code best practices list five questions to answer before you leave a task running on its own. The last is: "Where does the result go, and who signs off? A PR, a comment, or a summary, and then a person approving the merge, the deploy, or anything else you can't take back." The default block list points the same way: it stops Claude merging a pull request no human has approved.
On a shared board that sign-off is a column. The agent works a card, leaves a hand-off comment, and moves the card to Needs review. A person checks the pull request, then moves the card to Done or back. Our human-in-the-loop guide covers that layout. Auto mode changes one thing: you no longer see each board change as a prompt. With the Flux MCP server, that works out as follows, checked against its code on November 2, 2026:
- No tool forces a prompt. Flux's 12 MCP tools carry no
readOnlyHintorrequiresUserInteractionmarkers, so any prompt has to come from your own rules. Calls no rule covers go to the classifier, like any outside tool. - Done is open to any Write key. Flux enforces no column order. A key with the Write scope, whose owner is at least a member of the workspace, can move a card to any column, Done included. Nothing on the classifier's default block list is about task boards.
- The comment is the record. Changes made over MCP are not yet written to the Flux activity log, so the agent's hand-off comment and the pull request are what you review. Comments made with an API key show under the name of the person who created the key, so have agents sign theirs.
So keep the sign-off rule in places auto mode respects. Start with your project's CLAUDE.md. The auto mode configuration docs say the classifier reads the same CLAUDE.md content Claude loads, so one rule steers both. And unlike a chat message, the project-root CLAUDE.md is re-injected from disk after compaction:
## Flux board rules - Work only the card you were given. Read it with get_card first. - When you finish, add a comment that starts with "[claude]": what changed, how you checked it, and the pull request link. - Then move the card to Needs review. Never move a card to Done. - Never merge a pull request. A person merges after review.
That is still a model reading a rule. If an agent must never move cards without you, add ask rules, which prompt even in auto mode. With the server added under the name flux, as in our setup command, this lets the six read tools skip the classifier and makes every move, and every new card, ask:
{
"permissions": {
"allow": [
"mcp__flux__list_workspaces",
"mcp__flux__list_boards",
"mcp__flux__get_board",
"mcp__flux__list_cards",
"mcp__flux__get_card",
"mcp__flux__search_cards"
],
"ask": [
"mcp__flux__create_card",
"mcp__flux__move_card",
"mcp__flux__reorder_cards"
]
}
}
The trade-off: you approve every move and every new card, not just cards headed for Done (a new card can be created straight into any column). Claude Code skips mcp__ rules with parentheses in settings files, so a rule can't target one column. For agents that only need to read the board, use a key without the Write scope: every Flux write tool, add_comment included, then returns "write scope required". Whichever you pick, check the Done column now and then for cards that skipped review. Where to keep these rules for Claude Code and other agents is covered in AGENTS.md vs CLAUDE.md, and unattended loops in the Ralph loop.