Plan Mode

Something like "Shift+Tab" to turn it on like other tool.
Maybe, it can maintain a list of TODOs in some AI-PLAN.md file (untracked in git) but maybe in project root itself, as it plans.
Then, once it starts implementation, it goes through the same .md file.

Out of interest how are you doing that currently? I started by using an md and json file and iterated over this a couple of times to improve the plan, however every time it needs to check if something is done or mark it as complete it's just fleshing/bulking out my context massively. Any ideas on how to improve it whilst there isn't a plan function. But yes I'm currently preferring the "other" tool to do things but the subscription model shuts me down pretty quickly in large projects.

Hello @bolinfest. Mentioning you as the chief contributor to this repo.

I am wondering what is happening with this FR.

Plan mode is table stakes for Codex.

@bolinfest does anyone even read these?

@cadamsdotcom we have a bit of a backog right now

Thanks for the response - know you’re busy so appreciate it.

Given you say there’s a bit of a backlog, I’m curious how formally it’s being tracked on the open source side. For example - is there a roadmap we can see? Would love to get an idea what you folks are prioritizing!

Out of interest how are you doing that currently? I started by using an md and json file and iterated over this a couple of times to improve the plan, however every time it needs to check if something is done or mark it as complete it's just fleshing/bulking out my context massively. Any ideas on how to improve it whilst there isn't a plan function. But yes I'm currently preferring the "other" tool to do things but the subscription model shuts me down pretty quickly in large projects.

What's the "other" tool?

What's the "other" tool?

Claude Code.

This is something Claude Code already does really well. While ChatGPT feels stronger overall in reasoning, Codex still struggles with tool use compared to Claude Code. Having a clearer way to preview and guide what the model intends to do would make it much easier to trust and manage its edits.

Right now, I often feel like I have to babysit it, since it can make messy or incorrect changes. A plan mode would go a long way toward improving that experience. This seems like a relatively high-impact feature that could deliver real value quickly with a bit of afternoon vibing.

@bolinfest thanks for engaging in this thread.

Codex's ergonomics don't let GPT-5 shine. We can't trust it to do what it says it will. Plan mode is the clincher that makes Claude Code a useful tool, and it'll be the same for Codex.

We all have our wishlists, and we know you have your roadmap. What will it take for us to convince you?

bump

Overall I think the GPT models are GOAT. However, Codex CLI feels nerfed without a proper plan mode. That feature is crucial to getting things right — otherwise it’s more like “vibe coding.” Compared with Claude Code, Codex CLI feels unusable without it.

I understand priorities may differ, but for many of us this feels like the single most important feature. Could you consider either (a) reprioritizing plan mode, or (b) sharing a clearer roadmap so the community can help contribute? I could imagine many would like to pitch in (including me) if we knew where it stands. Enabling plan mode may be one small step for Codex, but it would be one giant leap for developers.

I have found Plan Mode invaluable for the (many) times that I don't quite know what I want. Claude will come back with proposals for me to evaluate, which I love. And there's something about putting the model in a position where it can't make changes to the code and it must write a compelling case for what it "wants" to do, that IMHO results in higher quality decisions.

Currently it is really annoying that if I ask a question like "Why in file XYZ is this or that...?" and instead of an explanatory answer I get presented with a code patch diff to accept without any kind explanations.

Currently the answer is to use read only mode! It solves that. But switching read only on and off either requires starting a new session or a command I haven't found yet

This would be a great addition, now that cursor-cli and claude code have developed a comprehensive plan mode, codex seems lacking in this matter.

I proposed a potential high-level architectural plan on how to achieve this in my github issue #4897

Any feedback on this plan mode PR? https://github.com/openai/codex/pull/4961

I used Claude's Plan mode at first, but as I get better at prompting I've found Plan mode less and less useful. Here's my typical planning workflow now:

