Always-online is only the surface; what is truly declining is the
cost of supervision.Codex no longer maintains a standalone desktop app entry point. OpenAI has merged it into ChatGPT, then launched ChatGPT Work. The Codex technology once used for writing code now handles documents, spreadsheets, and web pages. Codex already has over 5 million weekly active users, and 1 million of them use it for non-development work.
In OpenAI’s new design, users first choose Chat, Work, or Codex. Different modes invoke different permissions and execution environments. The long-running task execution capability developed through coding is now being applied to general-purpose work.
Other products show the same trend. Anthropic has put Chat, Cowork, and Code in the same application. Users can switch modes by task. Their execution environments and permissions remain independent. In the development space, Cursor 3.0 has spun off a task management window. Tasks can execute in local, cloud, and remote environments.
The common pattern behind these changes is that the underlying execution environment and the human interaction interface are decoupling. Agents can run continuously in the background. Users can initiate tasks from the web, check progress and approve results from their phone. When editing, debugging, or deep review is needed, they switch back to the desktop IDE.
What kind of change makes it possible for users to manage tasks on the web or phone without staying tethered to the original interface?
The answer depends on whether the Agent can complete tasks independently, and whether users can verify results at low cost.
Agent products are evolving along two axes.
The first is the ability to complete tasks independently. Early models were error-prone and required humans to watch them in real time. Only when autonomous planning improves can people trust them to run in the background.
The second is the ability to verify results at low cost. Always-online is only meaningful if people don’t have to re-read the entire process. The system needs to compress long, complex execution processes into quick-to-review conclusions, sources, diffs, and anomalies – this is what we call “acceptance compression.”
Agents moving from the IDE to the phone is not just about stronger execution capability; it is about a shift in how humans supervise: we no longer watch the execution process, we only verify the final output.
Coding was the first to cross this threshold, because software engineering already had mature “acceptance compression” tools. Knowledge work, by contrast, long lacked this infrastructure – only recently have the missing pieces come together to cross the chasm.
Always-online is only the surface; what is truly declining is the
cost of supervision.
In the early days, large model coding was highly unstable. People had to sit at the computer, watching the editor cursor and terminal errors, ready to step in and correct at any moment.
At this stage, the integrated development environment (IDE) was the lowest-cost synchronous supervision interface. It put code, terminal, and debugger in front of the person, making it easy to modify code or prompts at any time.
This matched the relatively low model capability of the time. Vendors didn’t need to build complex cloud VMs and mobile push systems to make semi-finished agents useful. The IDE was not the endgame – it was synchronous supervision scaffolding for a low-autonomy era.
As autonomous capability improved, agents began to leave the IDE. Coding agents were the first to close the loop on mobile, because software engineering already had highly mature asynchronous acceptance protocols.
From task entry, red-green Diff changes, machine checks via tests and compilers, to the safety net of PR containers and one-click Revert, this infrastructure was inherently the perfect mobile control panel. An agent runs in the background for hours, and the developer pulls out their phone to check just a few compressed signals: did the tests pass, what changed, what does the preview look like.
This compresses high-intensity review into extremely low-bandwidth decision signals. Although tests only verify explicitly stated requirements, and increased output can overwhelm review queues, it significantly lowers the per-acceptance cost, letting someone decide whether to merge in half a minute from the subway.
When agents entered knowledge work – writing reports, making presentations, organizing spreadsheets – acceptance hit a vacuum.
The bottleneck was not that phones can’t view files. Mobile suites could already access and collaborate on documents. The real pain point was: it’s very hard for a user to decide, within two minutes, whether the 30-page slide deck auto-generated by an agent is acceptable.
There are no compilers and automated tests here. A 30-page report – is the data correct? Are the case studies real or fabricated? None of these questions can be answered with a machine-generated red or green light.
Without acceptance compression mechanisms, throwing long-running tasks to the background was unsafe and would only make people more anxious after closing their laptop – they had no choice but to sit at the computer and manually check line by line. This meant early knowledge work agents could only stay on the desktop, dominated by high-attention synchronous review.
The changes in July 2026 signal that knowledge work is beginning to build the filtering mechanisms that let people make quick decisions on their phone.
Systems are beginning to filter information across different documents: large models can generate editable native slides, letting people click to verify specific components instead of guessing whether images are real; highlight suggested edits, letting people accept or reject each one without re-reading; link report figures to private-domain files for source tracking; push an outline for plan approval before beginning work; push directly to the phone lock screen when data anomalies are detected.
While earlier prototypes of local remote control existed, they still depended on the local computer being awake. What July achieved was persistent cloud sessions and cross-device continuity.
These mechanisms didn’t create a compiler – content quality and irreversible external publishing still require human judgment. But they compressed the review scope from “read through 30 slides” to “check only a few anomalies and source markers,” letting people decide in two minutes on their phone.
This low-bandwidth decision-making reveals the true meaning of “accessibility.”
It is not merely about 24/7 availability or having an app. It means users can initiate, monitor, and verify work without returning to the original execution environment, without maintaining high attention.
At this point the agent recedes into a background delegation service: it does not depend on the user keeping the software open; the executor continues working in the background after the user goes offline; when the user returns hours later, the system can compress what happened into a brief summary; it stays quiet by default, pushing notifications only for anomalies or high-risk actions.
The phone is merely a window for low-attention supervision; what truly changed is the cost of supervision.
When discussing continuous execution, cloud hosting is the mainstream, but continuous execution does not equal cloud.
For privacy-conscious groups, a Mac mini kept running at home (see Mac sleep and wake settings guide), paired with a local agent and mobile client, can also achieve continuous execution, remote task assignment, and phone-based monitoring – the same set of capabilities.
The difference between the two lies in responsibility allocation and data boundaries. Local execution preserves the system environment, app login state, and control, but the user must bear maintenance and remote access responsibilities. Cloud execution has the vendor handling the environment and elastic resources, eliminating maintenance costs, but the user must surrender the runtime environment and data boundaries. Mass-market commercial products lean toward cloud, but people willing to shoulder the configuration cost can absolutely go local-first.
Under this trend, IDEs and desktop software have not disappeared, but have retreated to become professional execution views.
The IDE is dedicated to high-density code writing, review, and debugging; Word and PowerPoint have become tools for precise formatting and deep review.
The top-level form has become a cross-device, continuous, always-online delegation service. User attention is rationally distributed: on the desktop, users handle initial macro planning and deep review; on the phone, users handle low-bandwidth verification – tapping the screen to approve plans, handle exception notifications, or confirm before critical write operations.
To return to the beginning: after Codex merged into ChatGPT, it lost a standalone entry point, but its execution capabilities entered more types of work. This change neatly encapsulates what is happening with Agent products: tasks can run continuously, and users switch between IDE, desktop, web, and phone based on their attention at the moment.
The next round of competition will also continue along these two axes. Agents must improve the probability of completing tasks independently, and must compress long-running execution into easily verifiable results. The former determines whether people dare to leave; the latter determines whether they will keep using the product after they leave.