Unexpectedly high token consumption when GPT-5.6 Sol delegated

What version of the Codex App are you using (From “About Codex” dialog)?

Version 26.825.51511

What subscription do you have?

Plus

What platform is your computer?

macOS

What issue are you seeing?

Summary

I investigated unexpectedly high token consumption when GPT-5.6 Sol delegated work to GPT-5.6 Luna using Multi-Agent V2.

The local telemetry shows that delegation did not materially reduce the work performed by the Sol root. Instead, the Sol root continued substantial research, editing, validation, coordination and integration while three Luna workers simultaneously performed delegated work.

The resulting delegated workload processed 32.69M input tokens.

A separate direct-Sol workload of similar overall purpose processed 4.54M input tokens.

The workloads are not identical, so I am not claiming that delegation itself causally produces exactly a 7.2x multiplier. However, the important observation is that the Sol root alone consumed 10.95M input tokens in the delegated workload, or approximately 2.4x the total input consumed by the direct-Sol workload.

Environment

Subscription: ChatGPT Plus
Platform: macOS / Apple Silicon
Date: 2026-08-30 to 2026-08-31

Feedback ID from affected delegated session:

01a0544b-8776-73d1-acf8-1dedd98f7dc7

Session structure

The delegated workload consisted of:

Sol root, gpt-5.6-sol, medium
├── Luna A, gpt-5.6-luna, high
├── Luna B, gpt-5.6-luna, high
└── Luna C, gpt-5.6-luna, high

No nested agents were created.

All three spawn_agent calls explicitly used:

fork_turns:"none"

Token accounting

Final cumulative token_count values were cross-checked against
state_5.sqlite -> threads.tokens_used.

I did NOT naïvely sum cumulative token_count events.

Thread	Input	Cached input	Output
Direct Sol workload	4,539,242	4,327,040	24,160
Delegated Sol root	10,948,967	10,466,304	32,292
Luna A	7,910,958	7,687,680	36,349
Luna B	8,330,517	8,143,872	46,245
Luna C	5,495,848	5,344,512	38,266
Delegated total	32,686,290	31,642,368	153,152

Delegated/direct input ratio: 7.20x.

Again, these were not identical workloads, so the ratio should be treated as an observed comparison rather than a controlled benchmark.

Important negative findings

This does NOT appear to be the existing wait_agent polling problem.

The delegated Sol root contained:

• 0 wait calls
• 0 wait_agent calls
• 3 list_agents calls
• 3 spawn_agent calls
• 9 send_message calls
• 2 followup_task calls
• 1 interrupt_agent call

There were no timed-out wait loops.

It also does NOT appear to be parent-history inheritance into the Luna workers.

All three workers were spawned with:

fork_turns:"none"

Their first input contexts were approximately 35.5k tokens, and their rollout files did not contain a copied sequence of the parent's prior turns.

What happened while workers were active

During the approximately 16-minute worker-active window, the Sol root made 52 unique inference-like token records and processed:

Input: 8,844,732
Cached input: 8,667,776
Uncached input: 176,956
Output: 22,757

This worker-active period represents 80.78% of the Sol root's final input consumption.

Average Sol input context during the worker-active period was approximately 170k tokens and the maximum reached approximately 232k.

The root continued performing substantive work while the children were active, including:

• source research
• browser checks
• route calculations
• local commands
• file edits / patches
• validation
• messages and follow-ups to workers
• worker-result integration

Seventeen explicit agent-operation-associated Sol turns accounted for approximately 3.06M input tokens. This figure is an upper-bound attribution because some of those turns also performed substantive review/integration.

The three list_agents turns alone processed approximately:

658,807 input tokens
650,752 cached input tokens

Observed failure mode

The economic behavior I expected from delegation was approximately:

Sol delegates bounded work
→ Luna performs that work
→ Sol avoids performing the delegated work
→ Luna returns a compact result
→ Sol integrates it

The observed behavior was closer to:

Sol continues a large active workload
+
Luna A performs delegated work
+
Luna B performs delegated work
+
Luna C performs delegated work
+
Sol coordinates and integrates the workers

In other words, worker computation appears to have been added on top of a substantial Sol workload rather than replacing enough Sol computation to make delegation efficient.

Expected behavior

When an expensive root model delegates a bounded task to a cheaper worker, the root should materially relinquish ownership of that work until the worker returns.

Ideally:

1. The delegated workstream becomes worker-owned.
2. The root does not independently repeat the same research/execution.
3. Worker status management does not require unnecessary full-context root inference.
4. The root receives a compact completion/result event.
5. The root performs one bounded integration/review step.

Parallelism should not automatically turn delegated work into additive root + worker computation.

Why I think this is distinct from existing reports

Related issue #35108 describes wait_agent/tool-boundary polling repeatedly resampling the parent context.

My affected session had no wait or wait_agent calls.

Related issue #38989 documents extreme MultiAgentV2 token amplification, recursive delegation and repeated review/test loops.

My case is much smaller and simpler:

• exactly 3 Luna children
• depth 1 only
• fork_turns:"none"
• no nested delegation
• no wait_agent loop

Yet the Sol root still consumed 10.95M input tokens and 80.8% of its input occurred while workers were active.

This suggests a more general orchestration/work-ownership problem in addition to the already documented polling and history-forking problems.

Accounting integrity

The rollout token_count records contain cumulative total_token_usage values.

For the analysis I used final cumulative values per session and cross-checked them against state_5.sqlite threads.tokens_used.

