The Truth About Codex Ultra Mode: It's Not a Reasoning Level

Article Content

When OpenAI released GPT-5.6, it introduced not only three new models but also two new "reasoning levels" — Max and Ultra — integrated into tools like Codex. The official description of Ultra is "the highest capability setting for orchestrating multiple agents across parallel workflows." Sounds powerful, but the truth is: Ultra is not a reasoning level at all — and its current implementation is frankly quite bad. Based on deep technical analysis from the developer community, this article reveals what Ultra mode actually is and exposes the many problems with Codex's sub-agent system.

What Is Ultra, Really?

When selecting a model in Codex's terminal interface, you see a list of reasoning level options: low, medium, high, extra high, max, and finally Ultra. This arrangement creates an intuitive impression — that Ultra is simply one notch above Max in reasoning intensity. But this is exactly where OpenAI is most misleading.

The best reference point for understanding Ultra is Claude Code's "Ultra Code" feature. Running /effort in Claude Code shows a similar list, with Ultra Code labeled underneath as "X high + workflows." That's the key: Ultra is not a reasoning level — it's a skill.

It works similarly to loading a skill via a slash command — appending the contents of a Markdown file to the system prompt, taking effect on the next incoming message.

What is a system prompt? In the conversation structure of modern LLMs like GPT and Claude, each request typically consists of three message types: system (system-level instructions), user (user input), and assistant (model response). The system prompt sits at the very top of the conversation, has the highest priority, and is used to define the model's role, behavioral boundaries, and operational norms. Developers can "soft-program" model behavior by modifying the system prompt without retraining the model. Ultra mode works exactly this way — it injects an additional instruction into the system prompt, telling the model to "spawn more sub-agents and adopt more complex workflows," rather than genuinely increasing the depth of underlying reasoning computation or chain-of-thought.

Skills vs. Prompt Engineering: In modern AI agent systems, a "skill" refers to a mechanism that grants the model specific behavioral patterns through structured prompt injection — essentially a modular encapsulation of advanced prompt engineering. Slash commands (like /effort or /skill) are a common interaction pattern for CLI tools exposing this type of functionality, typically backed by a Markdown or JSON file whose contents get appended to the system prompt. The advantage of this design is flexibility and extensibility; the downside is opacity — ordinary users can't perceive what instructions they're actually triggering. Ultra's problem is precisely this: it packages a "dynamically loaded instruction set" skill as an apparently equivalent "reasoning intensity level," conflating two fundamentally different capability dimensions.

Both Ultra and Ultra Code are essentially instructions telling the model to "use more sub-agents." In Claude Code, this is implemented via workflows; in Codex, it's accomplished through an agent mechanism internally called V1 and V2.

In short: Ultra switches the system prompt, not the model's depth of thinking.

Why Does Ultra Burn Through Your Quota?

The core issue with Ultra is token consumption. Before diving in, it's worth clarifying what Reasoning Effort actually means.

What is Reasoning Effort? Reasoning effort is a concept introduced with OpenAI's o1 and o3 series, referring to the computational depth of the model's internal "thinking" (chain-of-thought) before generating a final answer. Low reasoning effort means the model answers quickly; high reasoning effort means the model spends more tokens on self-verification, counterarguments, and corrections — these intermediate thinking steps are typically invisible to the user but consume significant compute. In essence, reasoning effort controls the number of "thinking tokens" the model invests before responding, representing a real difference in computational cost. In contrast, Ultra doesn't increase the thinking depth of any single inference — it scales horizontally (by spinning up more parallel agents) to broaden task coverage. The two approaches are fundamentally different: the former is "thinking deeper," the latter is "sending more people to do the work."

Max already consumes up to twice as many tokens as extra high while delivering only a 4–10% performance improvement on various benchmarks — the cost exceeds the benefit, and Max is rarely worth using on its own.

Ultra is even more extreme — it's essentially recursive Max with no upper bound. The root agent and all sub-agents are set to Max reasoning level. In theory, you could have the parent agent launch sub-agents at a lower reasoning level, but the current sub-agent version used by the Sol model doesn't support configuring reasoning levels for sub-agents individually. Once Ultra is enabled, all spawned sub-agents are also running at Ultra.

Why does token consumption explode? Tokens are the basic unit of pricing and computation for LLMs, roughly corresponding to ¾ of an English word or about 1.5 Chinese characters. In multi-agent architectures, token consumption grows multiplicatively rather than linearly. Each sub-agent typically needs to receive the full or partial context history, task description, and tool definitions — so N parallel sub-agents consume roughly N times the input tokens of a single agent. If the parent agent also passes the entire main thread history down to each sub-agent (as V2 does by default), context pollution combined with cache invalidation means a single task can consume tens of times more tokens than normal mode. Factoring in the roughly 2× token premium of Max reasoning level, Ultra's real-world consumption in extreme cases can be 20 to 50 times that of the base mode.

The consequences are shocking: some users running Ultra in fast mode exhausted their first 5-hour quota within 20 minutes, manually reset, and burned through it again in 40 minutes — hitting the 5-hour cap twice within a single hour.

