Several existing feature requests propose individual parts of this idea: switching between Chat and Work while preserving context, better ChatGPT↔Codex handoffs, or automatic routing between environments.
I would like to suggest bringing these ideas together into one optional cooperation layer across Chat, Work, and Codex, while preserving the ability to use all three independently as they work today.
Keep separate use
Some users will always want to use Chat, Work and Codex as distinct environments.
That should remain possible.
Enabling better cooperation should not mean merging the three products or forcing automatic routing on everyone.
Instead, I would suggest several levels of interaction that users can choose between.
1. Manual handoff
Within an existing conversation, the user should be able to explicitly hand the current task or a subtask to another environment.
For example:
Continue in Work
Continue in Codex
The relevant context would be transferred, while the UI clearly indicates which environment is now handling the task.
After completion, the result could return to the original conversation without requiring the user to manually copy prompts, files, summaries, and results between environments.
2. Suggested handoff
ChatGPT could recognize when another environment is better suited to part of a task and suggest it without acting automatically.
For example:
“This part requires repository access and running tests. Continue in Codex?”
or:
“This task would benefit from multi-step browser and file interaction. Continue in Work?”
The user remains in control but no longer needs to know in advance which environment is best suited to every part of a task.
3. Optional automatic orchestration
For users who want it, ChatGPT could be allowed to delegate appropriate subtasks automatically.
For example, a user might ask in Chat:
“Analyze this open-source project, determine why the backup fails, and explain the result to me.”
The system could coordinate the task like this:
Chat
→ understands the goal, discusses requirements, and decomposes the problem.
Codex
→ inspects the repository, analyzes code, runs tests, or prepares a patch.
Work
→ performs longer-running research, browser interaction, file-heavy analysis, or artifact creation when useful.
Chat
→ receives the results, combines them with the conversational context, and continues the discussion with the user.
The user would not need to manually act as the dispatcher between the three environments.
Bidirectional cooperation
Delegation should ideally not be limited to Chat → Work/Codex.
The environments should be able to cooperate where appropriate:
Chat ↔ Work ↔ Codex
For example:
-
Work could delegate a code-analysis subtask to Codex.
-
Codex could return an ambiguous product or design decision to Chat instead of making an unsupported assumption.
-
Chat could delegate a long-running external task to Work and continue when the result is available.
Each environment could retain its specialization while participating in a larger workflow.
Always keep the active environment transparent
Whether the handoff is manual, suggested, or automatic, the UI should always make it obvious where the task is currently being processed.
For example:
Chat → Codex → Chat
or:
Currently executing in: Codex
Users should also be able to inspect which context, files, and resources were transferred.
Automatic orchestration should never mean invisible orchestration.
Preserve permission boundaries
Delegation should never silently expand permissions.
Each environment should only receive:
-
the context required for the delegated task;
-
files, repositories, apps or tools the user has authorized;
-
permissions explicitly available to that environment.
Sensitive or consequential actions should continue to require explicit approval where appropriate.
Why this matters
Today, users can end up becoming the manual bridge between Chat, Work and Codex: deciding which environment to use, copying context between them, transferring results back and reconstructing the state of a task.
At the same time, other users may prefer the existing separation and do not want ChatGPT making those decisions automatically.
I think both needs can be accommodated.
The underlying model could simply be:
Separate — use Chat, Work, and Codex independently as today.
Manual handoff — explicitly continue a task in another environment while preserving context.
Suggested handoff — ChatGPT recommends the appropriate environment and asks first.
Automatic orchestration — optionally allow ChatGPT to delegate subtasks between environments itself.
The goal is therefore not to merge Chat, Work, and Codex.
It is to keep their specializations and independent use, while adding a transparent, permission-aware cooperation layer for users who want it.