Duplicate cumulative snapshots were excluded from per-turn analysis.

The final SQLite totals matched the rollout totals for the Sol root and all three Luna workers.

I am not claiming that these local telemetry token totals equal dollar billing. The local telemetry does not expose sufficient service-tier/pricing information to establish that.

Workaround

For now I have stopped using Sol -> Luna hierarchical delegation for this workload.

The more token-efficient architecture appears to be sequential:

1. Run Luna High directly to produce the complete artifact.
2. End that thread.
3. Start a fresh Sol High thread to independently review and improve the finished artifact.

This prevents the expensive Sol root from remaining active throughout the worker execution.

Request

Please investigate whether Multi-Agent V2 can make delegation actually displace parent-model work rather than merely adding worker computation alongside continued root-model activity.

The affected session diagnostics were submitted privately through /feedback using the Feedback ID above.

What steps can reproduce the bug?

1. Start a Codex task using GPT-5.6 Sol as the root model.

2. Give Sol a substantial but coherent workload, such as researching, writing and validating a set of related tour stories.

3. Have Sol delegate several bounded parts of that workload to GPT-5.6 Luna workers using Multi-Agent V2.

4. Use fork_turns:"none" so the workers do not inherit the parent conversation history.

5. Allow the Sol root to continue working while the Luna workers execute.

6. After completion, inspect the root and worker token usage in:
   ~/.codex/sessions/.../rollout-*.jsonl
   ~/.codex/state_5.sqlite

7. Compare the final cumulative token usage of the Sol root and Luna workers with a similar workload completed directly by Sol without delegation.

In my reproduced case:

• Direct Sol workload: 4,539,242 input tokens.
• Delegated Sol root: 10,948,967 input tokens.
• Three Luna workers: 21,737,323 input tokens.
• Delegated total: 32,686,290 input tokens.

The delegated workflow therefore processed 7.20x as many input tokens.

The important observation is that the Sol root itself consumed 2.4x as many input tokens as the entire direct-Sol workload, before adding any Luna usage.

This occurred without nested agents, without wait/wait_agent calls, and with fork_turns:"none" for all three Luna workers.

What is the expected behavior?

When Sol delegates a bounded task to a cheaper Luna worker, the delegated work should materially replace work that Sol would otherwise perform.

Expected behavior:

1. Sol identifies and delegates a bounded workstream.
2. The Luna worker takes ownership of that workstream.
3. Sol avoids independently performing substantially the same research or execution while the worker is active.
4. Worker status management should require minimal root-model inference.
5. When the worker finishes, Sol should receive a compact result or artifact.
6. Sol should then perform one bounded integration/review step.

Delegation should therefore reduce expensive Sol computation, even if total raw token count increases somewhat because cheaper worker tokens are added.

It should not behave as:

large continuing Sol workload

• large Luna workload(s)
• additional Sol coordination/integration workload.

The purpose of using a cheaper delegated model should be to displace expensive parent-model work, not simply add parallel computation on top of it.

Additional information

I performed a read-only forensic analysis of the affected Codex sessions and cross-checked the final cumulative token totals against state_5.sqlite.

Affected Feedback ID:
01a0544b-8776-73d1-acf8-1dedd98f7dc7

Session structure:

Sol root, GPT-5.6 Sol, medium
├── Luna A, GPT-5.6 Luna, high
├── Luna B, GPT-5.6 Luna, high
└── Luna C, GPT-5.6 Luna, high

There were no nested agents.

All three workers were spawned with:
fork_turns:"none"

The workers initially received only about 35.5k input tokens and their rollouts did not contain a copy of the Sol root's previous conversation, so parent-history inheritance does not explain the amplification.

There were also:

• 0 wait calls
• 0 wait_agent calls
• no timed-out wait loops
• only 3 list_agents calls

Therefore this appears distinct from the previously reported wait_agent polling/context-resampling issue.

While the Luna workers were active, the Sol root still made 52 unique inference-like turns and processed:

• 8,844,732 input tokens
• 8,667,776 cached input tokens
• 176,956 uncached input tokens

This represents 80.78% of the Sol root's total input consumption.

Average Sol input context during this worker-active period was approximately 170k tokens and the maximum reached approximately 232k tokens.

The Sol root continued doing substantive research, browser checks, route calculations, file edits, validation, worker communication and result integration while the Luna workers were executing.

Seventeen turns directly associated with agent operations accounted for approximately 3.06M Sol input tokens. The three list_agents turns alone processed 658,807 input tokens.

The local token_count records contain cumulative counters, so I did not naïvely sum them. Final cumulative values were used and independently matched state_5.sqlite threads.tokens_used.

The direct and delegated workloads were similar in purpose but were not identical controlled A/B runs, so I am not claiming that Multi-Agent V2 always causes exactly a 7.20x increase.

The stronger finding is that delegation failed to reduce Sol activity: the delegated Sol root alone consumed 10.95M input tokens compared with 4.54M for the direct-Sol workload.

This suggests that Multi-Agent V2 currently lacks sufficient work ownership / parent suspension behavior when expensive root models delegate to cheaper workers.

Start by comparing the affected session's rollout-*.jsonl files with state_5.sqlite, using the final cumulative token totals and the listed agent-operation turns as the initial evidence. Trace the Multi-Agent V2 orchestration path responsible for root and worker activity, then verify with a comparable delegated and direct workload that bounded delegation displaces rather than merely adds root-model work.