Codex Desktop: stale conversation state repeatedly resurfaces after correction in long-running multi-task workflow

Summary

Codex appears to become stuck on an obsolete instruction/conversation state and repeatedly resurfaces substantially the same old response after the user has corrected it and moved on to newer prompts.

This occurred during a long-running coordinated software-development workflow with multiple Codex conversations: one controller/coordinator conversation and one separate implementation/dev conversation.

After the initial routing mistake was corrected, Codex continued returning the same or substantially similar obsolete message approximately eight or nine additional times in response to later prompts.

Environment

• Product affected: Codex / ChatGPT Desktop
• OS: Windows 10
• Browser also in use: Google Chrome
• Subscription: ChatGPT Plus
• Time zone: Eastern Time, United States
• Date observed: July 13, 2026
• Workflow: multiple Codex conversations coordinated together
• Affected coordinator conversation: available privately on request / through in-app feedback session

Intended Workflow

1. The user gives a task/instruction to a coordinating Codex conversation.
2. That conversation routes/prepares/delegates work to a separate implementation conversation.
3. The implementation conversation owns code edits.
4. The coordinating conversation should not independently perform implementation unless explicitly instructed.

Initial Failure

Codex went off the established path and began performing implementation work directly inside the coordinating conversation instead of routing it to the separate implementation conversation.

The user corrected the mistake and clarified the role split between conversations.

Persistent Failure After Correction

After correction, Codex later returned the same or substantially similar obsolete message around eight or nine times across subsequent interactions.

The repeated response did not appropriately answer the newest prompt. It appeared to replay or reactivate an older resolved state.

Actual Behavior

Codex intermittently did one or more of the following:

• Responded as though the original routing mistake had just happened again.
• Repeated substantially the same message produced several interactions earlier.
• Lost track that the routing issue had already been corrected.
• Treated an obsolete instruction as though it were the newest instruction.
• Confused the controller/coordinator conversation with the separate implementation conversation.
• Failed to recognize the current stage of the workflow.
• Produced responses disconnected from the newest user message.
• Reopened/replayed a resolved issue without being asked.
• Required repeated correction of the same already-resolved issue.

Expected Behavior

After the user corrected the initial misunderstanding, Codex should have:

• Retained the clarified role of the coordinating conversation.
• Continued from the newest user instruction.
• Treated the original routing mistake as resolved.
• Avoided replaying old responses or obsolete task states.
• Kept the coordinating and implementation conversations logically separate.
• Prioritized the latest user message and instruction hierarchy.
• Asked for clarification if the current state was ambiguous.

Approximate Reproduction Sequence

1. Open an established Codex conversation used as a coordinator for a larger coding workflow.
2. Maintain a separate Codex conversation for implementation work.
3. Instruct the coordinator to direct/prepare work for the implementation conversation.
4. Observe the coordinator begin doing implementation directly.
5. Correct Codex and explain that implementation belongs in the other conversation.
6. Continue submitting newer prompts about the project.
7. Observe Codex later returning the same or substantially similar message associated with the earlier routing mistake.
8. Correct it again.
9. Continue the conversation.
10. Observe the obsolete response/state resurfacing repeatedly.

Frequency

• Approximately eight or nine occurrences after the original correction.
• Intermittent but persistent.
• Severity: High.

User Impact

This disrupts long-running software-development workflows by causing:

• Loss of confidence that Codex is acting on the newest instruction.
• Risk of code being modified in the wrong conversation/execution context.
• Risk of obsolete instructions being applied to the current codebase.
• Duplicate or conflicting implementation work.
• Unnecessary consumption of Codex usage and paid limits.
• Repeated time spent correcting an already-resolved issue.
• Difficulty determining whether later output is based on the actual current state.

Possible Technical Areas

This may involve one or more of:

• Stale conversation-state restoration.
• Old user-turn or assistant-response replay.
• Incorrect checkpoint restoration.
• Context-window assembly/order failure.
• Conversation summarization preserving obsolete instructions as active.
• Failure to prioritize the latest user message.
• Cross-thread/cross-task context contamination.
• Task-router state persistence.
• Incorrect recovery after interruption/compaction.
• Cached completion returned for a newer prompt.
• UI/backend synchronization failure.
• Duplicate message submission or delayed response delivery.
• Incorrect association between a response and its originating user message.

Requested Investigation

Please investigate whether:

1. Older turns or generated responses were repeatedly replayed.
2. A checkpoint, context-compaction, or state-restoration failure occurred.
3. A delayed task response was repeatedly attached to newer user turns.
4. Multi-conversation orchestration state became corrupted.
5. Codex incorrectly continued an earlier task after it had been superseded.
6. UI and backend disagreed about which user message was current.
7. Duplicated requests/retries were created invisibly.
8. An internal conversation summary preserved the obsolete instruction as active.
9. Related response identifiers show the same/related completion delivered multiple times.

Notes

Personal account details and exact affected conversation links can be provided privately through in-app feedback/support. They are omitted here because GitHub issues are public.