GPT 5.6 Sol Is Slower and More Expensive

Short version, because you're building and don't have all day: the 5.6 rollout made Sol the default model for every task, and Sol is keener than 5.5 was to grind away in long tool loops without checking in. If, like me, you'd also cranked your reasoning effort up and left it there, your trivial jobs are now running on your most expensive model at a heavy thinking setting. So routine work got slow and dear, and nobody sent you a memo about it.

One thing up front, because I got this wrong myself and it matters: the vendor did not set your reasoning to extra-high. It made Sol the default model if you updated your Codex CLI to the latest version. The effort level is your call, and OpenAI's own default is medium ("if you omit it, GPT-5.6 defaults to medium," their words). A big chunk of my cost turned out to be self-inflicted, from a reasoning setting I'd bumped up. That's the good news, actually, because a setting you own is a setting you can fix.

I found this the ugly way, so here's a guide so you don't have to.

What actually changed

• The default model changed, not just the model. Anything you don't explicitly route now runs on Sol. That's your top-tier model, handling your easiest jobs by default.
• Your reasoning effort is probably too high, and that part's on you. The default is medium. In the Codex UI the ladder runs Low, Medium (default), High, Extra High, Max, Ultra (the API calls Extra High xhigh, if you set it in config). If you raised your reasoning effort to match what you were using on 5.5 and left it there, then that combination of top model plus high effort is what makes routine work bite.
• Sessions got slow. Jobs that used to return in a couple of minutes started taking most of an hour. Median session on my box was nine minutes, the tail ran over an hour, and the worst ran overnight.
• Sol runs longer unbroken tool loops. The longest run I could find on 5.5 across months was 77 consecutive tool calls. On 5.6 it hit 119, one agent circling on its own with no pause to think. I once caught a session that had spawned 47 sub-agents and run for twenty hours after finishing the actual task.
• The scary token number is fake. My tracker claimed 4.5 billion tokens in a day. It wasn't real. A counter was tallying cached context every turn as if it were new, so long sessions pile up an enormous number nobody paid. Real output was under a tenth of a percent of the headline. The cost problem is real; that particular figure is a measurement artefact, and if you're panicking at a billions-of-tokens dashboard, check whether it's counting cache before you do anything drastic.

What to stop doing

• Stop running everything on the default. If you haven't touched your model config since 5.5, every job is on Sol right now, and quite possibly at whatever effort you last set. That's the single most expensive mistake, and it's the default, so you've probably made it.
• Stop leaving reasoning effort where you set it for the last model. Effort is a dial you own, not something the vendor forced on you. Check it. Medium is the default; if you're above it for routine work, you're paying for thinking you don't need.
• Revisit your skills construction from GPT 5.5. Sol's behaviour is much more literal than 5.5. If you specified an exact list of instructions to follow per skill, it's going to do just that. 5.5 contextualized the skills related to the conversation far better (sometimes worse, but still) so it almost picked and chose what was required in the particular conversation context. 5.6 does not do that. Big ouch.
• Stop trusting your old session timings. "It's just launch-week load" is the excuse I used for a week. It wasn't load. If routine jobs got slow after the rollout, assume it's the model tier and how your skills are built, not the servers.
• Stop letting agents loop unbounded. Sol will happily circle on a finished task, versus 5.5 which stopped when things seemed done. Anything that can spawn sub-agents or retry needs a hard cap, or you'll find your twenty-hour session too.
• Stop dragging full context between steps. The cost is almost entirely re-fed context, not thinking. Any skill that hands whole transcripts to the next step is paying for the same tokens over and over.

What to change in your setup

• Route by task, not by default. Put a deterministic layer in front that reads the task and picks the model and effort to fit it. Routine delivery and waiting-on-CI go to the cheap fast model on low. Real implementation and review get Sol on high or extra-high. The big model comes out when the job needs it, not before. The CLI now caters for agent family and thinking effort invocation when spawning sub agents locally, so use that.
• Know what's native now and what still isn't, so you don't build the wrong thing. The plumbing has caught up: as of Multi-Agent V2 (CLI 0.145), spawning sub-agents with a per-agent model and reasoning effort, running them in parallel, and consolidating their results is native. If you're hand-rolling that primitive, stop, use spawn_agent and the agent config files. What is not native is the bit that actually solves this problem: a deterministic top-level router that reads a task and picks the cheapest adequate tier for the main session. That's still an open feature request, and "Ultra" is not it (Ultra runs parallel agents on one hard problem at a fixed tier, which makes hard work wider, not routine work cheaper). Also not native: a batch runner that drives a whole epic of kanban cards (if you use those) to completion with iteration caps and bounded handoffs. OpenAI's own answer there is "wire up your own queue and call codex exec," so if you want it, you're building it. That's the gap I ended up filling, and it's worth knowing it's a real gap before you decide whether to fill it too.
• Cap the loops. Give any long-running or fan-out skill a hard ceiling on iterations and sub-agents, and make it stop and say it's stuck rather than circle.
• Compact sooner and hand off small. Make skills drop tool output they don't need, compact context earlier (in spite of the context window increase), and pass short summaries between sub-agents instead of whole transcripts. On my setup, cutting retained tool output and forcing earlier compaction did more for cost than the model routing itself.
• Default your delivery skills to the cheap model in writing. Don't rely on remembering. Set the cheap model as the written default for delivery and CI-wait work, and only allow escalation to Sol for failures that genuinely cut across everything.

Building infrastructure is expensive

The fixes have their own bill. A router sits in the path of everything the agent does, so anything wrong with the router is wrong with everything. V1 of mine bricked on cold starts, launched agents pointed at stale checkouts over a permissions quirk, and broke interactive resume when Codex shipped a routine version bump my router was too rigid to follow. This was expensive, and I ended up having to use other agents (waves at Claude) to fix what Codex has gotten wrong/broken.

Two things to take from that:

• Budget for the fix hurting before it helps. The obvious fix for an operational problem is itself operational, with its own failure modes. It's still worth doing, a fix that holds for months earns a rough fortnight, but go in expecting the fortnight.
• When several things break the same week, don't assume one cause. The version-bump breakage had nothing to do with the model or the cost. It just arrived in the same fortnight and broke the same sessions, and I nearly wrote it up as "the new model broke interactive mode," which was flat wrong. Pull the threads apart before you blame anything.

The recurring bit

This is the same complaint I made last time about the relearning tax, so I'll keep it to one line: the vendor made the top model the default for everything, the cost of that landed on you unannounced in your environment, and there's no changelog for "your routine work is now slow and expensive." There should be.

Anyway. Route your cheap work to a cheap model, cap your loops, recheck your skills definitions, and go check two settings right now: your default model, which is probably Sol, and your reasoning effort, which is probably higher than the job needs.