GPT-5.6 Sol Is the Best Agent OpenAI Has Shipped. It Also Burns Your Entire Token Allowance Through Subagents You Never Chose.

$5 per million input tokens. $30 per million output. That’s GPT-5.6 Sol — the most capable model in OpenAI’s new three-tier family, and the one you get whether you wanted it or not.

OpenAI shipped GPT-5.6 as a pricing story. Sol for hard reasoning. Terra ($2.50/$15) for mid-range work. Luna ($1/$6) for the background tasks that make up the bulk of real token volume. The pitch is route-and-save: let expensive models handle hard problems, let cheap ones do everything else. It’s the entire economic argument for the family. One community-modeled routing split — Luna on 85% of tokens, Terra on 12%, Sol on 3% — would cut costs by roughly 80% compared to running everything on one model.

Except Codex CLI’s multi-agent surface makes routing impossible. Every subagent Sol spawns inherits Sol’s pricing. Not because the runtime can’t do it. Because two compounding defaults quietly disable the feature, and the escape hatch is locked behind a backend that rejects your configuration.

The Tiered Family That Exists for Routing

Three models, one release. Sol at $5/$30 — frontier reasoning, the one that headlines benchmarks. Terra at $2.50/$15 — the middle child, capable enough for most agentic work at half the price. Luna at $1/$6 — the budget option, meant for the repetitive background tasks that eat tokens without needing frontier intelligence.

The economics are straightforward. If you’re running an agent that decomposes a complex task into twenty subtasks, you don’t need Sol for each one. Web research doesn’t require Ultra-tier reasoning. File exploration doesn’t either. The entire point of tiering is that the hard reasoning happens once — at the top — and the subtasks get routed to whatever model is cheap enough to make the work affordable.

This isn’t a value-add. It’s the reason the family exists as a family instead of a single model. Without routing, Sol/Terra/Luna is just three separate models that happen to share a release date. With routing, it’s a cost architecture — and one that makes a $30-per-million-output model affordable in practice, because most of your volume lands on something that costs $6.

Consider what a typical agent session looks like. You hand Sol a task: “refactor the authentication module and update the tests.” Sol plans, decomposes, and spawns children. One reads the existing auth code. Another searches for breaking changes in the framework docs. Another runs the test suite. Another writes a summary of what changed. Of those four subtasks, only the planning genuinely benefits from Sol-tier reasoning. The file reading, the web searching, the test running — those are exactly what Luna was built for.

Where the Tokens Actually Live

Codex CLI’s spawn_agent tool lets Sol break a complex task into pieces and delegate. Each child operates independently, reports back, and the parent synthesizes results. That’s the pattern that makes multi-agent systems worth running — decomposition, parallelism, specialization.

It’s also where 90% of token volume lives. Not in the parent’s reasoning. In the children. A real engineering session with Sol Ultra can spawn 150 to 200 subagents. Each one consuming input tokens, generating output tokens, holding context windows open while it works. The parent does the thinking. The children do the fetching, searching, testing, reading — exactly the work that Luna was priced for.

If those children ran on Luna pricing, the session economics work. If they run on Sol pricing — five times the input cost, five times the output cost — the math gets ugly fast.

The Two Defaults That Break Everything

Here’s where it falls apart. Codex CLI ships with hide_spawn_agent_metadata set to true by default. This setting strips the spawn_agent tool schema of four fields: model, reasoning_effort, agent_type, and service_tier. The agent literally cannot see that model selection is an option. It doesn’t know the parameter exists. So it never tries to pass it.

Even if it did — even if the agent somehow guessed that model: "gpt-5.6-terra" was available — the default fork_turns setting blocks the override. fork_turns controls how a spawned agent inherits the parent’s context. The default is full-history fork, and full-history forked agents are hardcoded to inherit the parent’s model, reasoning effort, and agent type. The override only works with fork_turns: "none", which means the child starts fresh with no parent context. Nothing in the documentation teaches this. Nothing in the tool schema hints at it. The agent has no way to discover it.

Two defaults. One hides the option. The other blocks it even if you find it. Together they make the routing layer functionally inaccessible — not through a design decision you can argue with, but through two quiet configuration values that compound on each other.

This was documented across three GitHub issues filed on July 10, 2026 — #31814, #31893, and #32031 on the openai/codex repository. Issue #32031 includes a community-submitted patch with passing tests. The pull requests remain staff-only. The fix requires a coordinated backend schema update, not just a client-side toggle.

The Escape Hatch That Doesn’t Work