1. "Hey Claude, please research how the codebase handles the case of XYZ. I'd like you to track it through from user input all the way through to the backend server call. Please write your findings in ~/plan.md"
2. Then I edit the file to include "# Feature: better handling of XYZ" and I write my goals
3. "Hey Claude, please review Feature XYZ in ~/plan.md. I'd like you to come up with a plan for how to execute it. Write your plan at the bottom of the document"
4. Then I edit ~/plan.md myself, or do several further rounds with Claude to improve the document, e.g. by inserting acceptance goals for each stage.
5. "Hey Claude, please implements parts 1 and 2 of the plan"

I think Plan mode in Claude has two functions, (1) encourage the LLM to think a little deeper without its normal rush to be proactive, (2) give you the human an opportunity to see what it's going to do before it goes ahead.

Claude's Plan mode is only useful for a very narrow range of tasks. It doesn't help with the small tasks where it's fine just diving in. It doesn't help with the larger tasks which need more collaboration on the plan. It only helps with medium-small projects.

I think that every use of Claude's planning can be more effectively done with an ad-hoc ~/plan.md document or similar.

A few nice things I've enjoyed since adopting this ~/plan.md workflow:

1. It's easy to start new conversations and have them quickly ramp up with only the essential context needed to do their work (e.g. "Please read sections 1-2 of plan.md")
2. It's easy to use concurrent agents, e.g. codex exec 'Please implement part 1 of plan.md' and in another terminal codex exec 'Please implement part 2'
3. You can check the plan in if you realize it's going to take a week, or leave it an ephemeral file if it's only going to take half a day.
4. You can annotate sections with "[DONE]" for longer-term TODO tracking that Codex manages with its "item-list plan" or Claude manages with its TodoWrite tool.
5. Your plan can seamlessly be used with different agents, e.g. if you want Codex to help build the plan and Sonnet4.5 execute part of it, or if you want one agent to review the plan that another agent has developed.

