On April 9, 2026, Anthropic released the Advisor Strategy — a new API pattern where Sonnet 4.6 silently consults Opus 4.6 on hard decisions during agentic tasks. The result: 74.8% on SWE-bench Multilingual (up from 72.1%) at 11.9% lower cost than pure Opus. Here is how it works and how to implement it today.
Every developer using the Claude API faces the same dilemma. Opus 4.6 is measurably better at complex reasoning and ambiguous decision-making, but it costs significantly more per token than Sonnet or Haiku. Running everything through Opus is expensive. Running everything through Sonnet means occasionally getting weaker outputs on the hard problems where Opus would have excelled. Until April 9, 2026, the only solution was manual model routing — deciding upfront which tasks go to which model and hardcoding that logic into your application. Anthropic just shipped a better answer: the Advisor Strategy.
What Is the Advisor Strategy?
The Advisor Strategy is a new server-side tool — advisor_20260301 — built into the Claude Platform that lets an executor model (Sonnet 4.6 or Haiku 4.5) silently consult Opus 4.6 on the hard parts of a task, all within a single /v1/messages API call. Your user never sees the consultation happen. Your token costs stay mostly at Sonnet or Haiku rates. But the reasoning quality on genuinely difficult decisions approaches Opus-level.
Anthropic’s published benchmark results validate the claim: Sonnet 4.6 with an Opus 4.6 advisor scores 74.8% on SWE-bench Multilingual, up from 72.1% for Sonnet alone — a 2.7 percentage point gain — while costing 11.9% less per agentic task than running on pure Opus. That combination is unusual: most AI capability improvements trade cost for quality, or quality for cost. The Advisor Strategy claims to improve both simultaneously, which is worth understanding in detail.
The Architecture: Executor and Advisor
The mental model is straightforward. Your agent operates in two roles:
- Executor — The model the user interacts with. It calls tools, reads results, iterates, and writes the final answer. This runs on Sonnet or Haiku, handling everything routine and consuming the bulk of the tokens.
- Advisor — Opus 4.6, watching silently. When the executor encounters something genuinely hard — a tricky architectural decision, ambiguous requirements, conflicting context — it calls the
advisor_20260301tool and escalates. Opus reads the shared context and returns a plan, a correction, or a stop signal. It does not call tools. It does not write the final answer. It just advises.
The key design insight is that Opus does not need to process every step. The expensive reasoning only activates when the executor signals uncertainty. In a twenty-step coding task, perhaps four steps require Opus-level judgment: the initial architectural decision, a tricky edge case midway through, an unexpected error, and a final review. The Advisor Strategy structures computation around that reality rather than paying Opus rates for all twenty steps.
This maps closely to how expert consultants work in human organizations. A junior developer handles routine implementation and escalates to a senior architect only when the problem is genuinely hard. The senior architect does not rewrite every function — they provide targeted judgment at the right moments. The Advisor Strategy automates that escalation pattern within a single API call.
How to Implement the Advisor Strategy
The implementation requires three changes to your existing Claude API calls.
Step 1: Add the Beta Header
The Advisor Strategy is currently in public beta. Add the following header to your API requests:
anthropic-beta: advisor-tool-2026-03-01Step 2: Declare the Advisor Tool
Add advisor_20260301 to your tools array in the Messages API request. This is a built-in platform tool — you do not implement a handler for it. Anthropic’s infrastructure handles the Opus invocation server-side.
{
"model": "claude-sonnet-4-6",
"max_tokens": 16000,
"tools": [
{ "type": "advisor_20260301" },
{ "name": "run_bash", "description": "Run a shell command", "input_schema": { ... } }
],
"messages": [...]
}Step 3: Tune Your System Prompt
The advisor tool performs best when the system prompt explicitly tells Sonnet when to escalate. For a coding agent, that looks like this:
You are a software engineering agent. Implement tasks step by step.
Use the advisor tool before proceeding when you encounter:
- Architectural decisions affecting multiple files or components
- Ambiguous requirements with multiple equally valid interpretations
- Security-sensitive code: authentication, authorization, data validation
- Complex algorithmic problems where you are not confident in your approach
For all other tasks, proceed directly without consulting the advisor.The guidance matters. An under-specified prompt causes the executor to escalate too often (eroding cost savings) or never (losing the quality gain). Anthropic recommends being explicit about the categories of decisions that warrant escalation, tailored to your specific application domain.
SWE-bench Benchmarks: What the Numbers Mean
Anthropic published performance data for the Advisor Strategy on SWE-bench Multilingual — a benchmark that measures the ability to resolve real GitHub issues by writing correct code, one of the most practical proxies for agentic software engineering quality:
| Configuration | SWE-bench Multilingual | Cost vs Pure Sonnet | Cost vs Pure Opus |
|---|---|---|---|
| Pure Sonnet 4.6 | 72.1% | 1x (baseline) | ~0.30x |
| Sonnet 4.6 + Opus Advisor | 74.8% | ~1.05x | ~0.88x |
| Pure Opus 4.6 | ~76.2% | ~3.30x | 1x (baseline) |
The interpretation: the Advisor Strategy achieves 74.8% performance (versus 76.2% for pure Opus) at roughly 88% of the cost of pure Opus. You capture approximately 83% of the Opus quality gain over Sonnet for about 26% of the price premium. For most production agentic workloads, that trade-off is clearly favorable.
A note on scope: SWE-bench is a coding benchmark. Anthropic has not published Advisor Strategy results for other task categories such as complex reasoning, creative generation, or customer support conversations. The 2.7 percentage point gain may not generalize uniformly across every domain. Test your specific use case before drawing broad conclusions from the coding benchmark alone.
When to Use the Advisor Strategy
High-Value Applications
Long-running coding agents are the clearest win. When an agent executes a multi-step development task — scaffolding a feature, debugging across multiple files, writing comprehensive tests — most steps are routine execution that Sonnet handles well. Architectural choices, diagnosing root causes of complex bugs, and handling unusual edge cases are where Opus genuinely adds value. The Advisor Strategy delivers Opus guidance on exactly those steps without paying Opus rates for the rest.
Research and analysis workflows benefit from the same pattern. Reading sources, extracting information, and formatting results are executor tasks. Synthesizing conflicting findings, identifying what is genuinely significant versus routine, and forming well-reasoned conclusions are advisor tasks. The executor does the reading; Opus does the thinking on the hard synthesis questions.
Customer support automation with escalation paths — where an executor handles the majority of interactions and consults the advisor when the situation is unusual, high-stakes, or requires nuanced judgment. The advisor’s guidance shapes the executor’s final response without the user experiencing any change in interface.
Where It Adds Less Value
Short, single-turn tasks rarely benefit. If a task is simple enough that Sonnet handles it correctly without assistance, adding an advisor introduces overhead without meaningful quality improvement. The pattern is optimized for multi-step agentic workflows, not single completions.
Tasks requiring Opus for every step — highly complex mathematical proofs, frontier research reasoning, tasks where every decision requires expert judgment — are better served by pure Opus. The Advisor Strategy assumes a meaningful fraction of steps are routine. If none are, the pattern does not help.
Latency-sensitive applications should test carefully. Advisor consultations add round-trip time within the API call. Anthropic has not published latency benchmarks for advisor invocations specifically, but any additional model call adds overhead. Measure the actual latency impact before adopting the pattern in real-time user-facing contexts where response speed is critical.
Cost Analysis: The Real Numbers
Anthropic’s 11.9% cost reduction claim compares the Advisor Strategy against pure Opus for the same task, not against pure Sonnet. The Advisor Strategy costs slightly more than pure Sonnet (due to occasional Opus advisor calls) but significantly less than pure Opus (because the majority of tokens run at Sonnet rates).
A rough model for a typical 100-step agentic coding task illustrates the economics:
- 90 steps handled by Sonnet at Sonnet pricing: approximately 18,000 tokens
- 10 advisor consultations handled by Opus at Opus pricing: approximately 5,000 tokens
- Total cost: approximately 85–90% of running the identical task entirely on Opus
For high-volume agentic workloads — teams running hundreds of agent tasks daily — an 11.9% reduction on your largest model line item is material. According to our analysis, teams spending $10,000 per month on Opus-powered agents could recover $1,100–$1,400 monthly with zero change to output quality on the most complex tasks. To model the exact impact for your workload, use our AI prompt cost calculator. Enter your current Opus costs and model what an 11–12% reduction does to your monthly AI infrastructure spend.
How the Advisor Strategy and Claude Managed Agents Fit Together
Anthropic released two major developer platform features this week. The Advisor Strategy (April 9, 2026) is a new API pattern for cost-efficient intelligence distribution. Claude Managed Agents (April 8, 2026) is a production infrastructure layer that handles sandboxing, session persistence, credential isolation, and tool execution for agents running at scale — priced at $0.08 per session-hour plus standard token rates.
The two features are architecturally complementary. You can deploy the Advisor Strategy inside agents running on the Managed Agents platform, combining production-grade infrastructure reliability with the intelligence economics of the executor-advisor pattern. Managed Agents solves the operational problems every production agent hits: state recovery after dropped connections, secure sandbox isolation, and scoped permissions for tool access. The Advisor Strategy solves the cost-quality allocation problem. Together, they represent Anthropic’s most complete story for production agent deployment to date.
If you are building production agents today, the Managed Agents platform handles the infrastructure concerns that most developers get wrong on first build. The Advisor Strategy then optimizes the intelligence layer inside those agents. For serious production deployments, these two features belong together. For a deeper look at multi-model routing patterns beyond the Advisor Strategy, see our complete guide to routing across GPT-5.4, Claude 4.6, and Gemini.
Developer Recommendation
For teams currently running agents on pure Opus: the Advisor Strategy is worth testing immediately. The migration path is minimal — add a beta header, declare one additional tool, and tune your system prompt. The potential cost savings at high agentic task volumes can be substantial, and the quality impact is positive according to Anthropic’s published benchmarks.
For teams currently running agents on pure Sonnet: evaluate whether your application has a meaningful fraction of genuinely hard decisions where the output quality today is not meeting your bar. If you are seeing quality failures on complex tasks that Sonnet handles poorly, the Advisor Strategy may resolve them without the full cost overhead of switching entirely to Opus.
For developers building new agents from scratch: consider starting with the Advisor Strategy as your default architecture rather than an afterthought. The executor-advisor pattern maps naturally to how most complex tasks are actually structured — mostly routine execution with occasional hard decisions — and gives you a principled way to calibrate escalation criteria as you learn where your application genuinely needs Opus-level judgment and where Sonnet is sufficient.
The feature is available in public beta now. Add anthropic-beta: advisor-tool-2026-03-01 to your API request headers to start testing today. Anthropic has indicated it will move to general availability after the beta period, with the current pricing structure locked in.