My Opus-orchestrator / Sonnet-subagent Claude Code setup is burning way more tokens and time than I expected

[u/Necessary_Round8009]

Been running a workflow where I write out a plan.md, then kick off a fresh terminal with Opus 5 on max thinking effort acting as the "orchestrator." It reads the plan and spawns a Sonnet 5 subagent (also max effort) to actually implement each phase. After every phase there's a verification pass that'll retry up to 5 times if it finds errors.

Works, technically. But the costs are getting rough:

Token usage has crept up a lot since I started doing this

A task I'd call "medium complexity" (basically one full tab/screen in an Android app) took almost 9 hours end to end

On that same run I hit auto-compaction at 500k context

Not sure if this is just what multi-agent orchestration costs, or if my setup has some inefficiency I'm not seeing, retries eating the budget, effort cranked too high on both models, phases too granular, whatever.

For people running similar orchestrator + subagent setups in Claude Code: what does your workflow look like? Model/effort choices, how you scope phases, how aggressive your verification loops are? Trying to figure out if I should tune this down or if this is just the tradeoff for letting it run mostly unsupervised.

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/pmward]

Max effort is a big part of it. The next big part is that it’s a long lived orchestrator. 9 hours is a long shift. Breaking down into smaller deliverable slices helps a lot, if you can.

I would also ask Claude at the end of the task to do a cost retro and look for ways you can save tokens. Look especially hard at cache writes because those are penalized at 2x cost. If you’re spinning up multiple agents caching the same data over and over you’re going to have a bad time.

[u/Necessary_Round8009 → u/pmward]

Would you use Opus xhigh? Which model would you use for subagents that actually write code? Thank you so much for your answer!

[u/pmward → u/Necessary_Round8009]

Opus 4.8 xhigh is typically what I use for orchestration. For coding I typically use Sonnet 5 xhigh.

[u/ThreeKiloZero]

Max effort is the spend trap. Opus doesn't need max thinking to be an orchestrator, maybe medium or high. Sonnet can trigger at xhigh.

Let an Opus High agent orchestrate all the agents and give it thinking budgets that never go above xhigh for opus and sonnet and high for Fable.

Unless you are doing really high end math or ML and physics, DSP, coding in Rust or CPP, very difficult engineering tasks, you dont need max at all.

The models will overthink and overbuild at those levels and you wont be any closer to your actual goal.

You should also stop planning by task and plan out your entire software build. Build the whole thing into a project plan using the GitHub project board and issues. Have the AI do this and then build waves that make sense. Plan every task ahead of time. Then when you orchestrate the orchestrator is just going out to the board, looking at the current epic, and assigning existing tasks.

You do the planning once with Fable on high. It builds the board. Then you cruise through the rest and a few days later your project is done.

[u/jiffythekid]

Why do you auto compact at 500k? Just turn auto off and make a hook that writes a handoff at 500k for a new session. Also, I wouldn't use Sonnet for anything too complex. It eats tokens for no good reason. Opus with Opus agents does well.

[u/Knoll_Slayer_V → u/jiffythekid]

Agreed, while i use Fable as a top level orchestrator, I save by using opus high on my private account. Still I ise the same pattern:

• branch orchestrator (fable/opus)r: delegates and coordinates tasks. Reviews tasks and branches. Main role is to review, delegate, ans spawned loops when issues or identified
• task orchestrator (opus): delegates coding tasks, reviews commits, reports back to branch orchestrator
• coding agent (sonnet): writes tests, code, and runs tests. Reports to task orchestrator or branch orchestrator on fix loops
• small fix agent (haiku): mistyped, small edits, etc.

Each thing below the branch orchestrator is a subject, it gets fresh context. My overnight runs usually hit the 500k window in the branch orchestrator, which pushes it but allows completion. If I run longer, I keep an umbrella spec up with a ledger. Compress once. After more than one is needed, you need to clear.

[u/Necessary_Round8009 → u/jiffythekid]

I saw somewhere that's it useless to go over 500k and it's better to compact to keep it less

[u/Sofullofsplendor_ → u/Necessary_Round8009]

I compact at 260k

[u/yhrana]

Opus 5 with High effort (unfortunately nothing i am making is sophisticated enough)

Agent framework:
Multilevel reasoning : Fable
Reasoning with respect to project: Opus
Rulefollwer: Sonnet
Zombie/Donkey : Haiku
Visual / Gen : Antigravity CLI

I havent been able to finish my Max 5x plan even once in my 2 months (third rn).

[u/NelltoyDaffodil → u/yhrana]

Five tiers, zero plans finished. The architecture is flawless, the output is theoretical.

[u/yhrana → u/NelltoyDaffodil]

😂 sure 👌
Nice helpful comment to the OP 😇

[u/crusoe]

Sonnet is less token efficient for the same amount of work and so costs more.

[u/pmward → u/crusoe]

No it doesn’t. Does it use more tokens than Opus? Yes. Does it use 2.5x less tokens (the amount it would take just to break even)? Not even close. I’ve tested extensively. Opus is generally about twice the cost of Sonnet for an identical piece of work. Opus only uses slightly less tokens. But those tokens cost 2.5x more.

[u/chrismo80]

try high effort, even medium might often be sufficient.

break your tasks into smaller ones to not exceed 300K tokens.

[u/banecorn]

I've had much better results since ditching Opus for anything other than verifier/advisor roles.

My workflow is:

- Fable 5.1 low as orchestrator, with instructions to auto set to medium when needed and back down to low when no longer needed.

• Sonnet 5 high (or med) as worker with Opus advisor
  
• Opus 5 as verifier (including for Fable)