Incidentally, this ~/plan.md workflow (which I've come to believe is best practice for planning the current generation of LLMs) can't even be done in Claude's plan mode, because it involves writing/editing the plan.md file itself and the LLM won't write it!

Use a smarter model for planning, and a faster/cheaper model for implementation. This is a widely adopted pattern and works well in practice.

IMO, this feature doesn't need justification—it's just a matter of priority.

What planning exactly meaning and what's difference between setting planning during reasoning or using mcp tools like sequetnial thinking?

What planning exactly meaning and what's difference between setting planning during reasoning or using mcp tools like sequetnial thinking?

Its more about UI/UX. In terms of claude code its just a toggle to go in read-only mode. I could imagine that its like a subagent with dedicated prompt and tool selection. CC integrated it very saemless into their UI. You can always switch between them and control what results you want. In plan mode I am conceptual, in act mode I want code snippets. Codex has a read-only mode too (/approvals) but before codex understand my requirements, he provides snippets (that I can accept or deny). Instead I want first to discuss with him and ask question to ensure he got me right. I could add .md files and define my workflow, but the toggle is so much easier and works out of the box. At the end all of them are somehow edditing the prompts before inference, Even your mcp. But I work many hours on a daily basis with both and CC is my favorite since months. I like Codex too, but the UI from CC is superior to Codex CLI. Lets fix that!

I like Claude's plan mode because of its read-only nature.

• I'm confident Claude does the job ? => don't use it
• If I want to double check => plan mode

On top of that it allows me to operate concurrently. Like having 3 terminals on the same project, one Claude is implementing, 2 are planning.

With codex I kind of tell it just analyze, don't change anything.
It works most of the time, but not always. It is annoying to type over and over...

Having 2 subscriptions one for Claude and one for Codex I find me defaulting to Claude more... just because of the plan mode!

Codex Web has a plan mode, can we please just have feature parity and something like this in the local cli?

<img width="918" height="294" alt="Image" src="https://github.com/user-attachments/assets/0c8c9d58-f1c8-4060-9011-1cbcf5165473" />

https://cookbook.openai.com/articles/codex_exec_plans

Any sense of when this might become available?

Just came here to advocate for a Planning Mode. Codex is very gung-ho about changing code and badly needs it. Often I am just asking for its opinion and discussing possibilities and it just goes off and implements. I'm getting tired of typing, "No code changes. Just analyze and explain..." etc, which thank goodness it does usually respect.

This is one of the most heavily-upvoted feature requests for Codex. We have been experimenting with various design ideas. Before we finalize a design, we'd love to get input from the Codex community. I've created a new discussion thread. We hope to hear from you!

let me sum it up: just copy claude code cli.

By far the single biggest annoyance with codex is that I will phrase something as a question: "I want to do X, what is the best way to accomplish this?" and it just goes off and starts making changes. If codex were better at discerning a request for dialogue from a request to go make changes, this feature wouldn't be so important, but in its current state plan mode is practically a necessity.

Any updates on this? I feel like it wouldn't be that crazy hard to implement. JUST COPY HOW CLAUDE DOES IT!!!

Please stop with those comments on "copy how cloude does it". If we want the team to work in such important functionality, we should at least ask for it, on the right way. I would love to have this, but since then we can't just bother like this... thanks

Thanks for all the feedback and interest in plan mode. It's clear from the feedback we received that there are many different opinions about how planning and spec'ing should work. One thing that we heard from many codex users is that there is no one-size-fits-all solution — that flexibility and configurability are important.

Today we announced a new feature: skills. Codex ships with several built-in skills including one called $plan. This skill provides a lightweight planning mechanism that you can invoke by simply including $plan in your task prompt. For example, $plan Build a dashboard website.

If you prefer a more formalized planning process — for example, one that builds a markdown specification with explicit requirements, you can define your own custom skill.

Please give it a try and let us know what you think.

@etraut-openai

Feedback on $plan skill vs. Plan Mode safety guarantees:

Thanks for shipping Skills! The extensibility and the open standard approach are great additions to the ecosystem.

However, after reviewing the $plan implementation, I believe there is a significant safety limitation compared to a dedicated "Plan Mode."

Currently, the $plan skill relies entirely on prompt compliance to prevent code changes. The SKILL.md instructions explicitly state: "Never write to the repo... Only write to the plans folder". While good advice for the model, this is not a mechanical guarantee. If the session was launched with default permissions (workspace-write), a model hallucination or instruction drift could still result in accidental modifications to the codebase.

In contrast, a true "Plan Mode" (like in Claude Code) acts as a permission state, effectively putting the agent into a read-only sandbox regarding the codebase, while still allowing it to write the plan artifact.

To achieve equivalent safety in Codex right now, a user has to:

1. Remember to launch the CLI with codex --sandbox read-only (high friction).
2. Hope that read-only mode doesn't block the $plan skill from writing the plan markdown file to ~/.codex/plans.

It would be vastly safer if the Agent Skills implementation in Codex supported the (currently experimental) allowed-tools metadata field. This would allow the $plan skill to programmatically restrict the session to read-only tools, removing the burden from the user to manage sandbox flags manually every time they want to plan.

Would appreciate your thoughts.

@coygeek, thanks for the thoughtful feedback.

Yes, you've identified a tradeoff between the generalizability of a skills-based solution and enforced no-code-modifications guarantees of a dedicated mode. I don't think we're opposed to adding a dedicated mode, but we generally prefer to invest in generalizable capabilities rather than hard-coded behaviors and modes. Generalized solutions scale better for both the user and the agent. They also compose better with other functionality. For example, skills can easily be used in non-interactive (codex exec) mode, and they work across all codex surfaces (CLI, extension, web, mobile, GitHub, etc.) without the need for bespoke interfaces or controls.

We also prefer to lean into the capabilities of newer models — including the significant improvements we've seen in steerability (rule following) and hallucination reduction with recent models. That is to say, we don't want to design our features around the limitations of older models — especially when we know that future models will continue to improve in these areas.

I hear your concern, but please try the $plan skill before you discount it. I've personally used prompt-based planning (previously with AGENTS.md and more recently with skills) extensively over the past few months. With the latest models, I've never seen codex make unwanted changes to my code during the planning phase.

Please give it a try and let us know what you think.

@etraut-openai Will skills be migrated under https://github.com/aaif as a vendor neutral standard?

@bhack

They're already an open-format.

https://agentskills.io/
https://github.com/agentskills/agentskills

Agent Skills is an open format maintained by Anthropic and open to contributions from the community.

Agent Skills is an open format maintained by Anthropic and open to contributions from the community.

I know but it is not under the same new governace as MCP and AGENTS.md right?

I have to agree with @coygeek's feedback, the lack of a hard mode switch is pretty disappointing.

I also think that for all we've talked about flexibility, the plan skill actually isn't that flexible. Unless I'm mistaken it seems to produce plans explicitly in one of two formats. That's not paticularly flexible, and looking at them they don't fit many of the situations in which I'd be looking to use a plan mode. Of course, there's nothing stopping us building on the skill to add more formats ourselves, but it does seem a bit silly to have to do so when _alternative tools_ don't have these limitations.

It's interesting you mention the steerability of the models, @etraut-openai. I'm looking at the skill markdown now and it says to "ask the user if they want to 1. Make changes, 2. Implement it, 3. Save it as per plan". Codex only seems to offer option 2 to me - always asking if I'd like to implement the plan. Given that our only guardrails against actually writing changes with the default sandbox are model steerability, it does make me concerned that it seems not to be following the skill instructions to the letter.

In contrast, a true "Plan Mode" (like in Claude Code) acts as a permission state, effectively putting the agent into a read-only sandbox regarding the codebase, while still allowing it to write the plan artifact.

But that's not true. Claude's plan mode does not affect the runtime behavior of its Edit or Bash or Write other tools. There is no sandbox.

(1) Look in the Claude source code cli.js. The toolPermissionContext.mode === "plan" has no effect on the runtime behavior of Edit, Write, Bash.

(2) Try it yourself experimentally. Enter Claude Plan mode. Tell it you're working on something, and ask it to write then execute a small python script to gather information. My example was to enter plan mode and tell it "I want to make a plan to write an edit tool similar to the Edit tool in cli.js. Could you look in there figure out its signature?". I stopped this after a bit and then told it "This Grep tool use isn't working well because the file is too big. Could you make a little python script which will search for all mentions of toolPermissionContext.mode in cli.js and we'll iterate on that." Claude happily wrote to the script while in plan mode, executed it, edited it with tweaks.

(3) Try jailbreaking it, in other words enter plan mode and tell to disregard its instructions and generate code inside one of your source files. Maybe you'll manage it? I was completely unable to persuade it to disregard its instructions for editing my source code. This tells me that the LLM has really good adherence to the instructions. Repetition of the plan mode <system-reminder> is probably key to adherence.

(4) Why else would Anthropic have spent so many tokens on a <system-reminder> EVERY SINGLE user message (not just user prompts, but also tool result user messages) to remind the LLM that it's in plan mode and not to try any edits? It's 183 words in normal planning, 753 words under the experimental PLAN_V2. Why would they have needed such strong and repeated reminders if the agent were in a sandbox? If it were in a sandbox, the tool_results that said "Sorry we can't edit this file while in plan mode" would have been a much better way to achieve the same end.

I think the conclusion is clear. Prompt compliance is a great solution: (1) we honestly can trust the LLM to make the right call if we prompt it right, (2) there are many grey areas, for instance iterating on information-gathering helper scripts, that are needed during planning and a hard block won't work for them.

I don't think we're opposed to adding a dedicated mode, but ... rather than hard-coded behaviors and modes.

If hard-coded behaviors or modes are considered in the future, is this issue the appropriate place to stay engaged with OpenAI developers for discussion, updates, and announcements?

---

While the referenced plan skill may be effective in practice, experience with prompt compliance suggests it should not be relied upon when 100% adherence is required.

It is also worth noting that the handling of NOT and other forms of negative logic in prompts has improved over time. The introduction of reasoning models marked the first point at which NOT and similar negative logic began to behave as expected. Even so, each use of negative logic still requires careful verification to ensure it is actually respected. For this reason, I generally avoid using NOT or other negative logic in prompts intended for reuse and stored in files, especially when those prompts may be applied across different models.

In case you decide to implement it in the requested Claude like way, please make this opt-out so it don't polute agent instructions when someone want to provide it's own process.

When I switched from CC I was also very disappointed in lack of plan mode, but I quickly noticed that gpt-5 series of models (excluding 5.1 but the -max was ok) are so good in following instructions that I can create much more complex and fine tuned planning in AGENTS.md

Here is how mine flow works:

• I default to read only mode on start
• model is instructed there are 3 stages: exploration, planning and implementation
• first us optional exploration stage where agent is instructed to understand my request and ask me clarifying questions is something is unclear what or how I want it - it also ask me to pick tradeoffs (this is basically defining what to do)
• then is planning stage where agent plans how to do it, it have to present implementation details, what files edit in what way, etc)
• it needs my explicit approval to continue, when I'm ready I switch approval to read write mode

