← sources

Does delegating to cheaper models actually save money? I tested it across three codebases.

source: reddit (reddit:ClaudeCode)published 2026-11-03 18:40ingested 2026-11-04 02:41

retained text

**Disclaimer:** This is a small experiment, not a definitive benchmark. Most tasks were run twice, while everyday tasks were run once. I'd have liked to run more repetitions, but subscription usage limits make that difficult. The cost differences are interesting, but small quality differences should be treated as observations rather than definitive rankings.

I wanted to see whether Claude Opus decides to use subagents effectively, and whether forcing it to delegate, preventing delegation, or leaving it to decide for itself changes the results.

I built a model-router skill that lets Opus delegate work to Haiku or Sonnet, then compared four setups:

1. **Forced Opus:** told not to use subagents.
2. **Spontaneous Opus:** free to delegate, but it never did.
3. **Skill-routed:** Opus uses my skill to choose when to delegate and which model to use.
4. **Forced Haiku:** all subagents use Haiku.

I tested these on three codebases: my own project (\~10k lines), [rich](https://github.com/Textualize/rich) (\~22k lines) and [beets](https://github.com/beetbox/beets) (\~52k lines).

**Results**

**1. Small codebase (\~10k lines)**

Every setup passed all 10 everyday tasks.

On five reading-heavy tasks, Forced Opus was the most accurate per run. Skill-routed cost 30% more, while Forced Haiku cost the same but had the weakest docs check (4 of 9 issues).

Interestingly, skill-routed found all 9 known documentation issues across its two runs, compared with 8 for Forced Opus. However, its individual runs were less accurate.

https://preview.redd.it/zet93rp8yfzh1.png?width=3000&format=png&auto=webp&s=2868345689c66f0a7a680f18c39c54f693d7dda7

**2. Medium codebase (\~22k lines)**

This was where Haiku surprised me.

On the documentation check, Forced Haiku found 11 of 12 known issues across two runs, matching or slightly exceeding Opus, while costing 41% less.

Skill-routed actually cost 11% more than Forced Opus. Spontaneous Opus was 14% cheaper.



https://preview.redd.it/n35l2p5lyfzh1.png?width=3000&format=png&auto=webp&s=87d89fcadfd21ae2bb7aaf36a1162c979312da88

**3. Large codebase (\~52k lines)**

This produced the biggest cost differences.

Across all three tasks, average cost reductions compared with Forced Opus were:

* Spontaneous Opus: 32% cheaper
* Skill-routed: 38% cheaper
* Forced Haiku: 75% cheaper

Quality depended on the task.

On the reference documentation check, both delegated setups found more issues than either Opus-only setup.

On the larger 80-page plugin documentation check, Forced Opus was clearly the most accurate, finding 45 of 51 known issues across two runs. Forced Haiku found 34, but cost 84% less.

https://preview.redd.it/ivumou1oyfzh1.png?width=3000&format=png&auto=webp&s=88f0dfe7343d16ae6d4893047ef97500c79a9f9c

**What I think is happening**

**Small projects:** Opus can often write small scripts to inspect the code instead of reading everything manually. Delegation adds briefing, duplicated reading and verification costs.

**Medium projects:** reading becomes a larger part of the workload. Haiku is extremely cheap at reading cached context, making it surprisingly effective for straightforward checks. Sonnet offered little cost advantage in this experiment.

**Large projects:** a single long session becomes expensive as the growing context is repeatedly read. Delegation splits the work into smaller contexts, reducing costs and allowing parallel execution. However, the largest documentation check showed that this can come with a quality trade-off.

The obvious way to estimate savings is misleading. Re-pricing the delegated tokens at Opus rates suggested 34-85% savings. Head to head, results ranged from 30% more expensive to 75% cheaper.

One particularly interesting observation: Opus never delegated spontaneously in any of my runs, even on the largest codebase. That's specific to these tasks and this setup, not proof that Opus never delegates.

**Final thoughts**

I wouldn't claim there's one best approach.

* **Small codebase:** Opus alone was generally the better choice.
* **Medium codebase:** Haiku-only delegation was surprisingly competitive.
* **Large codebase:** delegation offered substantial savings, but accuracy depended on the task.

The router skill mostly selected Sonnet, which often wasn't economical enough to justify the extra coordination.

Full methodology, per-task results, charts and the transcript checker:

[https://github.com/Manuele-T/claude-model-router/tree/v1.0](https://github.com/Manuele-T/claude-model-router/tree/v1.0)

I'd be interested to hear whether others have seen similar behavior, particularly Opus choosing not to delegate even when working on larger codebases.

document fetched 2026-11-04 00:39 · canonical https://reddit.com/r/ClaudeCode/comments/1xn18cu/does_delegating_to_cheaper_models_actually_save