Claude's New Advisor Mode: Better Results + Cheaper
Claude's New Advisor Mode: Better Results + Cheaper
Anthropic just released Advisor Mode, a new API strategy that pairs Opus 4.6 as a planning advisor with Sonnet or Haiku as the executor — and it consistently beats standalone Sonnet on benchmarks while cutting cost by roughly 95% per agentic task. If you build anything on top of the Anthropic API, this is the upgrade you've been waiting for: Opus-level planning quality at sub-Sonnet pricing.
I've been testing this on API-driven projects this week, and the short version is: it finally solves the "Sonnet isn't quite smart enough, Opus is too expensive" problem. Here's how Advisor Mode actually works, what the benchmark numbers look like, and when you should switch.
What Is Claude Advisor Mode?
Advisor Mode is an Anthropic API strategy that routes planning to Opus and execution to a cheaper model (Sonnet or Haiku), with Opus maintaining full shared context across the entire task. The executive model — Sonnet or Haiku — runs the tools, writes the code, and does the actual work. Opus sits above it as a planner and consultant.
The relationship isn't one-shot. This is the key difference between Advisor Mode and the plan-then-execute pattern you already see inside Claude Code.
In Claude Code's plan mode, Opus produces a plan once and hands it off to Sonnet. If Sonnet hits a wall mid-execution, it's mostly on its own. Advisor Mode changes that: when the executive model hits a decision it can't reasonably solve, it consults Opus again, with Opus already holding full context of what Sonnet has been doing. The back-and-forth is continuous, not a single handoff.
Opus never makes any tool calls. To keep cost down, all tool calls are executed by the smaller model. Opus is pure reasoning — it advises, and the cheap model acts. That's where the cost savings come from, and it's why this isn't just "use Opus with a lower temperature."
How Does Advisor Mode Compare to Standalone Sonnet on Benchmarks?
Sonnet 4.6 High with an Opus advisor beats standalone Sonnet 4.6 High on SWE-Bench, BrowseComp, and Terminal-Bench — while costing dramatically less per task. Anthropic published the head-to-head numbers, and the gap isn't small.
On SWE-Bench:
- Advisor Mode (Sonnet + Opus advisor): 74.8 accuracy at roughly $0.96 per agentic task
- Standalone Sonnet 4.6 High: 72.1 accuracy at roughly $19 per agentic task
That's a 2.7-point accuracy lift at about 1/20th the cost. On BrowseComp, Advisor Mode posts 60.4 versus standalone Sonnet's 58.1, and it's cheaper there too. Terminal-Bench shows the same pattern.
The anthropic API has been great but expensive for a long time. Most developers have felt the gap between "Sonnet is close enough" and "I wish I had Opus just for this step." Advisor Mode fills the gap and undercuts Sonnet's standalone price in the process.
Why Is Advisor Mode Cheaper Than Using Sonnet Alone?
Cost is driven by tool calls and output tokens, not Opus's reasoning tokens. When Opus is advising but not executing tools, its role is tightly scoped: it provides strategy, not long chains of tool invocations. The executive model (Sonnet or Haiku) handles all the tool calls, which is where agentic tasks rack up tokens.
This is the insight that makes the math work. A standalone Sonnet agent often does more back-and-forth with tools than is strictly necessary — it doesn't always know the most efficient path. Opus, acting as an advisor, points Sonnet at the right path earlier, which means fewer redundant tool calls, shorter trajectories, and less total token spend.
You get Opus-flavored decisions without paying Opus-flavored token volume. That's the whole pitch.
How Do You Enable Advisor Mode in Your API Calls?
Advisor Mode is an API-level feature, not a Claude Code feature — you configure it by setting the strategy type to "advisor" and specifying the number of max advisor uses in your API call. If you're building a custom agent on top of the Anthropic SDK, this is a small code change.
The parameters you care about:
- Strategy type — set to
advisorso the API knows to pair an advisor with an executor - Max uses — how many times the executor is allowed to consult the advisor during a single task
- Advisor model — typically Opus 4.6
- Executor model — typically Sonnet 4.6 or Haiku, depending on task
Max uses matters because each advisor consultation costs you something. Setting it too low limits the back-and-forth; setting it too high lets the executor run up the bill by consulting for trivial decisions. Start conservative — 3 to 5 uses for most tasks — and tune up if your benchmarks show the executor needs more guidance.
If you're running Claude Code, you don't need to change anything — Advisor Mode is an API-level capability that matters most if you're building your own agent, custom workflow, or SaaS on top of the Anthropic API.
When Should You Use Advisor Mode?
Advisor Mode is a near-automatic upgrade for any agentic application running on the Anthropic API, especially coding agents, browsing agents, and terminal-based automations. If you're using Sonnet or Opus directly inside an app you built, the switch is mostly free gains.
Use it when:
- You have an API-driven agent doing multi-step work (coding, research, browser automation)
- Your task benefits from better upfront planning
- You're currently paying for Opus but feeling the cost
- Sonnet alone is "mostly working" but you want more reliability
Skip it when:
- Your task is a single turn with no tool calls (Advisor adds overhead for pure chat completions)
- You're working inside Claude Code and already have Opus running plan mode
- You need the absolute lowest latency possible (the advisor consultation does add a small delay)
For agentic workloads outside Claude Code, there's almost no reason not to switch.
Why Is the Middle Ground Between Sonnet and Opus So Valuable?
Every Anthropic API developer has felt this gap: Sonnet is fast and cheap but occasionally not smart enough, Opus is reliably smart but expensive enough to blow out your unit economics, and there's nothing in between. Advisor Mode is that missing tier.
In my own client work, I've had projects where Sonnet would hit 85% reliability on a multi-step task — close, but not close enough to ship. The honest answer was usually "add Opus for the hard steps," which meant either rearchitecting the whole agent or eating 20x the cost per call.
Advisor Mode sidesteps that entirely. Opus sits on top as the strategist, Sonnet stays as the workhorse, and you get 90% of the Opus reliability lift at roughly 5% of the Opus cost. For API-first companies, this changes what agentic products are economically viable.
How Does Advisor Mode Change the Cost Math for Production Agents?
If your agent was running on standalone Opus to guarantee quality, Advisor Mode can cut your per-task cost by 90% or more without sacrificing benchmark performance. That's not a marginal improvement — that's the kind of cost shift that lets a product exist.
The math on the SWE-Bench numbers:
- Previous setup: standalone Opus at ~$25-30 per agentic task (typical)
- Standalone Sonnet fallback: ~$19 per task, lower reliability
- Advisor Mode: ~$0.96 per task, higher reliability than standalone Sonnet
Over 10,000 tasks, that's the difference between $200,000 in API spend and $10,000. For a startup shipping an agentic product, that's the difference between a viable business model and a money pit.
Run the math on your own workload. If you're currently on Opus for reliability reasons, Advisor Mode is likely a 10-20x cost reduction. If you're on Sonnet but hitting a quality ceiling, it's a pure upgrade.
FAQ
How is Advisor Mode different from Claude Code's plan mode?
Claude Code's plan mode has Opus produce a plan once and then Sonnet executes it — a single handoff. Advisor Mode is continuous: Sonnet can consult Opus mid-execution whenever it hits a decision it can't reasonably solve, and Opus retains full shared context across the session. It's more like a pair-programming relationship than a baton pass.
Does Advisor Mode work inside Claude Code?
No. Advisor Mode is an Anthropic API strategy, not a Claude Code feature. To use it, you need to be building your own application on top of the Anthropic SDK. Inside Claude Code, Opus-planning and Sonnet-executing already happens through plan mode, but without the continuous advisor relationship.
Which executor model should I pair with Opus?
Start with Sonnet 4.6 for most agentic tasks — it's the highest-performance executor and the benchmark gains are proven there. Use Haiku as the executor only for very simple, high-volume tasks where Haiku on its own is borderline capable, because Opus's advice can pull Haiku meaningfully above its weight class at minimal cost.
Does Opus make any tool calls in Advisor Mode?
No. By design, Opus never executes tool calls in Advisor Mode. All tool calls go through the executor (Sonnet or Haiku). That's the architectural choice that keeps the cost down while still letting Opus contribute its planning and reasoning quality.
Is there a cap on how often the executor can consult the advisor?
Yes — you set it explicitly with the max uses parameter in your API call. This prevents runaway costs from executors that consult Opus on every micro-decision. Start at 3 to 5 uses and tune based on benchmarks for your specific workload.
If you want to go deeper into building AI apps on the Anthropic API, join the free Chase AI community for templates, prompts, and live breakdowns. And if you're serious about building with AI, check out the paid community, Chase AI+, for hands-on guidance on how to make money with AI.