I have instructed agent to provide 2-5 suggestions to answers because in 95% of cases one of them is what I want, but I always can say anything else or make "A but ..." Or "A +B" etc or I can ignore this and ask some questions about current implementation and model with come back with response and the same questions at the end for my decision.

In summary IMO you can do anything you want right now and I would not want oai to make current instructions mode complex to avoid conflict with baked in features.

Keep in mind that Todo tool is currently named "plan tool" so you have to clarify that you have other plan in mind in instructions.

Edit: what I would however appreciate is some kind of indicator in the status line whether I'm in ro or rw sandbox

Keep in mind that Todo tool is currently named "plan tool" so you have to clarify that you have other plan in mind in instructions.

Can you add more details. Trying to understand that and just not able to connect the dots. Thanks

> Keep in mind that Todo tool is currently named "plan tool" so you have to clarify that you have other plan in mind in instructions. Can you add more details. Trying to understand that and just not able to connect the dots. Thanks

https://github.com/openai/codex/blob/fab1ded484fea1c0f5330fbb1e3a9b15af9a12c8/codex-rs/core/gpt_5_1_prompt.md?plain=1#L63-L83

Agent gets in it's build in instructions section about presenting plan using update_plan tool and if you describe another plan it gets confused if that's the same plan or not.

Another FYI - this time the info is from a Git commit