Even more dangerous: OpenAI temporarily removed the 5-hour limit because users were hitting it so frequently. While well-intentioned, this backfired badly for Ultra users. The 5-hour limit had represented roughly 20–25% of the weekly quota — essentially an early warning system. With it removed, Ultra can now potentially destroy an entire week's quota in 90 minutes.

V1 and V2: The Messy Sub-Agent System

Codex currently has two sub-agent implementations, internally labeled V1 and V2. Since the Codex CLI is open source, you can inspect the code directly.

Multi-Agent Architecture Background: A multi-agent system is an architectural paradigm where multiple independent AI agents collaborate to complete tasks, and it represents the cutting edge of current AI engineering. Its core advantages lie in parallelization (multiple agents simultaneously handling different sub-tasks), specialization (different agents focused on different domains), and fault tolerance (one agent failing doesn't affect the whole). However, the engineering challenges are equally significant: the cost of synchronizing context between agents is extremely high, and without termination conditions, the system may recursively spawn new agents indefinitely. OpenAI's V2 and Anthropic's Workflows represent two fundamentally different design philosophies — the former pursues dynamic flexibility, while the latter emphasizes determinism and predictability.

V1: A Simple Dispatcher

V1 is a straightforward tool-call mechanism. Take reviewing three PRs as an example: the model can spawn three sub-agents, each handling one PR, which then report back their results, with the top-level agent deciding next steps. V1 is currently the default implementation in Codex and the only version that's relatively complete.

V2: Over-Engineered Team Collaboration

V2 is a complete rearchitecture, introducing the ability for agents to communicate with each other and spawn their own sub-agents. It uses a path-based naming scheme — a root sub-agent named research becomes /root/research, and its testing sub-task becomes /root/research/tests.

V2 also introduces a "mailbox" concept, allowing agents to send typed messages to each other, with parent agents able to append tasks to idle sub-agents or even interrupt them. It sounds impressive, but there are real problems:

• Uncontrolled context sharing: By default, the entire history of the main thread is shared with all sub-agents, significantly increasing costs and worsening context pollution.
• Cache invalidation: V2 filters tool calls by default, causing cache invalidation and further driving up costs. Prompt caching is a cost optimization mechanism offered by major LLM providers — when a request contains the same prefix content as a recent request, the server can reuse already-computed KV cache and skip redundant forward computation. V2 breaks prefix consistency in requests, forcing each sub-agent to compute the full context from scratch, making it impossible to benefit from Anthropic's cached token discount (which charges only 10% of the standard price).
• No depth limit: V2 can theoretically nest and spawn sub-agents infinitely (default: 4 running simultaneously) with no guaranteed termination.
• Forced routing: Through a new subagent version field in a hidden models cache JSON file, new models Sol and Terra are force-routed to V2 regardless of user configuration.

As one community member put it: "It feels like too many people were involved in designing V2, making it bloated."

The Right Approach: Claude Code's Workflows

OpenAI copied the wrong part — they replicated Claude Code's poor UX design of disguising Ultra as a reasoning level, but didn't learn from the genuinely excellent implementation: Workflows.

Workflows are a programmatic way to define sub-agent processes. Claude Code generates a JavaScript file that defines metadata (name, description, stages), a typed schema for what each stage should output, and prompts that can be programmatically inserted with context. For example, a five-stage process of "research, validate, synthesize, review, finalize" — each stage has clear responsibilities and predictable outputs.

The core advantage of Workflows is: they impose a hard ceiling on the entire process. Most sub-agent implementations over-rely on tool calls, requiring the model to maintain all context itself and continuously spawn new agents — making it trivially easy to run indefinitely. Workflows are "instantly hard-coded," but the number of stages is fixed, so they will always terminate. Even if one stage spawns dozens of sub-agents, the workflow still progresses through all stages to the end. This design delivers value across three engineering dimensions: observability (each stage's output has a clearly typed schema, making debugging easier), cost control (a fixed number of stages means token consumption has a predictable upper bound), and guaranteed termination (doesn't rely on the model itself deciding when to stop).

Codex's Ultra implementation is the opposite — it stops when the agent decides to stop, not when the task is complete, making it prone to running out of control.

Recommendations for Everyday Users

Three core recommendations:

• Avoid Ultra for now. The current implementation is rough, will burn through your quota aggressively, and the cost far outweighs the benefit.
• Trust the default settings. The new models are perfectly capable in normal use — only Ultra will destroy your quota.
• Give OpenAI some time. Ultra has already been hidden from the slider in the ChatGPT app, the Max option has been collapsed, and community feedback is being addressed quickly.

From the technical community to inside OpenAI, there's emerging consensus: Ultra should be a standalone toggle, not a tier in the reasoning level list, because Ultra is a skill, not a reasoning effort level.

Until there's an official fix, if you genuinely need multi-agent collaboration capabilities, the better path to explore is using GPT-5.6 directly in Claude Code with Workflows — that's the implementation that's actually been validated in practice.

Key Takeaways