Is OpenAI Actually Fixing Codex CLI After the Backlash?

Codex CLI has had a rough few days. GPT-5.6 Sol can produce excellent work, yet a growing number of developers were finding that the experience inside Codex felt more expensive, more chaotic and sometimes less capable than the same model running through another coding harness.

That criticism became much louder after Theo from T3 published “I need you to hear me out (it’s REALLY good)”. His argument was not that GPT-5.6 was bad. It was that Codex itself was getting in the model’s way through an over-prescriptive system prompt, intrusive progress instructions and uncontrolled subagent orchestration.

I went through the recent Codex releases, merged pull requests and current development work to see whether OpenAI is actually responding.

My conclusion is that Codex is being actively repaired, but it is not fixed yet. The prompt problem has already received a stable hotfix. The most meaningful controls for subagent cost and reasoning are in the 0.145 prerelease line, while the deeper orchestration criticism remains largely unresolved.

This article reflects the public repository as of 20 July 2026.

The criticism was about the harness, not the model#

When people compare coding models, they often talk as though the model name explains the entire result. In practice, a coding agent is a combination of the model and the system built around it:

• the system and developer instructions;
• the tools it can call;
• the context it receives;
• how it delegates work;
• how it handles retries and interruptions;
• and what the interface encourages it to do.

Theo’s most convincing point was that the harness is part of the product. Running GPT-5.6 Sol in Codex and running it through Claude Code can produce different behaviour even though the underlying model is the same.

His complaints centred on three areas.

First, Codex’s bundled instructions included detailed frontend opinions. They prescribed visual patterns such as card styling, border radii, icon choices and page composition. General coding guidance had turned into a miniature design system, which could conflict with an existing project and bias unrelated frontend work towards the same look.

Second, the instructions pushed the agent to provide frequent progress updates. This helped explain the odd timer-like messages where Codex repeatedly announced that it was still working instead of simply completing the task.

Third, multi-agent mode could burn through usage rapidly. A powerful root agent could spawn several children, pass them large amounts of context and allow them to use similarly expensive reasoning settings. The result might be useful, but it was difficult to predict or control.

Theo’s demonstrations are not controlled benchmarks, and his claim that he personally caused a prompt removal cannot be independently proven from the public repository. The underlying problems, however, line up closely with changes now appearing in Codex.

The first clear response was the 0.144.6 hotfix#

On 18 July, OpenAI published Codex CLI 0.144.6. The release contained a narrowly scoped change:

• refreshed bundled instructions for GPT-5.6 Sol, Terra and Luna;
• refreshed their instruction templates;
• corrected their context windows to 272,000 tokens.

The associated pull request, “Narrow 0.144 hotfix to GPT-5.6 prompts and context”, is unusually explicit about keeping the patch focused. It says the stable catalog should differ in exactly twelve values: the base instructions, instruction template, context window and maximum context window for each of the three GPT-5.6 variants.

That matters because this was not a broad feature release that happened to include prompt work. It was a targeted stable hotfix touching the precise layer under criticism.

It still does not prove that Theo’s video directly triggered the change. Prompt updates may already have been in progress, and OpenAI has not published a statement connecting the two. The timing and scope make it reasonable to say that the company was responding to the same class of problem, even if the exact cause remains private.

There is another useful signal in 0.144.2. OpenAI rolled back a Guardian auto-review prompting change after it caused a regression. That suggests prompts are now being treated as production behaviour that can require an emergency rollback, rather than harmless text bundled around the model.

The bigger correction is arriving in 0.145#

The prompt hotfix is important, but the stronger technical response is in the 0.145 development line.

Codex previously exposed several overlapping multi-agent settings through feature flags and partially implemented configuration. Pull request 33550 consolidates these under a clearer [agents] configuration section.

The new surface includes:

• agents.enabled to control whether multi-agent tools are available;
• agents.max_concurrent_threads_per_session to limit spawned threads across both agent backends;
• default subagent model and reasoning settings;
• persisted resolved settings so a resumed session does not silently change behaviour.

The key follow-up is pull request 33631. Before this change, the default subagent model and reasoning fields were effectively reserved placeholders. They are now applied when a spawn call does not explicitly choose its own settings, including agent-job workers.

A future 0.145 configuration can therefore look broadly like this:

[agents]
enabled = true
max_concurrent_threads_per_session = 4

# Example values: choose models available to your account.
default_subagent_model = "gpt-5.6-luna"
default_subagent_reasoning_effort = "low"

This directly addresses one of the most expensive failure modes. A root agent can remain on a high-capability model while routine exploration, searching or repetitive worker tasks use a faster and cheaper configuration.

The same change also allows full-history forks to retain the parent conversation context while using a different model or reasoning effort. Previously, keeping the full context and reducing the child’s cost were more tightly coupled.

OpenAI also merged validation after applying agent roles, preventing a role from creating an unsupported model and reasoning combination after the initial spawn settings had already been checked.

These are not cosmetic warnings. They are real controls over the model, effort and concurrency used by children.

They were already working on token controls#

Not every improvement arrived after the public backlash.

Codex 0.142.0, released in June, introduced shared rollout token budgets and delegation controls. Subagents draw from the shared budget, receive warnings as it runs down and stop when it is exhausted. Users can also choose whether delegation is disabled, only allowed after an explicit request or permitted proactively.

