Every coder has that one senior developer they secretly wish was sitting right next to them — not to write the code, but to just say "no, not that way… try this" at exactly the right moment.
That's literally what Anthropic just built into Claude Code.
The Old Way: Babysitting Two Developers
We had a pattern — use Opus for planning, switch to Sonnet for implementation, sometimes bring in Haiku for lighter tasks. I was the orchestrator. I was deciding when to call the big brain and when to let the fast model run.
It worked, but it felt like I was babysitting two developers who didn't talk to each other. Every handoff was context I had to manage. Every switch was a decision I had to make. The orchestration logic kept growing, and the real work kept shrinking.
The Hidden Cost of Orchestration
Worker pools. Context juggling. Task breakdowns. Meetings between models that don't actually talk to each other. The scaffolding around the intelligence started weighing more than the intelligence itself.
A Different Mental Model
Now imagine this — what if the fast developer could do everything on their own, but had a direct phone line to the smartest person in the room? No meetings. No task breakdowns. No project management overhead. Just one call when they're genuinely stuck, get the advice, and get back to work.
That's the Advisor strategy.
How The Advisor Pattern Actually Works
🏃 Sonnet as the Executor
Sonnet (the executor) runs your entire task end to end — reading files, calling tools, writing code, iterating. It owns the loop. It owns the context. It owns the outcome.
But the moment it hits a wall — a complex architectural decision, a tricky edge case, a moment where it could go in three different directions — it picks up the phone and calls Opus.
🧠 Opus as the Advisor
Opus (the advisor) doesn't touch a single line of code. It just says "here's the plan, here's the correction, now go." And Sonnet continues.
No task handoff. No context transfer. No orchestration scaffolding. The executor stays in control from start to finish; the advisor is just a phone call away when judgment matters.
The Numbers That Blew My Mind
Here's the part I had to read twice:
- Sonnet with Opus advisor actually performed better AND cost less per task than Sonnet running alone.
- Haiku with Opus advisor more than doubled Haiku's solo performance — at 85% less than what Sonnet costs.
Better Brain, Lower Bill
This shouldn't feel intuitive at first — adding a second model should cost more, right? But when the advisor only gets called at the right moments, it prevents the wasted loops, the wrong turns, and the re-work that eat up tokens. You spend a little more on judgment and save a lot more on execution.
One Line. No Orchestration.
The part that genuinely surprised me? This isn't a framework. It's not a worker pool. It's not a multi-agent system you need to architect.
One line in your API call. No orchestration logic. No worker pools. No context juggling. The executor knows when to ask for help, and the advisor knows how to answer without taking over.
I went from having a planner to having an advisor. That one shift changes everything about how we build AI agents.
Why This Matters For How We Build Agents
For the last year, the prevailing wisdom in agent design has been: break the work down, orchestrate the pieces, route each sub-task to the right model. Planners, executors, critics, routers — entire frameworks were built on this idea.
The Advisor pattern quietly suggests the opposite: don't break the work down at all. Let the executor own the task. Let it judge, in real time, when it needs a second opinion. Trust the model to know its own limits — and give it a way to call for help when it hits them.
This is a much more human way to work. A junior engineer doesn't hand off their task to a senior the moment things get hard. They try, they think, they get stuck, and then they ask. The Advisor pattern mirrors that rhythm exactly.
The Real Insight
The smartest move isn't using the most expensive model everywhere. It's not using the cheapest model everywhere either. It's knowing exactly when to ask for help.
Anthropic didn't just ship a new feature — they shipped a new design philosophy for how humans and AI agents should collaborate with each other. And it's the kind of idea that, once you see it, you can't un-see.
Try It Today
If you're building with Claude Code or the Claude API, go try this today. Take your current agent setup, rip out the orchestration layer, and let Sonnet (or even Haiku) run the task with Opus on speed-dial.
Then watch what happens:
- Your code gets simpler.
- Your bill gets smaller.
- Your agent gets smarter.
All from one line.
The future of AI agents isn't bigger orchestration. It's better judgment about when to ask for help.