Big model plans, cheap model codes: When the AI duo actually saves money
Google and Anthropic both split AI agent work between an expensive model and a cheap one, but they do it in opposite directions. The vendors promise savings. Independent tests show that this only holds if the cheap model can do almost everything on its own. If it can't, the duo can get a lot more expensive. We explain how both patterns work, run the numbers and show you how to set the pattern up yourself.

What this is about
AI coding agents are expensive because they work through many steps in a row and re-read the entire history at every step. One obvious way to save money is making the rounds in the tech press: let the expensive model do only the thinking and the cheap one do the actual work. Google and Anthropic have already built this idea into products, but as mirror images of each other.
- Top-down at Google: In the Antigravity coding tool, the Orchestrator has a large model plan while the cheap Gemini 4 Hydrogen carries out the plan.
- Bottom-up at Anthropic: With the advisor tool, the small model (Sonnet or Haiku) does the work itself and asks Opus for advice only when it needs to.
Our thesis: the split only saves money if the cheap model handles most steps on its own and coordination between the two stays cheap. Otherwise the duo ends up costing more than the big model alone. The independent numbers available so far back this up.
How the two patterns work
Google's Orchestrator launched on November 12 alongside Hydrogen. According to the Antigravity documentation, every message starts with a read-only phase. The planner explores the code without changing anything, resolves ambiguities and writes a plan. The plan also spells out the conditions that should trigger a re-plan. Then the executor takes over: it searches, edits files, runs builds and tests, and checks the result against the plan. Control goes back to the planner in three cases:
- a verification step fails twice,
- an interface behaves differently than expected,
- a design question isn't settled in the plan.
Gemini 4 Neon is now the default planner. You can also pick Carbon, Argon or Claude Opus 5.5. Besides Hydrogen, Claude Sonnet 5.5 is available as executor. You can't set the reasoning depth in the Orchestrator, and /effort has no effect there. Google doesn't say what context gets passed along at handoff or whether there's a cache. The availability details don't match either. At first it was “Ultra only”; the docs now list Pro and Ultra.
Anthropic's advisor tool (beta, type advisor_20260301) runs inside a single API request. According to the API docs, the small model decides on its own when to call the advisor. The advisor then gets the complete transcript of the session: system prompt, tool definitions, every step so far. It can't use any tools itself and only returns advice, typically 400 to 700 text tokens, or 1,400 to 1,800 with reasoning. Every call is billed at the advisor model's price. max_uses caps the number of calls per turn. Once the cap is hit, the small model keeps working without advice. There's no cap for the conversation as a whole. Caching is optional. Anthropic says it pays off from about three consultations per conversation.
A cache here stores the already-processed beginning of a conversation. With Opus 5.5, a reused chunk like that costs just 5 percent of the normal input price. That's exactly what makes switching models tricky: a model that joins mid-conversation doesn't have the history cached yet and has to read it in at full price.
Vendor numbers vs. independent measurements
| Claim | Source | What's behind it |
|---|---|---|
| Orchestrator: −24 % quota, −19 % time, success “close to Carbon” | Subscription quota, not dollars. No absolute success rate published. Benchmark cited sometimes as Terminal-Bench 4.1, sometimes as 4.0 | |
| Sonnet 4.6 + Opus advisor: +2.7 points SWE-bench Multilingual (72.1 → 74.8), −11.9 % cost | Anthropic, April 2026 | older model generation |
| Haiku 4.5 + Opus advisor: BrowseComp 19.7 → 41.2 %, 85 % cheaper than Sonnet alone, but 29 % worse | Anthropic | research tasks, not code |
| Opus 5.5 + Fable 5.1 advisor: +1.7 points at roughly 2.1× the cost | Anthropic data, analyzed by Developers Digest | at the edge of measurement noise, according to the article |
| Sonnet 5.5 + Opus advisor 20 % cheaper than Opus alone; Opus + Opus advisor +80 to +94 % | Independent test, 43 tasks, 171 runs | results better on only 2 of 6 tasks |
| Opus planner + Kimi K2.6: 97/100 like Opus alone, but roughly 3× the cost | Hands-on test, analyzed by Datallmlab | about $11 in planner costs didn't show up in the logs |
| “4x cheaper” | Morph | calculated, not measured |
Two findings stand out. First, the small model often doesn't ask at all. In the independent Claude Code test, Sonnet called the advisor only nine times across 53 runs, and 46 runs got by without any advice. After repeated failures, the model didn't ask even once. In Anthropic's own GPQA runs, there wasn't a single consultation out of 396 possible ones. Costs still rose by 12 percent (Haiku) and 25 percent (Sonnet), because the tool definition alone adds around 1,000 tokens to every request. Second, the hidden costs rarely make it into the marketing copy: planner tokens don't show up in the logs, and a weaker model needs more attempts.
Morph's “4x cheaper” doesn't hold up under scrutiny either. The figure is based on assumed token counts multiplied by list prices. Morph's own numbers work out to more like a factor of 2.3 for a full build ($92.50 vs. $39.50). On top of that, the math assumes the weaker model needs as many tokens as the strong one. Morph also sells its own model router.
Running the numbers: where the break-even point is
A simple model, our own calculation: the planner handles a share p of the work. Coordination adds an overhead o, expressed as work done by the big model. The small model needs e times as many tokens as the big one for its part and costs a fraction r per token. The duo is cheaper as long as: p + o + r·(1−p)·e < 1.
With p = 20 % and o = 5 %, here's how much less efficient the executor can be at most:
| Planner → executor (list prices) | Price ratio r | Executor may use up to … as many tokens |
|---|---|---|
| Carbon from Dec 1 ($4/$20) → Hydrogen ($1.50/$7.50) | 0.375 | 2.5× |
| Neon ($3/$15) → Hydrogen | 0.5 | 1.9× |
| Carbon at launch pricing ($2/$10) → Hydrogen | 0.75 | 1.25× |
| Opus 5.5 ($4/$20) → Sonnet 5.5 ($2/$10) | 0.5 | 1.9× |
So as long as Carbon's launch pricing lasts, there isn't much headroom. It also means Google's −24 percent can't be converted into dollars. Depending on how the quota weights the models, it could reflect a split where Hydrogen does barely 40 percent of the work or nearly all of it.
For the advisor, Developers Digest works out what a single Opus 5.5 consultation costs with a 50,000-token transcript and no cache: about $0.23 (50,000 × $4/M plus 1,600 × $20/M, which we double-checked). Let's assume Sonnet 5.5 needs as many tokens for a task as Opus. Then it costs half as much. For a task that costs $1.38 with Opus alone (Anthropic's own figure), the $0.69 in savings would be gone after three such consultations. With a 100,000-token transcript, after just under two. Haiku 5.5 costs only $0.10/$0.50 up to 100,000 input tokens. There, a single Opus consultation costs more than the entire rest of the task. Microsoft's own measurement for MAI Code 2 Flash shows, however, that Haiku 5.5 still came to $0.32 per task. Cheap list prices don't automatically mean cheap tasks.
Reviewer beats planner
A paper by Jan Miller (arXiv 2603.03406) compared both roles head-to-head. It tested Qwen3-32B as the reasoning model and Qwen2.5-Coder-14B as the coding model on HumanEval+ and MBPP+, 542 tasks in total. The result: when the big model planned up front, the duo scored 2.4 points worse than the coding model alone (78.0 percent). When the small model wrote freely and the big one reviewed, the score rose to 87.8 percent, and to 90.2 percent with one more attempt. The big model alone managed 84.1 percent. The limitations are significant: single functions rather than real projects, just one model pair, and two to seven calls instead of one.
Our take: this fits Anthropic's recommendation to consult the advisor early and before finishing. It also fits the independent test, where exactly that final check was usually skipped. The bottom-up pattern has potential, but in practice it often fails because the small model doesn't ask.
Set it up yourself and measure it properly
- Claude Code:
/model opusplanhas Opus 5.5 plan in plan mode and Sonnet 5.5 execute. According to the docs, this only applies in plan mode, and an open GitHub issue reports that Opus sometimes keeps running afterward. You get the bottom-up pattern with/advisor opus. Haiku can ask there, but can't act as the advisor itself. - OpenCode 2: In the agents docs, each agent under
agentsgets its ownmodel.mode: "subagent"turns it into a helper agent, andpermissionscontrols which subagents the main agent may launch. Subagents run in their own sessions with fresh context. A cheap main model paired with a strong reviewer works well, for example. In issue #8456, a user warned that switching models mid-session resends the entire context. - DeepSeek-Reasonix: In
reasonix.toml, you setdefault_model(executor) andplanner_model, plusplanner_max_stepsaccording to a third-party analysis. Both models run in separate sessions so their caches stay stable. The README calls this “cache-stable sessions.” - Cursor: A fixed planner-executor pair isn't built in. Forum users report that you can't assign models per plan step. When running several models in parallel in plan mode, a bug caused one model to modify code anyway.
What you should measure: cost per successfully solved task (not per task), how often handoffs or consultations happen, tokens broken down by model (for the advisor, in usage.iterations), cache hit rate and runtime. Always compare against three baselines: the small model alone, the big model alone, and the big model at a low effort level. Anthropic itself recommends that last comparison as the bar the duo has to clear.
Our verdict
The two-model team isn't a money-saving machine. What's been shown so far: with Sonnet as the worker and Opus as an occasional advisor, you can save around 10 to 20 percent without hurting quality. Google's −24 percent hasn't been independently confirmed yet, and it only refers to quota, not money. If you pair the big model with itself as advisor, or coordinate planner and executor by hand, you can easily pay double or triple. Our take: new cheap executors like Hydrogen or MAI Code 2 Flash make the pattern more attractive the further their price sits below the planner's. But the biggest lever probably isn't planning, it's the final review. And that's exactly the step today's tools still skip too often.
Sources
- Google Antigravity Blog: Gemini 4 Hydrogen in Google Antigravity antigravity.google
- Google Antigravity Docs: Models / Orchestrator antigravity.google
- Anthropic: The advisor strategy claude.com
- Claude API Docs: Advisor tool platform.claude.com
- Claude API Docs: Pricing platform.claude.com
- Claude Code Docs: Model configuration (opusplan) code.claude.com
- Datallmlab: Orchestrator-Executor LLM Pattern datallmlab.com
- arXiv: Review Beats Planning (2603.03406) arxiv.org
- arXiv HTML: Review Beats Planning arxiv.org
- Morph: Multi-Agent Model Routing morphllm.com
- allahabadi.dev: Claude Code's Advisor Tool, Tested allahabadi.dev
- Developers Digest: Claude Advisor Tool vs a Bigger Model developersdigest.tech
- Decode the Future: Claude Advisor Tool & Claude Code /advisor decodethefuture.org
- eesel: Google Antigravity Orchestrator eesel.ai
- Interesting Engineering: Gemini 4 Hydrogen interestingengineering.com
- Xataka Brasil: Modelo caro pensa, barato trabalha xataka.com.br
- GitHub: anomalyco/opencode Issue #8456 github.com
- OpenCode v2 Docs: Agents opencode.ai
- DeepSeek-Reasonix README raw.githubusercontent.com
- Instagit: Two-Model Collaboration in DeepSeek-Reasonix instagit.com
- Cursor Forum: Plan mode with multiple models forum.cursor.com
- Microsoft AI: MAI Code 2 und MAI Code 2 Flash microsoft.ai
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.