https://github.com/openai/codex/commit/fab1ded484fea1c0f5330fbb1e3a9b15af9a12c8

Remove plan from system skills (https://github.com/openai/codex/pull/8374)
Removes plan from system skills. It has been rewritten into create-plan for evaluation and feedback: https://github.com/openai/skills/pull/22

---

https://github.com/openai/skills/tree/main/skills/.experimental/create-plan

For those wondering if progress is being made on Plan Mode.

In the latest commit

https://github.com/openai/codex/commit/d86bd20411522b7ecfd466aea7e384daac3e7fac

noticed this

<img width="544" height="209" alt="Image" src="https://github.com/user-attachments/assets/9d4c868e-6fa0-4252-9454-ba8ac7f549b6" />

I was not paying attention to CollaborationMode when I should have been, now I know better.

---

<img width="389" height="17" alt="Image" src="https://github.com/user-attachments/assets/b44d26f2-8bbb-4e04-90df-4af4131dbef7" />

For those that know, this could be one of the keys to being successful or stuck in the mud.

Thanks to the OpenAI devs for this.

I think it's very useful if would be implemented like in Claude Code, Cursor, etc.

The collaboration_modes = true under [features] in config.toml enables this - so far thoroughly impressed by the new plan mode. The way it asks questions and zeros-in on the requirements is commendable. Far better than the plan mode I've experienced in Claude Code (at least some time ago).

The collaboration_modes = true under [features] in config.toml enables this - so far thoroughly impressed by the new plan mode. The way it asks questions and zeros-in on the requirements is commendable. Far better than the plan mode I've experienced in Claude Code (at least some time ago).

Does this give us similar shift-tab support like Claude? This is the number one thing _by far_ that I wish the Codex CLI had.

The amount of times I have to undo everything I've typed (hard to even do in the terminal) because I forgot to turn approvals to read only - or copy the prompt I so carefuly crafted, close it, reload codex, and then /approvals, then paste again to get started - it is by far, my greatest barrier to fast iteration.

I understand being able to switch mid "thinking" is another feature request entirely - but just having the ability to switch easily when we're not in the middle of waiting for a response would be so, so, much better.

Its just so incredibly useful as you start to see the LLM veer off track and you want to stop - see where we are - make sure we're on the same page - reset trajectory...its one of the most useful and powerful tools in a software engineering dance using an AI assistant.

Being able to shift-tab to go between plan mode and auto-approve changes has got to be the most useful thing, far and away, that Claude has the Codex doesn't. Very much hoping this is high up on the Codex CLI teams' priority list. If it isn't...I'm telling you - it should be reconsidered as a higher priority.

Oh my gosh. YAS! Exactly this!!!

Thank you, Codex team! And thank you, @guidedways !

<img width="681" height="314" alt="Image" src="https://github.com/user-attachments/assets/0f00473b-0970-41c6-be61-4b74a013c0e2" />

When Plan Mode will be added in the VsCode extension? Is there a roadmap?

The collaboration_modes = true under [features] in config.toml enables this - so far thoroughly impressed by the new plan mode. The way it asks questions and zeros-in on the requirements is commendable. Far better than the plan mode I've experienced in Claude Code (at least some time ago).

Thanks for the contribution. Is this feature planned for release? Relying on GitHub issues to discover functionality doesn’t seem sustainable long term.

@Gnonymous No, they're coding features with the intention of never releasing them.

@Gnonymous I believe in 0.93 you should be able to enable this under /experimental - either way, they seem to be actively fine-tuning it, as I see they've been updating PLAN.md frequently. Obviously once it's ready, it should show up outside of the experimental section.

@guidedways I checked 0.93 but couldn’t find plan mode under /experimental. I’m still using it by enabling collaboration_modes = true under [features] as you mentioned above. Thanks for the reply, and we all hope it can be released soon.

@guidedways I checked 0.93 but couldn’t find plan mode under /experimental. I’m still using it by enabling collaboration_modes = true under [features] as you mentioned above. Thanks for the reply, and we all hope it can be released soon.

Yeah interesting, not there still. Should eventually arrive though, it's now being used widely (folks raving on Reddit etc).

@Gnonymous No, they're coding features with the intention of never releasing them.

@gregblass That’s bad news. Codex is powerful, but it lacks some useful features compared to Claude Code. By the way, does /rename work correctly for you? I tried renaming a session, but I don’t see any change when using /resume after /rename.

<img width="1034" height="647" alt="Image" src="https://github.com/user-attachments/assets/f86660f8-fd8c-4dd0-aa1e-4df6881986b7" />

Plan Mode is here.

I added the following in the config.toml file, and re-ran the installation command npm i -g @openai/codex and now it shows when I type /plan as you see in the screenshot.

[features]
collaboration_modes = true

Hope you're all seeing this.

It appears to be enabled by default in the new Codex Mac app. The app even has an indicator for it in the UI.

<img width="732" height="360" alt="Image" src="https://github.com/user-attachments/assets/d585ba96-6d2a-4304-a6cb-59978be2ccda" />

In vscode (new version)

<img width="577" height="188" alt="Image" src="https://github.com/user-attachments/assets/e0acbdb3-b37b-4ae3-9400-511d1b833b51" />

For vscode as the change is very recent, had to reinstall the extension to get to version 0.4.69

<img width="202" height="140" alt="Image" src="https://github.com/user-attachments/assets/240bbf60-8007-4a34-a04e-b466997340bc" />

Then click "+"

<img width="339" height="89" alt="Image" src="https://github.com/user-attachments/assets/4256e136-2e94-4ca9-979e-87c52223bb55" />

to reveal "Plan mode" selector

<img width="336" height="148" alt="Image" src="https://github.com/user-attachments/assets/3919dc7a-d976-410c-a330-6773c0475f0f" />

When selected updates the status bar.

<img width="345" height="145" alt="Image" src="https://github.com/user-attachments/assets/affc9c98-f065-4167-a38d-5d2a3ab126ea" />