[Feature Request] Plan Mode: Add "Copy Plan" button & "Clear Context and Start Coding" workflow

+1, would be cool in Codex CLI too as I'm sure it's not hard to add. It's been an integral part of my workflow in Claude Code and I think it'll certainly be a good addition to Codex CLI to free up its context (although I obviously haven't quantified how it affects model performance).

+1

I think we're getting somewhere.

I just saw this in VS Code + Codex Extension.

As you can see in the photo (hopefully it gets attached), there's now a 'Download Plan" (meaning it downloads plan.md) and a "Copy" (meaning copy to clipboard) buttons next to the "Open" button (which was always there.

<img width="726" height="368" alt="Image" src="https://github.com/user-attachments/assets/d12be50e-1e4a-4875-9cbc-70fe74b89b66" />

Then, i tested the Codex App (for macos) (Version 260210.1703 (602)) and i see the same change, download button and copy button, which are new.

This is excellent.

However, this functionality isn't there for codex cli itself (perhaps a limitation?).

Anyway, part of my original github issue is now resolved. :)

_____

Only thing missing is the button for 'start a new session and execute current plan', so hopefully the OpenAI team considers this useful feature.

Worth considering that the "clear context and execute plan" workflow might have a hidden cost with Codex models specifically. The thing is that Codex models (especially the new 5.3 one) explore the codebase thoroughly when they get a task, including when you enter plan mode. But when you reset the context and feed only the plan back in, the model loses all that exploration and has to redo it from scratch during the execution phase. That's probably why it hasn't been added, we'd essentially be paying for codebase exploration twice. But who knows, maybe it'll enhance the result since the model will only pull the relevant bits based on the plan. That said, Claude Code's implementation of this works well in practice. Claude Code has Explore subagents though which seems incompatible with Codex vision 🤷‍♂️

@sqdshguy I think that could be solved with a "compact and auto accept edits" workflow then. Have codex figure out what is important information it needs to continue, move that into the plan file in some kind of ## Memory section, clear the rest of the context, and proceed with implementing the plan. Context rot is something that has been demonstrated to be an issue for pretty much all models that I know of.

+1 for this feature in Codex CLI. I like to plan with gpt 5.2 high and then execute with 5.3 codex and my current solve for this is to just let him write the plan in a file, then create a new chat, change model, and point it to the plan file (or just copy-paste the text manually).

+1 for this I use Claude Code's "clear context and implement plan" daily.

+1

Claude Code just released this in v2.1.50:

<img width="602" height="140" alt="Image" src="https://github.com/user-attachments/assets/1c29d038-5fa3-4a80-afc3-7c80e0e909eb" />

I really love this small (quality of life improvement) that shows the actual context being cleared.

UPDATE:
For those unaware, claude code never showed the amount of context being cleared until now.
Now it shows actual percentage (as visible in the photo) as 51% cleared.

+1 this is actually very important for context management

+1

+1 This would be very helpful to avoid hitting the context limit and also the model seems to respond better when it doesn't have all the previous exploratory context used for creating the plan

@shivakanthsujit indeed. I often find myself starting a new chat after a plan is generated.

Strong +1 from me. This is one of the main workflow gaps that still makes me consider going back to Claude Code for planning-heavy work.

The current flow is too manual:

• finish /plan
• copy the plan
• start a fresh session
• paste the plan back in
• restate the handoff context

That defeats the purpose of having a dedicated planning mode in the first place, and it wastes both time and context budget.

The ideal implementation for me would be:

1. When exiting Plan Mode, offer an option to start execution in a fresh default-agent context.
2. Automatically persist the generated plan and a short structured handoff/task list to disk.
3. Pass that persisted plan + handoff to the default agent as the execution starting point.

In other words: exit /plan -> optional clear/compact context -> save plan + handoff -> continue with default agent.

That would preserve the value of planning, reduce context pollution, and remove the current copy-paste session-juggling workflow.

I think this workflow becomes even more powerful if it is extended beyond just “clear context and continue locally”.

Right now Plan Mode is excellent for shaping intent: you can explore the repo, iterate on the approach, and converge on a solid plan. But after that point, there are often three distinct needs:

1. Continue locally (current behavior)
2. Continue locally with a clean context (this issue)
3. Continue in Codex Cloud (missing piece)

That third option would be especially valuable. After a plan is finalized, execution can be long-running or involve heavier operations (tests, refactors, PR generation), which are better suited for a cloud agent.

So instead of only:

• Clear context and start coding

it could evolve into something like:

• Proceed locally
• Proceed locally with clean context
• Proceed in Codex Cloud

From an implementation perspective, this does not require full session migration. It could simply serialize the approved plan plus relevant repo/branch state and launch a cloud task. This would tightly connect Plan Mode with asynchronous execution and make the CLI → Cloud transition feel natural.

This likely overlaps with the remote session handoff discussions in #19657, but framing it specifically as a Plan Mode continuation makes the user workflow very concrete.

Shouldn't this be a nearly "free" feature to implement since it's already implemented in the CLI?

Is this feature really that difficult to implement? This is really a good feature that I'm looking for.

Current Codex App status update (July 2026):

The App now shows an Action Menu when Plan Mode finishes, so part of the original workflow has been implemented. However, the menu currently offers only two choices:

1. proceed with implementing the plan;
2. do not proceed.

It still lacks the third option already available in Codex CLI:

Clear context and implement this plan

This is not just another way to start implementation. It is important because planning can consume a substantial portion of the context window through repository exploration, discussion, and revisions. Users should be able to keep the approved plan as the execution handoff while discarding the exploratory conversation that produced it.

Requested App behavior:

• add Clear context and implement this plan to the existing post-Plan-Mode Action Menu;
• preserve the finalized plan and pass it into a fresh implementation context automatically;
• preserve the current project/worktree/branch association;
• begin execution without requiring users to copy the plan, create a new thread, paste it, and restate the task.

The App already has the correct menu location and Codex CLI already has the desired action. The remaining request is straightforward CLI/App feature parity for that third menu option.