Codex 0.144.0 added a warning when Ultra reasoning is combined with high multi-agent concurrency. That warning does not make the workflow cheaper, but it confirms that OpenAI already recognised the risk of unexpectedly rapid usage.

The timing is important. The company did not discover multi-agent cost on the day a YouTube video appeared. The team was already adding budgets and warnings. The recent criticism exposed that those protections were not yet enough.

Recent work is making multi-agent sessions less chaotic#

Since the current stable release, the main branch has continued to receive agent-related reliability and performance changes.

Pull request 34234 avoids redundant subagent metadata requests. Fresh and forked threads cannot already contain descendants, so Codex no longer performs unnecessary backfills for them. Resumed sessions still load the information needed for agent navigation.

Pull request 34226 stops child completion notifications from triggering the same expensive backfill used for the primary CLI task. In a busy multi-agent session, only the main exec turn should drive that work.

Pull request 34198 lets side conversations start with an empty interface instead of replaying all inherited parent turns, while still retaining the context required by the model.

The terminal interface has also received several rendering improvements, including incremental Markdown rendering and fewer redundant redraws while streaming.

These changes should make Codex feel more responsive and less noisy when multiple threads are active. It is worth separating interface efficiency from model efficiency, though. Avoiding a duplicate database read or Markdown rerender saves local resources; it does not necessarily save thousands of model tokens.

What still has not been fixed#

The biggest architectural criticism remains open.

Codex is still primarily based on model-directed orchestration. The model decides whether to delegate, which task to give a child and how to combine the result. Configuration can limit the damage, but it does not make the process deterministic.

There is no public guarantee that Codex will automatically:

• choose the cheapest suitable model for each child;
• reduce reasoning effort for simple jobs;
• avoid sending unnecessary context;
• estimate the likely cost before spawning an agent tree;
• or follow a finite workflow graph with a predictable termination point.

This is where Theo’s comparison with code-defined Claude Code workflows remains relevant. A workflow written as a program has explicit stages and a clear end. Codex’s agent tree can be more flexible, but flexibility also creates more opportunities for duplicated work, runaway delegation and difficult-to-explain usage.

Codex is also carrying both V1 and V2 multi-agent systems, along with compatibility and migration logic. The repository shows substantial work to make that transition reliable, but the coexistence itself adds complexity.

Most importantly for normal users, the better subagent defaults are not yet in the latest stable 0.144 release. At the time of writing, they are in the 0.145 prerelease line. That makes them evidence of direction, not proof that the everyday stable experience is already solved.

There is no conventional public roadmap#

OpenAI does not maintain a simple public page saying which Codex features will ship in which version and on what date.

The practical roadmap is the repository itself:

1. merged pull requests on main;
2. alpha release tags;
3. stable release notes;
4. maintainer comments on larger issues such as per-agent configuration.

That makes it possible to see the direction, but difficult to know when work will be considered complete. Features can merge, change shape during alpha testing or remain behind model metadata and feature flags before reaching most users.

The visible direction is nevertheless clear: OpenAI is investing in per-agent configuration, persistent parent-child relationships, better agent navigation, shared budgets and a common runtime that can support the CLI, desktop app and other Codex clients.

Was this all caused by the backlash?#

Probably not.

The timeline suggests two things happened at once.

The subagent configuration work was already moving. The unified agent settings and functional default model controls were merged on 16 July, around the same day Theo’s video appeared. Changes of that size would have been designed and implemented before the public upload.

The narrow GPT-5.6 prompt hotfix landed two days later and maps much more directly to the immediate criticism. It may have been accelerated by the discussion, but OpenAI has not confirmed that publicly.

The fairest conclusion is not that one creator forced OpenAI to rebuild Codex in a weekend. It is that the criticism identified real weaknesses at a moment when the Codex team was already working on them, and the prompt controversy appears to have received a fast response.

What I would do as a Codex user#

For a normal daily workflow, I would stay on 0.144.6 or newer stable releases. The corrected GPT-5.6 context metadata and refreshed instructions are worth having.

I would not move a critical project to a 0.145 alpha solely for the subagent settings. Alpha builds can contain other unfinished protocol and interface changes, and the gain is not worth introducing unrelated instability unless you are intentionally testing Codex.

When 0.145 reaches stable, I would configure three things immediately:

1. a conservative maximum number of concurrent agent threads;
2. a cheaper default model for general subagents;
3. a lower default reasoning effort for routine delegated work.

Until then, I would avoid combining Ultra reasoning with a large concurrency limit unless the task genuinely justifies the cost.

The verdict#

The improvements are too closely aligned with the criticism to dismiss as pure coincidence, but they are also too substantial to have all been invented after one video.

OpenAI has already:

• replaced the bundled GPT-5.6 instructions in stable;
• corrected the affected context windows;
• added shared token budgets and delegation modes;
• built functional default model and reasoning controls for subagents;
• unified concurrency settings;
• and continued cleaning up multi-agent lifecycle and TUI behaviour.

What it has not yet delivered is a predictable, automatically cost-efficient orchestration system that removes the need for users to manage those settings themselves.

So the answer is yes, OpenAI is fixing Codex CLI. The more accurate status, however, is actively being repaired rather than finished.

The wider lesson is bigger than Codex. A strong model can still feel weak inside a poor harness, while a carefully designed harness can make the same model feel dramatically more capable. Model benchmarks matter, but the instructions, tools and orchestration around the model are part of what users are actually buying.