The current separation between Chat, Work and Codex creates unnecessary cognitive overhead. As a user, I first have to understand which interface has which capabilities, which environment has access to which files, and where a task can actually be executed.
I think the product model should be inverted.
ChatGPT should be the central conversational and coordination layer, while computers, cloud environments, phones, and external services are treated as execution environments or agents that can be connected to it.
The exact UI does not matter, and something like @Desktop, @Laptop or @Cloud is only an illustration of the concept. The important part is that these environments become addressable resources from the same ChatGPT experience.
For example, I might have:
- a cloud execution environment that is always available
- an agent installed on my desktop computer
- another agent on my laptop
- eventually an agent on my phone
- connected services such as Gmail, Google Drive, GitHub, etc.
Each connected agent or service would expose its own set of capabilities, permissions and skills.
A desktop agent might provide local filesystem access, shell execution, development tools and installed applications. A phone agent might, with explicit permission, expose capabilities such as messages, notifications or supported apps. Gmail provides email skills. GitHub provides repository skills. Cloud provides compute and browser capabilities.
ChatGPT would then act as the coordinating layer across all of them.
This would make the distinction between conversation/context and execution/data location much clearer.
My conversations, projects, instructions and coordination context could remain centrally available in ChatGPT, while the product remains explicit about where other information lives and where actions are performed.
For example:
- This project and conversation are stored centrally.
- This file exists only on my desktop.
- This task will execute locally on my desktop.
- These files were uploaded to cloud storage.
- This operation requires access to my laptop, which is currently offline.
That distinction is important. A unified interface should not mean pretending that all data is in the cloud. ChatGPT should make locality, permissions and data movement visible when it matters.
The desktop ChatGPT application could simply bundle two components:
- The normal user interface.
- A headless local agent/runtime.
They could be installed together for convenience, but they would not need to be architecturally coupled.
That means I could sit in the ChatGPT web interface and work with my desktop computer, or start something on my phone and continue using resources on another machine. If an agent is unavailable, ChatGPT simply says so.
This also enables cross-agent workflows.
For example:
“Find the document on my desktop, compare it with the version in Drive, use cloud compute to analyze the data, and save the result back to the project.”
ChatGPT becomes the coordinator rather than forcing me to manually move between products.
OpenAI already appears to have many of the individual building blocks for this idea: ChatGPT conversations and projects, Work-style cloud execution, Codex/local execution, remote sessions, connectors and tool integrations.
So my suggestion is not primarily to add another feature.
It is to make these capabilities part of one coherent product model.
Instead of:
Chat vs Work vs Codex
the user-facing model could become:
One ChatGPT
One conversation/project layer
Multiple connected agents and services
Clear execution and data boundaries
This would also make the platform extensible in a very natural way. Installing an agent on a new type of device simply adds another capability provider to ChatGPT, without requiring another separate ChatGPT product or interaction model.
To me, this would make ChatGPT significantly easier to understand while also making it much more powerful.
The user should ideally think:
“What do I want ChatGPT to do?”
not:
“Which OpenAI interface do I need to open to do it?”