Codex Is Secretly Burning Through Your Quota. Here’s the Hidden Subagent Problem

If you’ve been using Codex lately and wondering… “Why is my quota disappearing so fast?” You might assume you’re simply making too many requests.

But there’s another reason that isn’t obvious until you look at how Codex orchestrates subagents.

And it’s surprisingly simple.

Every Subagent Is Another Expensive AI

Codex can split work into multiple agents.

Imagine you ask it to build an application.

Instead of one AI doing everything, it might create separate workers.

• Agent 1 researches APIs.
• Agent 2 writes backend code.
• Agent 3 creates tests.
• Agent 4 reviews everything.

This sounds great.

The problem?

By default, every spawned subagent uses the same model as the parent agent.

If you’re using GPT-5.6 Sol Ultra, every new worker is also GPT-5.6 Sol Ultra.

That means expensive requests multiply very quickly.

Think of it like hiring five senior architects to paint five different walls.

Yes, the work gets done.

But you probably didn’t need five architects.

Why Your Quota Disappears

Imagine this workflow.

Main Agent (Sol Ultra)
        |
        +---- Research Agent
        |
        +---- Coding Agent
        |
        +---- Testing Agent
        |
        +---- Documentation Agent

You started one conversation.

Now you actually have five separate Sol Ultra instances running.

Each one consumes compute.

Each one counts against your quota.

That’s why heavy orchestration can become surprisingly expensive.

The Missing Feature

Naturally, you’d expect something like this:

spawn_agent(
    role="research",
    model="gpt-5.6-mini",
    reasoning="low"
)

Or perhaps:

spawn_agent(
    role="reviewer",
    reasoning="minimal"
)

Unfortunately…

That isn’t currently supported.

The spawn_agent tool doesn't expose parameters for selecting:

• model
• reasoning effort

during the spawn call itself.

So every spawned worker inherits its configuration from somewhere else.

Can You Change the Reasoning Level?

Yes.

But not directly inside spawn_agent.

Instead, you configure different agent roles.

Think of a role as a template.

Instead of saying:

Spawn a new agent with low reasoning.

You say:

Spawn my “researcher” role.

That role already knows which model and reasoning level it should use.

Step 1: Create an Agent Role

Inside your Codex configuration:

# ~/.codex/config.toml
[agents.researcher]
description = "Deep research agent"
config_file = "agents/researcher.toml"

This tells Codex that a role called researcher exists.

Step 2: Configure That Role

Create another configuration file.

# ~/.codex/agents/researcher.toml
model_reasoning_effort = "high"

Now whenever this role is spawned…

It automatically uses high reasoning.

No need to specify it every time.

Supported Reasoning Levels

According to Codex, supported values include:

minimal
low
medium
high

Depending on your environment, you may also be able to configure a different model for that role.

That lets you reserve your most powerful model for tasks that actually need it.

What You Can’t Do

This doesn’t work:

spawn_agent(
    role="research",
    reasoning="low"
)

Nor this:

spawn_agent(
    model="mini",
    reasoning="minimal"
)

The spawn call itself doesn’t currently expose those options.

Configuration happens before execution, not during it.

Why This Design Exists

Role-based configuration has some advantages.

Every research agent behaves consistently.

Every reviewer follows the same settings.

Every coding agent has predictable capabilities.

That makes orchestration easier to manage.

But it also removes flexibility.

Sometimes you want one quick research task with minimal reasoning.

Other times you want a deep investigation using maximum reasoning.

Right now, you’d need separate predefined roles for each case.

Example

Imagine you’re building a web application.

Instead of running every worker at maximum capability, you could organize them like this:

Planner
Reasoning: High
↓
Research
Reasoning: Medium
↓
Coder
Reasoning: Medium
↓
Tester
Reasoning: Low
↓
Documentation
Reasoning: Minimal

This keeps expensive reasoning where it matters while reducing unnecessary compute for simpler tasks.

The Bigger Lesson

Many developers focus on choosing the “best” AI model.

But orchestration matters just as much.

If one request silently creates four or five additional high-end agents, your usage can grow much faster than expected.

Understanding how subagents inherit their configuration helps you design workflows that are both powerful and efficient.

Sometimes the fastest way to save quota isn’t using a smaller model — it’s making sure every spawned worker isn’t automatically using your most expensive one.

As AI coding tools become more agent-driven, these configuration details will have an even bigger impact on cost, speed, and scalability.

Knowing how your agents are spawned today can save you a lot of compute tomorrow.