Orchestrating AI agents gets the same score for half the cost: an Opus that hands out work among Sonnet workers hits 96% of the result of a whole team of Opus, according to the comparison Anthropic has published. The expensive model only thinks; the cheap ones execute. If you use Claude Code, Codex or OpenCode on a subscription, this changes how you ask for tasks: telling it “use three agents” and nothing else usually ends with three expensive models reading files at once.
Why your subagents burn through your quota
Delegating saves nothing by default: subagents inherit your session’s model and effort, so three commands at once can mean three Opus running at high effort. The spend goes up because the cheap work, reading files and running commands, is done by the expensive model.
When you ask Claude Code to “build the backend, the frontend and the database, and use three agents for it”, it spins up three subagents. A subagent is your same tool launched as a fresh instance with zero context: it takes an order, executes it and returns a result. You can pin the model of each one in the Claude Code subagents documentation, but you have to do it for every type of task. And even then the agent doesn’t know how much weekly quota you have left, or that you have another harness with its model free (Claude Code maxed out and Codex untouched, for example). That’s why there comes a point in the month when usage runs out, unless you pay quite a bit. For pricing and limits, you have it in the Opus 5 for coding analysis.
Four mechanisms that get confused with orchestration
Subagents, parallel agents, router and orchestrator do different things: only the orchestrator hands out work by difficulty and cuts tokens. The other three spend the same or just keep you from being stranded mid-session.
| Mechanism | What it does | What it saves you |
|---|---|---|
| Native subagents | Your tool spins up instances of itself with zero context | Nothing by default: they inherit your model and your effort |
| Parallel agents | claude-squad runs Claude Code, Codex and OpenCode at once, each in its own worktree | Time; tokens stay the same |
| Model router | Sits between your tool and the providers; if one quota falls, it jumps to a free model | Keeps you from being stranded; it doesn’t hand out work |
| Orchestrator | Splits the task into chunks, assigns each one by difficulty and merges the results | Real token savings: the expensive one thinks, the cheap ones execute |
The worktrees in the parallel setup exist so the agents don’t step on each other, and on independent tasks the time saved is huge. Tokens, nothing. The router doesn’t hand out work either: it switches model when one goes down, and that’s a fallback. It’s there so you don’t end up halfway through, not to decide who does what.
The orchestrator does decide. It takes the task, splits it into chunks, sends each chunk to the model that fits by difficulty, launches the workers and merges what they return. Google ADK will do, the same one I already used to build agent workflows step by step, or a skill inside the tool you already use.
Plan big, execute small
Any task has thinking work and execution work, and the thinking part is small. The expensive model reads your request, writes for each chunk what the worker has to do and sends it to a cheaper one. Each worker works in its own context and returns a summary; the boss merges the summaries and decides whether another round is needed.
There’s a second saving, and it’s context. If you pile up files and references in a half-million or one-million token window, every message gets more expensive and the model responds worse. With workers, the boss only gets the summary of each chunk, so its window stays clean for deciding. Claude Code already documents agent teams to hand out work among agents, and the costs and tokens guide covers how consumption is measured.
When orchestration costs you more
If the change touches two or three files, coordinating costs more than doing it, and there the main agent is in charge, plain and simple. Splitting the task, writing what each worker has to do, merging results and validating that everything fits eats tokens.
It pays off with big changes in a big project, or when you’ve asked for a lot of things at once, because the cost of coordinating weighs little against what you save on execution. My rule is exactly that: size of the change versus cost of coordinating it.
How to try it today with an open source skill
There’s a free, open source skill you install with one command in whatever agent you already use, be it Claude Code, OpenCode or any other. The setup checks which CLIs and models you have, you pick a playbook and the skill launches the workers that fit. I set it up live in the video; the flow is short:
- The setup scans the CLIs you have installed across all your agents, checks which models you have available and offers you three profiles: base, savings and aggressive, the latter for when you want quality and don’t care about the spend.
- You pick a playbook, a strategy stored in an editable YAML. There are four covering the spectrum:
direct: small tasks; the main agent does everything and nothing is orchestrated.scout-then-build: several cheap workers explore the code without writing anything, and only one writes the change.plan-big-execute-small: Anthropic’s pattern; the big model plans and the small ones execute.best-of-n: fires several attempts at a hard fix, compares them and keeps the best one.
- Before each round, the skill checks how much quota you have left on Claude or Codex and warns you if it’s about to cross the line you set.
- When it finishes, a report command breaks down what each worker did, with which model, how long it took and how many tokens it spent.
Watch out for best-of-n: it burns more than nailing it first time. It’s there for quality, when the fix deserves several attempts; the other three do bring the bill down.
What’s left to confirm
To me, the most valuable part of the skill is the two visibility pieces: it knows how much quota you have left on each provider before launching, and the report tells you what each worker spent and with which model. That, natively in Claude Code or Codex, you don’t have today. What’s left to confirm is whether the harnesses end up shipping orchestration built in; until then, the skill is the shortcut.
Install it, run the setup with the savings profile and launch your usual task with the plan-big-execute-small playbook. Compare the report with what you used to spend and tell me in the comments which model combination you run.



What do you think?
Leave your opinion, question or suggestion. Comments are synced with GitHub Discussions .