A coding agent can get a better model, a new window and a longer leash without making a person’s work easier to finish. Someone still has to supply the right files, redirect a mistaken approach and pick up the result. Codex’s history is useful because it exposes those different problems—and the danger of compressing them into one product breakthrough.
In How Codex Happened, Dan Shipper reports how OpenAI moved from a cloud product that struggled to find sustained use toward local tools and a desktop app. His interviews describe a deliberate choice to leave out a built-in code editor, putting conversations with agents at the center. That is a consequential design decision. The public code suggests a broader lesson: an assignment becomes easier to delegate when the agent can keep working while the way a person directs it changes.
An architectural option before the pivot
On April 24, 2025, OpenAI merged the first public Rust implementation of Codex CLI. The reasons were practical: a standalone executable would avoid requiring Node.js, use fewer resources and reach operating-system sandbox features directly. Its README warned that the new implementation was materially behind the existing TypeScript version.
Inside that unfinished implementation, the core library already separated agent logic from user interfaces. A protocol document described the engine accepting instructions, requesting model responses, running commands and applying patches. The interface could be a terminal or a graphical application. Interruptions and approval requests had explicit places in that design.
This was before the May cloud launch. It does not disprove the later strategic pivot described by Every, which acknowledges the April CLI as a separate early effort. It establishes something narrower: the architectural option existed before it became the center of the retrospective. Experimental code is neither a finished shared product nor a record of which internal team received the most resources.
The cloud exposed the cost of delegation
The May 16 launch gave Codex cloud tasks their own environments, where the agent could edit a repository, run tests and prepare changes for review. It also acknowledged a missing capability: users could not redirect the agent while it worked. Matching the remote environment to the developer’s actual setup remained part of the job.
The same announcement introduced a coding-optimized CLI model, codex-mini-latest. That matters when comparing the products: the cloud’s codex-1 was different, but local users did not have to wait until GPT-5 for any coding specialization. OpenAI also explicitly anticipated bringing interactive collaboration and delegated tasks together.
Claude Code offered a credible alternative route. Its February 24, 2025 preview already connected an agent to local code, tests and Git operations from the terminal. The useful advantage was concrete: work could happen in an environment the developer already used. A desktop window was not a prerequisite for delegating an engineering task.
Nor did OpenAI simply abandon the cloud. By September 15, it was describing context carried between local and remote work, conversation compaction for longer sessions, and faster cloud follow-ups through container caching. Its model pitch combined quick collaboration with sustained independent execution. The product was connecting modes of work that the origin-story shorthand can make sound like competing destinations.
What the desktop actually added
The February 2, 2026 app launch made the assignment a visible unit: project threads, parallel agents, separate working copies of a repository, and comments attached to proposed changes. Existing CLI and editor-extension history could carry into the app. Those choices reduced the work of keeping several jobs straight.
Leaving out an embedded editor did not eliminate manual editing. The launch explicitly let users open changes in their editor. The new default was to direct and review an assignment inside the app, with other tools still available. For a person managing several tasks, that can be more useful than keeping every action inside one window.
Model improvements were arriving alongside it. OpenAI’s February 5 GPT-5.3-Codex announcement combined stronger coding with broader professional knowledge and emphasized steering during execution. This is the strongest alternative to an interface-led success story: model capability, access to tools and product design improved together. The public sequence cannot tell us how much adoption each change caused.
The assignment still has a life underneath the window
A fresh October 15 change shows how concrete that underlying work remains. The merged code lets Codex suspend an unfinished parent task even when child agents exist, initiating their shutdown so the parent can later be recovered under its original turn identity. The accompanying tests check that recovery and distinguish failures while closing a child’s saved history.
It is a bounded capability. Child agents are not automatically restarted; their cleanup finishes separately; pending input may be discarded. We inspected the implementation and test definitions, without running the suite or establishing a desktop rollout. The patch illustrates a requirement of continuing work, not proof that every interruption is seamless.
For anyone choosing an agent tool, this history suggests a better practical trial than comparing chat windows. Give it a real assignment, correct it midway, leave it, and return to review what happened. Can the task retain the files, context and visible result needed to finish? That is the part of “agent-native” work a new interface has to earn.