You might think: just flip hide_spawn_agent_metadata to false in the local config. Override the default. Expose the schema. Let the agent see its options.

It doesn’t work. Under ChatGPT authentication — which is how most Codex CLI users run — the backend rejects schema deviations. The error message is explicit: “Function ‘collaboration.spawn_agent’ is reserved for use by this model and must match the configured schema.” The backend enforces the hidden schema. Your local config is ignored.

So the setting exists in the codebase. You can change it. The change means nothing. The backend overrides your override. The entire escape route is a door that looks functional from the outside but is bolted shut from the other side.

What This Costs

Fifty subagents at Sol pricing, each generating roughly 48,000 output tokens: about $72. Same work at Luna pricing: $14. Five times cheaper.

Double it. One hundred subagents, ~5 million output tokens. Sol: $150. Luna: $30.

A heavy session — 200 subagents, the kind a real engineering day produces when an agent is iterating through a complex codebase — runs about 10 million output tokens. At Sol’s $30 per million: $300. The same work on Luna: $60. That’s the difference between a sustainable workflow and one that burns through a ChatGPT Pro subscription’s entire token allowance in a single sitting.

| Subagents | Output tokens (est.) | Cost at Sol | Cost at Luna | |—|—|—|—| | 50 | ~2.4M | ~$72 | ~$14 | | 100 | ~5M | ~$150 | ~$30 | | 200 | ~10M | ~$300 | ~$60 |

These aren’t hypothetical numbers. Users on X confirmed the pattern within hours of GPT-5.6’s release. @ashutosh_270497 reported 15+ hours with Sol and noted tokens burn faster even on Medium effort, calling the Plus plan “useless now.” @arb5z described Sol as consuming tokens like a Fable 5 while performing like an Opus 4.8 — expensive hardware running mid-tier output. @evi77ain (Eidzoku) identified the root cause directly: the spawn_agent tool doesn’t let you choose the model or reasoning effort, so every subagent Sol Ultra spawns is another Sol Ultra instance. @dedene (Peter Dedene) put it plainly: it can’t spawn smaller subagents for basic exploration or web research and forces Sol for everything.

Tibo (@thsottiaux) — OpenAI staff on Codex & ChatGPT — reset rate limits twice in 24 hours and told users to “rejoice.” When the people who built the infrastructure are resetting their own limits twice in a day, something is wrong with the burn rate.

Two hours later, Tibo posted a longer acknowledgment: “We didn’t get everything quite right.” He listed specific admissions: “We made it too easy to use the highest-compute settings without making the impact on usage limits sufficiently clear” and “We introduced regressions for some existing multi-agent workflows.” The fix, he said, includes “changing defaults and the model picker so they don’t push people toward unnecessarily expensive settings.” A larger set of improvements is promised for the following week.

That’s OpenAI confirming the core problem: the defaults pushed users toward expensive settings, and multi-agent workflows regressed. Whether the fix addresses the hide_spawn_agent_metadata schema specifically remains to be seen. “Changing defaults” could mean hiding Ultra behind a confirmation. It could mean exposing model selection in spawn_agent. Until the next update lands, the routing bug is still live.

The Patch That Exists But Can’t Ship

The community patch is real. The branch exists, the tests pass, the fix is small — expose the model parameter, default fork_turns to none when overrides are present. The runtime already supports it. The schema fields already exist in the code. They’re just hidden by default and blocked by backend enforcement.

But the pull requests to openai/codex are restricted to staff. And the fix isn’t purely client-side — it requires the backend to stop rejecting schema deviations for authenticated users. That’s a coordinated change across two surfaces, and OpenAI’s acknowledgment — while welcome — didn’t commit to a timeline for the schema fix specifically.

The Fix Is Small. The Silence Is Loud.

The engineering fix is a handful of lines: expose model and reasoning_effort in the spawn_agent schema, default fork_turns to none when an override is provided, and stop rejecting authenticated schema deviations on the backend. None of this requires new infrastructure. It requires unblocking what’s already built.

The economic fix is the entire point of the three-tier family. GPT-5.6 Sol is a genuinely impressive agent — strong reasoning, good tool use, capable of the decomposition-and-delegation pattern that makes multi-agent systems work. It’s also priced to be used sparingly, and the tiered family was supposed to make that possible. Shipping the routing surface with routing disabled in the exact layer where token volume concentrates defeats the purpose. You don’t sell someone a fuel-efficient car and then weld the gear shift into first gear.

The community has identified the problem. The community has written the patch. The community has filed the issues. What remains is a decision from OpenAI: does tiered routing work in practice, or only in the pricing table?