Stop Burning Through Your Codex Pro Plan: A Simple Config Change That Can Cut Token Usage by 50%

Most people think they’re running out of Codex Pro credits because they’re using bigger prompts. That’s usually not the real problem.

The real culprit is something happening behind the scenes every time Codex decides to create a subagent.

If you’ve been running GPT-5.6 Sol Ultra and wondering why your usage disappears so quickly, this article might save you a lot of money.

Let’s look at what’s actually happening.

The Hidden Problem

Imagine you’re managing a software team.

You’re the project manager.

Instead of doing everything yourself, you assign work to three engineers.

Now imagine every engineer earns exactly the same salary as you.

Not only that…

Each engineer also hires four more engineers.

Your payroll suddenly explodes.

That’s essentially what happens when you run Codex with GPT-5.6 Sol Ultra.

When the parent agent creates subagents, those subagents inherit the same model and reasoning level.

That means if your main agent is:

GPT-5.6 Sol
Reasoning: Ultra

Every spawned agent also becomes:

GPT-5.6 Sol
Reasoning: Ultra

Three subagents?

You’re now paying for four Ultra models simultaneously.

And Ultra itself can internally use additional reasoning, making it even more expensive.

Why This Matters

Suppose your task looks like this:

Build a REST API
├── Search project files
├── Update documentation
├── Write tests
└── Fix a bug

Codex might decide to delegate those jobs.

Without configuration:

Main Agent
   │
   ├── Sol Ultra
   ├── Sol Ultra
   ├── Sol Ultra
   └── Sol Ultra

Everything runs at maximum cost.

But do you really need an Ultra reasoning model just to search files?

Probably not.

The Better Idea

Think of your AI agents like employees.

Not every employee needs to be the CEO.

You only need one person making the important decisions.

Everyone else simply follows instructions.

A much smarter architecture looks like this:

Orchestrator
          GPT-5.6 Sol Extra High
                    │
     ┌──────────────┼──────────────┐
     │              │              │
Fast Scanner   Routine Worker   Deep Worker
 Terra High     Sol Medium       Sol High

Each model has a specific job.

Instead of throwing expensive reasoning at everything, you use the right tool for the right task.

The Three-Agent Setup

Create three custom agents.

1. Fast Scanner

Purpose:

• searching files
• reading code
• exploring repositories
• gathering information

Configuration:

name = "fast_scan"
model = "gpt-5.6-terra"
model_reasoning_effort = "high"
sandbox_mode = "read-only"

Instructions:

Gather evidence quickly.
Return a concise summary.
Never edit files.

This agent only looks around.

2. Routine Worker

Purpose:

• writing code
• documentation
• tests
• simple bug fixes

Configuration:

name = "routine_worker"
model = "gpt-5.6-sol"
model_reasoning_effort = "medium"

Instructions:

Implement the assigned task.
Verify the result.

Medium reasoning is more than enough for routine implementation.

3. Deep Worker

Purpose:

• architecture
• security
• complex debugging
• difficult multi-step reasoning

Configuration:

name = "deep_worker"
model = "gpt-5.6-sol"
model_reasoning_effort = "high"

Instructions:

Validate assumptions.

Handle complex work carefully.
Verify everything.

Only the difficult tasks reach this agent.

Teaching Codex When to Use Each Agent

The magic happens inside your routing policy.

Instead of manually choosing models every time, Codex can decide automatically.

The routing logic is surprisingly simple.

Is this task read-only?
        │
       Yes
        │
        ▼
Fast Scanner

No
 │
 ▼
Is this a routine coding task?
        │
       Yes
        │
        ▼
Routine Worker
No
 │
 ▼
Complex debugging?
Architecture?
Security?
Multi-step reasoning?
        │
       Yes
        │
        ▼
Deep Worker

Everything else stays on the main orchestrator.

Ask Codex to Build It

Instead of manually editing every configuration file, you can simply ask Codex to do the work.

Paste the following prompt into Codex.

Read my current ~/.codex/config.toml and the docs at
https://developers.openai.com/codex/subagents
Then:
1. Create three agents:
fast_scan
routine_worker
deep_worker
2. Configure their models and reasoning effort.
3. Update config.toml with routing rules.
4. Set:
max_threads = 6
max_depth = 1
5. Show every generated file before saving.

After restarting Codex, the new agents load automatically.

What Changes After the Fix?

Before:

Main Agent
      │
      ├── Sol Ultra
      ├── Sol Ultra
      ├── Sol Ultra
      └── Sol Ultra

After:

Main Agent
      │
      ├── Terra High
      ├── Sol Medium
      └── Sol High

Exactly the same workflow.

Much lower token usage.

Why Use Sol Extra High Instead of Ultra?

This surprises many people.

Ultra sounds like the obvious choice.

But benchmark data tells a different story.

Artificial Analysis tested every GPT-5.6 reasoning level.

Their combined benchmark shows:

Sol Extra High
Score: 58
Sol Max
Score: 59

One point.

That’s it.

Yet Max can consume roughly three times the tokens.

For planning and orchestration, Extra High delivers almost the same quality while using significantly fewer resources.

Ultra goes even further.

It’s designed for the hardest reasoning tasks, not everyday coding sessions.

Why Sol Medium Is Enough for Coding

Most programming work isn’t inventing new computer science.

It’s implementing instructions.

Examples include:

• writing tests
• fixing bugs
• creating endpoints
• updating documentation
• refactoring functions

Medium reasoning is already capable of handling these tasks effectively.

Using High or Ultra for every implementation is like hiring a neurosurgeon to change a light bulb.

Why Terra Beats Luna

Many people immediately choose Luna because it’s cheaper.

That’s only looking at token price.

Real-world coding benchmarks paint a different picture.

Imagine two developers.

Developer A:

• finishes work in 76 steps

Developer B:

• finishes in 102 steps

Even if Developer B charges less per hour, the total bill can still end up higher because they take much longer.

That’s essentially the Terra vs. Luna story.

Terra consistently finishes engineering tasks in fewer steps, retains more context across large codebases, and performs much closer to Sol.

For read-only exploration, Terra offers one of the best cost-to-performance ratios.

Your Final Architecture

Here’s the recommended setup.

Main Session
GPT-5.6 Sol
Reasoning:
Extra High
↓
Fast Searches
GPT-5.6 Terra
High
↓
Routine Coding
GPT-5.6 Sol
Medium
↓
Complex Problems
GPT-5.6 Sol
High

The Bottom Line

Most developers aren’t wasting tokens because their prompts are too long.

They’re wasting tokens because every subagent inherits the most expensive model.

A small change to your config.toml lets Codex route work more intelligently.

Use:

• GPT-5.6 Sol Extra High as the orchestrator that plans and delegates.
• GPT-5.6 Sol Medium for everyday coding, tests, documentation, and bounded fixes.
• GPT-5.6 Terra High for lightweight read-only exploration and codebase scanning.
• GPT-5.6 Sol High only when a task genuinely requires deeper reasoning.

The result is a workflow where the right model handles the right job. You spend fewer tokens on routine work while preserving strong reasoning for the problems that actually need it.

Set it up once, restart Codex, and let automatic routing do the rest.