Atlas plan mode refuses to edit files because the built-in plan agent is defined with edit: { "*": "deny" } plus explicit allows for the plan markdown paths, so the fix is to finish your plan and run the plan_exit tool, which asks whether to switch to the build agent and start implementing. Answer Yes at that prompt and the build agent takes over with the default permissions merged in, and edits work normally. Answering No raises QuestionRejectedError and keeps you in plan mode, which is the supported way to stay put. Do not add a global edit allow to work around the denies, because that defeats the entire point of plan mode.
Why does the Atlas plan agent deny every edit
The Atlas plan agent denies every edit because it is defined with edit: { "*": "deny" }, with exactly 1 exception: explicit allows for the plan markdown paths at .atlas/plans/*.md. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent.
The denial is not a misconfiguration on your side and it is not a bug. Plan mode disallows all edit tools deliberately, and the wildcard deny on edit is how that policy is enforced rather than merely promised. The only writes that survive the deny are the explicit allows for the plan markdown paths, which is why you can keep building the plan document itself while every other file stays untouched. The message you see is the standard permission-rule denial, because plan mode is implemented through the same permission machinery as everything else: every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs. Recognizing that the plan agent is the source of the deny is the whole diagnosis.
How to exit Atlas plan mode with the plan_exit tool
Exit Atlas plan mode by running the plan_exit tool, which asks whether to switch to the build agent and start implementing. Answer Yes at that prompt and the build agent takes over. The plan agent is the only 1 of the agents granted plan_exit, so the tool sits exactly where you need it.
The plan_exit tool is the designed off-ramp from planning into building, and it exists on the plan agent alone. Running plan_exit produces a question rather than an immediate switch, because handing edit capability to an agent is a decision Atlas asks you to make explicitly. Answer Yes and Atlas moves you onto the build agent, whose permissions are the merged defaults rather than the plan agent's blanket edit deny. From there the file edits that were being denied a moment ago go through the ordinary approval path, where Atlas computes a unified diff for every file edit and surfaces it for approval before writing. Nothing about your plan is lost in the transition.
What happens if you answer No to the Atlas plan_exit prompt
Answering No to the Atlas plan_exit prompt raises QuestionRejectedError and keeps you in plan mode. That error is expected behavior, not a crash and not a bug: No is 1 of the 2 supported answers. Declining plan_exit is how you stay in planning and keep refining the plan.
Developers sometimes see QuestionRejectedError in the transcript after declining plan_exit and assume something broke. Nothing broke. Atlas treats the rejection as your decision: you were asked whether to switch to the build agent, you said no, and the plan agent stays active with edit still denied for everything outside the plan markdown paths. Keep planning, and run plan_exit again when the plan is actually ready. There is no cleanup step, no state to reset, and no reason to restart the session. If you did intend to start implementing and answered No by accident, simply run plan_exit again and answer Yes the second time.
How to switch from the Atlas plan agent to the build agent directly
Switching directly to the build agent is the 2nd supported route out of Atlas plan mode. The build agent merges the default permissions instead of the plan agent's edit: { "*": "deny" } rules, so edits stop being denied the moment the build agent is active, with 0 config changes.
Agent switching gives you the same outcome as plan_exit without the question prompt, and it is useful when you already know you are done planning. The important detail is what the build agent inherits: default permissions, not plan denies. That distinction is why switching agents fixes the problem while editing your permission config does not, and why it fixes it without weakening any policy. Be clear about the caveat, though. Switching to the build agent means edits are now possible, so the read-only safety net of planning is gone by design. Make the switch when you actually intend to write code, not merely to silence a denial you found annoying.
Why you should not add a global edit allow to escape plan mode
Adding a global edit allow to escape Atlas plan mode defeats the mode. The plan agent's edit: { "*": "deny" } rule is the 1 thing making that agent read-only, so an allow that overrides it produces a planning agent that silently writes to your working tree.
The workaround is tempting and it is a mistake worth naming plainly. A global edit allow does not just unblock the one file you wanted to touch, it removes the guarantee that planning cannot change your code, and it removes it for every future session too. The value of Atlas drafting a plan in a read-only plan agent and asking before switching to a build agent comes entirely from the read-only part. Two supported exits already exist, plan_exit and switching to the build agent, and both take seconds. Use them. If you find yourself repeatedly wanting to edit during planning, the real signal is that you are done planning, not that the permission rules are wrong.
How to verify you are out of Atlas plan mode
Verify by re-running the 1 edit that was denied. Once you are on the Atlas build agent, the edit proceeds through the normal approval flow instead of returning the permission-rule denial, and Atlas computes a unified diff for every file edit and surfaces it for approval before writing.
The confirmation is unambiguous, because the two states look nothing alike. On the plan agent, an edit outside .atlas/plans/*.md comes back denied with the permission-rule message and nothing is written. On the build agent, the same edit produces a unified diff for you to approve, and after approval the file changes on disk. If the denial persists after you answered Yes to plan_exit, check that the switch actually happened rather than assuming a permissions problem, because the plan agent's blanket edit deny is the only rule involved here. Atlas also snapshots file changes as git patches, so once the build agent starts writing, edits can be diffed and rolled back.
How to fix it
- 01Finish writing the plan first. Plan mode still allows writes to .atlas/plans/*.md, so the plan document itself is never blocked.
- 02Run the plan_exit tool, which asks whether to switch to the build agent and start implementing.
- 03Answer Yes at that prompt. Answering No raises QuestionRejectedError and keeps you in plan mode, which is the supported way to stay in planning.
- 04Or switch agents directly to build, which merges the default permissions instead of the plan agent's denies.
- 05Do not add a global edit allow to your config to work around the denies. A plan agent that can write files is no longer a plan agent.
- 06Re-run the edit that was denied and confirm the build agent applies it through the normal diff approval flow.
Frequently asked questions
- why can't Atlas edit files in plan mode
- The Atlas plan agent is defined with edit: { "*": "deny" } plus explicit allows for the plan markdown paths. Plan mode disallows all edit tools deliberately, so the denial is by design, not a misconfiguration.
- how do I get out of plan mode in Atlas
- Run the plan_exit tool, which asks whether to switch to the build agent and start implementing, then answer Yes. Alternatively, switch agents directly to build, which merges the default permissions instead of the plan agent's denies.
- what is plan_exit in Atlas
- plan_exit is the tool that moves you from the Atlas plan agent to the build agent. The plan agent is the only agent granted plan_exit. Running it asks whether to switch to the build agent and start implementing.
- what does QuestionRejectedError mean after plan_exit
- QuestionRejectedError after plan_exit means you answered No to the prompt, so Atlas kept you in plan mode. Answering No is the supported way to stay in planning. The error is expected behavior, not a crash.
- can Atlas write any files while in plan mode
- Yes, but only the plan markdown. The Atlas plan agent has explicit allows for writes to .atlas/plans/*.md, and everything else is denied by the edit: { "*": "deny" } rule on the plan agent.
- should I add an edit allow rule to fix plan mode denials
- No. Adding a global edit allow defeats plan mode by making the read-only plan agent able to write files. Use plan_exit or switch to the build agent instead, both of which take seconds and preserve the policy.
- what is the difference between the Atlas plan agent and the build agent
- The Atlas plan agent is read-only, with edit: { "*": "deny" } plus allows for plan markdown, and it alone holds plan_exit. The build agent merges the default permissions, so edits run through the normal unified diff approval flow.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Atlas with Claude Opus 4.5: The Price Break Opus in 2026
Claude Opus 4.5 runs Atlas on a 200K context at $5 per Mtok input, $25 per Mtok output, down from $15/$75 on Opus 4.1. Setup, extended thinking, and tradeoffs.
Atlas for Svelte in 2026
Adopt Atlas, the terminal-native AI coding agent, for Svelte and SvelteKit projects in 2026. Enhance development with intelligent code search, secure local embeddings, and guided code generation.
Atlas with CodeGemma 7B (Ollama): Fill-in-the-Middle on 8GB in 2026
CodeGemma 7B (Ollama) is Google's 5.0GB code model with fill-in-the-middle training and an 8K context, Free (self-hosted). Atlas setup and honest tradeoffs for 2026.
Rename a Symbol Across the Repo with Atlas in 2026
How to rename a symbol across a repo with Atlas in 2026: findReferences gets the true reference set, grep catches strings and docs, and edit refuses ambiguous matches.
Atlas with Together AI (gateway) in 2026: Open-Weights Models at Scale
Together AI (gateway) drives Atlas with the broadest open-weights catalog: Qwen3.7 Max at $1.25 / $3.75 per Mtok, up to 1M context, US-hosted inference.
Atlas vs OpenHands: Terminal AI Coding Agents in 2026
Atlas and OpenHands comparison for 2026. Explore terminal-native TUI, self-hosting, code indexing, change review, and pricing models for AI coding agents.
Atlas with GPT-4o in 2026: A 128K Legacy Model with Dated Snapshots
GPT-4o runs in Atlas at $2.50 per Mtok input and $10 per Mtok output on a 128K context with a 16,384 output cap. Best for quick lookups and reproducible baselines.
Atlas for Pandas: Terminal-Native AI Coding in 2026
Atlas is a terminal-native AI coding agent for Pandas. Vectorize df.apply, fix chained assignment under Copy-on-Write, and pin DataFrames with assert_frame_equal.