You paid $200 for Codex Pro.
You hit your limit in 4 hours.
4 hours of a 5-hour window. Gone.
And the worst part?
Most of that burn was completely avoidable.
I’ve burned over $200,000 of tokens on GPT-5.6 Sol figuring this out.
Here’s everything I learned — so you don’t have to.
Why you’re burning limits so fast
One setting. One bug. Costing you everything.
When Codex spawns subagents, it copies the parent model exactly.
Set Sol to Ultra? Every subagent also runs Sol Ultra. 3 subagents on one task = 3 Sol Ultra instances burning simultaneously.
That is why your 5-hour window disappears in 90 minutes.
The Codex spawn_agent tool has no option to pick a different model for child agents.
It just clones whatever you’re running.
This is not your fault. It’s a routing flaw in the system.
But now you know. And there’s a fix.
Model you should never touch
Ultra.
Not a reasoning level. A multiplier.
Ultra spawns 4 parallel sub-subagents inside a single agent call.
On a simple task: subagents spawning subagents spawning more subagents.
Recursive. Uncontrolled. Ruinously expensive.
The performance difference?
Sol Ultra scores 91.9% on coding benchmarks. Sol Extra High scores 88.8%.
3.1 extra points. 3x the cost.
OpenAI didn’t even publish Ultra results for their two main coding benchmarks.
That should tell you everything.
Avoid Ultra entirely. Full stop.
3-model system that fixes everything
You need three agents doing three different jobs.
Not one model doing everything at max power.
Sol Extra High → The Orchestrator
Plans. Architects. Delegates. Makes the hard decisions.
This is your main brain. The one that reads your prompt and figures out what needs to happen.
Extra High gives you 58/100 on benchmarks. Max gives you 59/100. One point difference. Three times cheaper.
Extra High is the right call here.
Sol Medium → The Executor
Writes code. Fixes bugs. Runs tests. Implements the plan.
Sol Medium still beats Claude Fable 5 by 11.4 points on long-running agent workflows.
At roughly a quarter of the cost.
It doesn’t need to make architectural decisions. It just needs to follow instructions well. Medium does that perfectly.
Luna Extra High → The Scanner
File searches. Codebase exploration. Lightweight reads. Evidence gathering.
Luna at Extra High is:
→ 1.3x faster than Terra
→ 2.5x cheaper than Terra
→ Same performance on lightweight tasks
This is the sleeper pick most people miss.
Luna looks cheap on paper ($1/$6 per million tokens) but burns more steps than Terra.
At Extra High, that step count drops. It becomes the obvious choice for read-only work.
Sol + Luna routing trick (48 hours, zero limits hit)
Here’s the exact setup that runs continuously without burning your window:
→ Sol Extra High writes the plan
→ Luna Extra High executes it
→ Sol Extra High reviews the output
That’s it.
One loop. No recursive spawning. No Ultra clones burning in the background.
The person who shared this ran it for 48 hours straight without hitting the 5-hour limit once.
The reason it works: Sol stays focused on decisions. Luna handles the token-heavy execution work at 2.5x cheaper rates. The total token burn drops dramatically even though you’re doing more.
Your
setting to add right now:
Only spawn subagents when I explicitly ask you to. Do not spawn subagents automatically.This stops Sol from eagerly spinning up agents on every task.
Add it to your global
and restart Codex.
Fix your config.toml in 5 minutes
This is the actual file that controls everything.
Codex reads it on startup.
Set it once. Every session after routes automatically.
Open Codex. Paste this prompt exactly:
Read my current ~/.codex/config.toml and the docs at
https://developers.openai.com/codex/subagents
for custom agent definitions.
Then do the following:
1. Create three agent TOML files under ~/.codex/agents/:
fast_scan - for quick searches, codebase exploration, file reads, and lightweight analysis. - model: gpt-5.6-luna - model_reasoning_effort: extra-high - sandbox_mode: read-only - Instructions: gather evidence quickly, return a concise summary, do not edit files.
routine_worker - for routine coding, tests, documentation, and bounded fixes. - model: gpt-5.6-sol - model_reasoning_effort: medium - Instructions: implement the assigned task and verify the result.
deep_worker - for difficult debugging, architecture, security, and ambiguous multi-step work. - model: gpt-5.6-sol - model_reasoning_effort: extra-high - Instructions: handle complex work carefully, validate assumptions, provide strong verification.
2. Update the [agents] section of my config.toml with this routing policy:
"Automatically decide whether delegation is useful. Choose fast_scan for lightweight read-only work, routine_worker for normal implementation, and deep_worker for complex or high-risk reasoning. Do not ask the user to choose a model unless the required model is unavailable. Keep simple tasks on the main agent."
3. Make sure max_threads = 6 and max_depth = 1 are set under [agents].
4. Show me the final config.toml and all three agent files so I can review before you save."Codex creates every file. You review. You save. Done.
What your 3 agent files look like
Codex generates these automatically from the prompt above.
Here’s what they should look like — so you know what to review
# ~/.codex/agents/fast-scan.toml name = "fast_scan" description = "Quick searches, codebase exploration, lightweight read-only analysis." model = "gpt-5.6-luna" model_reasoning_effort = "extra-high" sandbox_mode = "read-only" developer_instructions = """ Gather evidence quickly and return a concise summary. Do not edit files. """
# ~/.codex/agents/routine-worker.toml name = "routine_worker" description = "Routine coding, tests, documentation, and bounded fixes." model = "gpt-5.6-sol" model_reasoning_effort = "medium" developer_instructions = """ Implement the assigned bounded task and verify the result. """
# ~/.codex/agents/deep-worker.toml name = "deep_worker" description = "Difficult debugging, architecture, security, and ambiguous multi-step work." model = "gpt-5.6-sol" model_reasoning_effort = "extra-high" developer_instructions = """ Handle complex work carefully, validate assumptions, and provide strong verification. """
# ~/.codex/config.toml - [agents] section [agents] max_threads = 6 max_depth = 1 routing_policy = """ Automatically decide whether delegation is useful. Choose fast_scan for lightweight read-only work, routine_worker for normal implementation, and deep_worker for complex or high-risk reasoning. Do not ask the user to choose a model. Keep simple tasks on the main agent. """max_depth = 1 is critical.
It stops subagents from spawning their own subagents.
One level of delegation. No recursive spawning. No runaway burns.
How to write prompts that don’t burn limits
The model will keep going.
And going.
And going.
5.6 can complete tasks end to end without stopping. That’s mostly good.
But without clear stop points, it overshoots. Rewrites things it didn’t need to. Burns through 15% of your window on a task that needed 3%.
Add stop points to every prompt:
For planning tasks:
Build this new feature. Start by writing a plan only. When the plan is done, stop and ask for my feedback. Do not write any code yet.For implementation tasks:
The plan looks great. Build it out now. Use computer use to test as you go. Keep going until tests pass and you're satisfied. Open a PR when done. Stop after the PR is open. I'll handle reviews from there.For debugging:
Fix the bug in auth.ts. Read the file first. Write your diagnosis. Stop and show me the diagnosis before making changes. I'll confirm before you proceed.The pattern: tell it exactly when to stop.
Not vague. Not “use your judgment.”
Explicit checkpoints. Clear handoffs back to you.
Effort level guide
Not all tasks need the same horsepower.
→ Low / Medium — routine tasks, simple fixes, documentation, tests
→ High — features, multi-file changes, debugging
→ Extra High — architecture decisions, security reviews, complex multi-step work
→ Max — save for genuinely hard problems you’ve already failed at
→ Ultra — avoid. Always.
The default for most developers: High.
It’s plenty capable. Subagents on High are “not too bad” on burn.
The daily driver recommendation from the Codex team: Sol Medium.
Sol Medium beats Claude Fable 5 on agent benchmarks. At a fraction of the price.
You do not need extra high for everything.
Effort level cheat sheet: Simple fix → Sol Low or Medium New feature → Sol High Hard problem → Sol Extra High Fast scan → Luna Extra High Never → UltraBenchmark numbers that explain everything
Sol Extra High vs Max: 58 vs 59 points. One point. Three times cheaper. Use Extra High.
Sol Medium vs Fable 5: Sol Medium wins by 11.4 points on agent workflows. At 4x lower cost.
Luna Extra High vs Terra: Same performance. 1.3x faster. 2.5x cheaper. Use Luna.
Ultra vs Extra High: 3.1 extra points. 3x more expensive. OpenAI didn’t even publish Ultra’s coding results. Use Extra High.
The pattern: one tier down = same quality, dramatically cheaper.
Most developers are running one or two tiers too high on everything.
That’s the entire reason limits disappear in 4 hours.
Drop one tier. Keep the same output. Double your active window.
Before and after
Before this setup:
→ Sol Ultra running everything
→ Subagents cloning parent model and effort
→ 3 subagents = 3 Sol Ultra instances burning simultaneously
→ 5-hour window gone in 90 minutes
→ No context on what burned it
After this setup:
→ Sol Extra High as orchestrator
→ Sol Medium for implementation
→ Luna Extra High for scanning
→ max_depth = 1 stopping recursive spawning
→ AGENTS.md telling Sol not to spawn agents automatically
→ Stop points in every prompt controlling how far the model goes
Result: 48 hours of continuous work. Zero limit hits.
Same $200 plan. Completely different experience.
Full setup checklist
Do these five things right now:
→ 1. Open AGENTS.md . Add: “Only spawn subagents when I explicitly ask you to.”
→ 2. Paste the config.toml prompt into Codex. Let it create the 3 agent files.
→ 3. Set max_depth = 1 and max_threads = 6 in your config.toml.
→ 4. Switch your default effort to Sol High. Not Ultra. Not Extra High for everything.
→ 5. Add explicit stop points to every long-running prompt.
Takes 10 minutes.
Saves you hours of burned limits every single week.
One more thing
Spend time in ~/.codex and ~/.claude.
These directories are where the real power lives.
Custom agents. Routing policies. Model preferences. Default instructions.
Most people never open them.
The developers getting the most out of Codex right now?
They’ve made changes that felt stupid and were surprised how much it mattered.
Experiment. Adjust. Monitor your usage through the Codex dashboard.
Small config changes compound into dramatically different token burn rates.
This is the most fun time to be building with AI.
The tools reward the people who actually dig in.
If this saved your limits:
→ Repost so other Codex Pro users see it before they burn another window
→ Follow @sairahul1 for more AI system breakdowns
→ Bookmark this — the config prompt works, paste it tonight
Subscribe to theaibuilders.co
for more such interesting articles
I write about AI, building products, and systems that work without you.