How to Actually Use GPT-5.6 Sol Without Wasting Credits

GPT-5.6 Sol is genuinely impressive. It's also, for a lot of people, a constant lesson in how fast $200 of credits can disappear.

The quota management. Three models with different costs and limits. An Ultra mode that burns through your 5-hour window faster than you expect. A fast mode that sounds efficient and costs 2.5x more.

The models got better. The overall experience somehow feels worse.

The problem isn't Sol. It's where most people are running it.

I've been writing about AI orchestration all week - Fable as the brain, cheaper models doing the execution. Then Sol launched and the same principle applied in a direction nobody expected: Claude Code is a better environment for running GPT-5.6 than OpenAI's own Codex tool.

Same model. Different harness. Meaningfully different results. This guide covers exactly why, and exactly how to set it up.

Most people talk about GPT-5.6 as one model. It's three.

Sol, Terra, and Luna are distinct models within the 5.6 family, each built for a different layer of the work:

Luna - everyday coding. Fast, capable, cheapest to run. The default for ground-level implementation tasks.

Terra - bigger features and repo-wide changes. A step up in capability when Luna hits its ceiling.

Sol - planning, architecture, and final review. The judgment layer. The model you bring in when the problem requires real reasoning about what to build before building it.

This hierarchy matters because it creates a natural orchestration structure. Sol doesn't do the coding. Sol decides what gets built, reviews what came back, and signs off before it ships. Terra and Luna do the work.

When you run Sol inside Codex, that hierarchy breaks down. When you run it inside Claude Code, it works exactly the way it's supposed to.

The issue isn't that Codex is bad. The issue is one specific behavior that makes the 5.6 family expensive and unpredictable to run.

When Sol spawns a subagent in Codex, that subagent inherits the same model and the same effort level as the parent instance. Run Sol at Ultra and every subagent is also Sol at Ultra. Your quota doesn't drain in hours. It drains in minutes.

This is a documented open issue with over 110 reactions on GitHub and no fix yet.

Ultra makes it worse. Ultra isn't a reasoning level despite where it sits in the UI. It's a parallel multi-agent mode that spins up multiple agents simultaneously. Combined with the effort inheritance bug, running Ultra is the fastest way to burn through your entire 5-hour window on a single task.

Fast mode compounds the problem. Fast mode uses 2.5x as many credits. With GPT-5.5, a single message used between 0.1% and 2% of your limits. With 5.6, which runs far longer before stopping, a single message can consume 15% of your window. At fast mode's 2.5x multiplier, that's 40% of your 5-hour window gone in one shot.

The result: constant quota management instead of actual work. Three models to track, effort levels to monitor, subagents spinning up at the wrong tier, credits disappearing before you understand why.

Claude Code gives you control over what each subagent runs at. The model right-sizes the work instead of burning through credits on autopilot.

When a subagent spins up inside Claude Code, you choose the model and the effort level independently from the parent session. Sol can orchestrate a Terra subagent at medium effort for a feature build, and a Luna subagent at low effort for a quick code check. The expensive model stays at the top. The cheap models do the volume.

This is the harness difference that produces better results. It's not that Sol is smarter inside Claude Code. It's that Claude Code lets Sol work the way it's designed to work - as a judgment layer, not as the model that does everything at every tier.

Theo, who has burned over $200,000 of tokens with GPT-5.6 and knows the cost of every mistake, put it directly: if you have a Fable subscription, let Fable drive. Teach it how to spawn Sol as a subagent. The result is a three-tier system that costs a fraction of running Sol for everything.

This is the architecture that actually works.

Fable 5 at the top: The orchestrator. Reads the goal, writes the execution brief, decides which model handles which part of the task, reviews the final output. Fable emits judgment, not volume.

Sol in the middle: Planning, architecture decisions, technical review. Sol handles the parts of the task that require deep reasoning - not the implementation, the thinking about what to implement. At high effort, not Ultra.

Terra and Luna at the bottom: Terra for bigger feature work. Luna for everyday coding and mechanical tasks. These are the models filling the page while Sol and Fable barely produce tokens.

The cross-vendor bonus applies here too. Fable reviewing Sol's output catches what Sol might miss, because different model families have different blind spots. You're not just saving money. You're building in a second perspective at every layer.

I set this up between two lectures on Thursday. By the time I was back at my desk, the first task had run through all three tiers and come back clean. Fable reviewed Sol's plan. Sol reviewed Luna's implementation. The final output had been checked twice before I read a word of it.

This is the practical section. The decisions you make here determine whether you get great output or a drained quota.

Avoid Ultra entirely for now. It's not a reasoning level. It's a parallel multi-agent mode with documented bugs that cause runaway subagent spawning. The fix when it ships will be worth revisiting. Until then, leave it alone.

The effort recommendations that work:

Avoid fast mode for now. 5.6 runs far longer than 5.5 before stopping. Fast mode's 2.5x multiplier on a model that can consume 15% of your window in a single message is a combination that burns through quota in ways that are genuinely hard to predict.

Add this to your AGENTS.md:

This controls 5.6's eagerness to spin up agents without being asked. Sol in particular is very willing to spawn subagents. This instruction keeps it from making that decision on its own.

Use clear stop points in your prompts:

5.6 can run for a long time and complete complex tasks end to end. That's mostly good. It also means it can overshoot. Clear stop points let you check the work at each stage before committing tokens to the next one.

Two paths. Pick based on how technical you're comfortable getting.

OpenAI shipped the official Codex plugin for Claude Code in March 2026. It hit 20,000 stars in nine weeks. Three commands:

Once installed, three commands become available:

→ /codex:review - Sol reviews the current work → /codex:adversarial-review - Sol challenges its own output → /codex:rescue - Sol diagnoses a stuck or broken task

This is the non-technical path. Install the plugin, use the commands, Claude Code handles the rest.

For users who want Sol as the primary model behind their entire Claude Code session:

This uses CLIProxyAPI or the claude-code-proxy (raine/claude-code-proxy on GitHub). The Claude Code harness stays intact - agents, tools, UX - with Sol as the model running behind it. Type claudex instead of claude to start a Sol session.

Running Sol for everything inside Codex costs $5 per million input tokens and $30 per million output. Fable at $10/$50 is more expensive per token but emits far fewer tokens when used as a pure orchestrator.

The combination that makes financial sense:

The expensive models barely talk. The cheap models fill the page. The overall cost per session drops significantly compared to running Sol for everything through Codex at the wrong effort levels.

One note: OpenAI recently lifted the 5-hour usage limit temporarily and is rolling out an efficiency update that will reduce Sol's token consumption across the board. The exact impact hasn't been published yet. When it is, the cost math gets even more favorable.

If you're already on Codex Pro: install the plugin today. Three commands, done in two minutes. You keep your Codex subscription but route Sol's judgment through Claude Code's harness where you control the subagent tiers.

If you're already in Claude Code: set up the proxy approach and add the AGENTS.md instruction. Run your first task with Sol high as the review layer and Luna handling the implementation. Watch the effort levels stay where you set them.

If you're on the fence about the setup: try one task with the Codex plugin. Run /codex:adversarial-review on something Sol just produced. See what it catches.

The models are good enough to use from any harness. The harness determines whether you control the cost or the cost controls you.

If this changes how you're running 5.6, share it with one person still burning through quota on Ultra.

That's all I'm asking.

Become a paying subscriber to get access to this post and all other premium content.