Without Sacrificing Intelligence
Anthropic just shipped the Advisor Strategy — a one-line API change that lets cheap models do the work while Opus steps in only when it actually matters.
If you’re building AI agents on the Claude API, you already know the tax: every time you need real intelligence, you’re paying Opus prices.
On April 9, 2026, Anthropic shipped something that changes that calculus. They call it the Advisor Strategy — a new API pattern that lets Sonnet or Haiku run your entire agent workflow, with Opus stepping in only on the decisions that actually need it.
The benchmarks are real (we verified them against Anthropic’s official blog). The implementation is genuinely one line. And the cost math is compelling enough that if you’re running agentic workloads today, you should test this this week.
You’re building a coding agent. Or a research pipeline. Or a document classifier. Whatever it is, you hit the same wall:
Use Opus 4.6
Great output. But at $5/$25 per million tokens, a busy agent workflow gets expensive fast. The bill doesn’t scale with your users.
Use Haiku 4.5
Cost-effective at $1/$5 per million tokens. But drops the ball on complex reasoning, ambiguous planning, and edge cases.
The real question: For any given turn in your agent loop — does this step actually need Opus-level reasoning? Usually the answer is no. The Advisor Strategy is built around that observation.
The core idea inverts the usual “big model orchestrates small models” pattern. Instead:
Claude Sonnet 4.6 or Haiku 4.5
Runs the entire task: calls tools, processes results, iterates toward the solution, generates all output. Handles 95%+ of the work at the lower token rate.
When the executor hits a hard decision it can’t solve →
↓
Claude Opus 4.6
Reads the full shared context and returns a short plan, correction, or stop signal — typically just 400–700 tokens. Never calls tools. Never handles output. Advises only.
Opus responds → executor resumes with new direction →
↓
Result: All of this happens inside a single API call. No separate orchestration layer. No context handoff code. Shared context automatically.
The key insight: because Opus only generates a short guidance block per consultation, and the executor handles all heavy output at the cheaper rate, total cost stays well below running Opus end-to-end.
Source: Anthropic official blog, April 9, 2026 — claude.com/blog/the-advisor-strategy
These numbers come directly from Anthropic’s launch post and have been corroborated across multiple independent sources. Let’s break them down.
Sonnet 4.6 + Opus 4.6 Advisor
Benchmark: SWE-bench Multilingual (end-to-end code generation across 9 languages, 300 problems, 5 trial average)
Sonnet alone
72.1%
Sonnet + Opus Advisor
74.8%
Cost vs Sonnet alone
-11.9%
cheaper per task
What this means: You get better results AND pay less. The advisor adds intelligence on hard turns; Sonnet handles routine turns cheaply. The net is a win on both axes.
Haiku 4.5 + Opus 4.6 Advisor
Benchmark: BrowseComp (web research task completion)
Haiku alone
19.7%
Haiku + Opus Advisor
41.2%
+2x improvement
Cost vs Sonnet alone
-85%
per task cost
What this means: Haiku with an Opus advisor still trails Sonnet in raw score, but at 85% lower cost per task. For high-volume workloads where most turns are routine, this combination is hard to beat.
The real-world saving context: For a typical 25-turn coding agent with 3 advisor consultations, Sonnet + Opus advisor costs roughly 73% less than Opus solo. Haiku + Opus advisor costs about 87% less than Opus solo. Numbers from independent analysis corroborating Anthropic’s data.
Beta as of April 9, 2026 · Requires beta header
Two things to add to your existing API request. That’s it. No separate orchestration code, no context management, no additional endpoints.
Step 1 — Add the beta header to every request
anthropic-beta: advisor-tool-2026-03-01
This is required for the beta. Add it to your HTTP headers.
Step 2 — Python (Anthropic SDK)
# Sonnet as executor, Opus as advisor
response = client.messages.create(
model=“claude-sonnet-4-6”, # executor
tools=[
{
“type”: “advisor_20260301”,
“name”: “advisor”,
“model”: “claude-opus-4-6”, # advisor — only Opus supported
“max_uses”: 3, # cap Opus calls per request
},
# … your other tools (bash, web search, etc.)
],
messages=[…]
)
The advisor tool works alongside your other tools in the same request. No structural changes to your existing agent loop.
For maximum cost savings — Haiku as executor
response = client.messages.create(
model=“claude-haiku-4-5”, # cheapest executor
tools=[{
“type”: “advisor_20260301”,
“name”: “advisor”,
“model”: “claude-opus-4-6”,
“max_uses”: 5, # higher for complex tasks
}],
)
Tracking advisor token spend separately
# Advisor tokens are reported separately in the usage block
print(response.usage.input_tokens) # executor tokens
print(response.usage.advisor_tokens) # Opus tokens — billed at Opus rates
Use this to measure your actual Opus spend per task and tune max_uses accordingly.
Beta Limitations — What Nobody Else Is Telling You
⚠
Only Opus 4.6 is supported as advisor. You can’t use Sonnet as an advisor for Haiku. The beta locks advisor to claude-opus-4-6 only.
⚠
Priority Tier doesn’t cascade. If you’ve bought Priority Tier for Sonnet (for low latency guarantees), that doesn’t extend to advisor calls. Opus consultations use standard throughput unless you separately purchase Priority Tier for Opus.
⚠
No streaming for advisor responses. The advisor’s output arrives as a complete block, not streamed. For long-running loops, time-to-first-token increases by the advisor’s generation time each consultation.
⚠
API surface can change before GA. Anthropic hasn’t announced a general availability date. Pin to the beta version string (advisor-tool-2026-03-01) and test after updates.
⚠
Not the right tool for every workload. Single-turn Q&A, simple lookups, or tasks where every step genuinely needs Opus — the advisor adds overhead without benefit.
Strong fit — use Advisor Strategy here
✓
Multi-step coding agents where most turns are mechanical but occasional decisions need real reasoning
✓
High-volume document classification or extraction pipelines with occasional edge cases
✓
Legal or financial data processing where 95% of records are routine but some need senior judgment
✓
Research pipelines with multi-step web browsing and synthesis (BrowseComp result confirms this)
Weak fit — skip it for these
✗
Single-turn Q&A — no iteration loop means nowhere for the advisor to add value
✗
Simple deterministic tasks where Haiku alone handles everything correctly
✗
Latency-critical paths where an Opus pause on every hard turn breaks your SLA
✗
Tasks where every turn genuinely requires Opus-level reasoning — advisor becomes overhead
Before you commit to the advisor pattern in production, Anthropic recommends running your own evaluation — not just trusting the published benchmarks:
Run your existing eval suite with Sonnet alone — establish your baseline score and cost per task
Run the same eval with Sonnet + Opus advisor — measure score delta and actual advisor token usage
Run with Opus solo — this is your quality ceiling and cost floor comparison point
Now you have the actual quality-cost tradeoff for your specific workload. The published benchmarks are a starting point, not a guarantee. Your task distribution may differ.
Launch date
April 9, 2026 — Beta
Supported combinations
Sonnet 4.6 + Opus 4.6
Haiku 4.5 + Opus 4.6
Advisor tokens per call
Typically 400–700 output tokens at Opus rates
Cost control
Set max_uses to cap Opus calls per request
Sonnet + Opus result
+2.7pp on SWE-bench Multilingual
-11.9% cost vs Sonnet alone
Haiku + Opus result
19.7% → 41.2% on BrowseComp
-85% cost vs Sonnet alone
Claude Code users · settings.json · Measured by Affaan (everything-claude-code)
The Advisor Strategy works at the API level. But if you’re using Claude Code directly, there’s a parallel optimization that takes 60 seconds to set up — and it compounds on top of everything above.
Open ~/.claude/settings.json and add this:
~/.claude/settings.json
{
“model”: “sonnet”,
“env”: {
“MAX_THINKING_TOKENS”: “10000”,
“CLAUDE_AUTOCOMPACT_PCT_OVERRIDE”: “50”,
“CLAUDE_CODE_SUBAGENT_MODEL”: “haiku”
}
}
How to get there: terminal → cursor .claude → open settings.json
| Setting | Default | Recommended | Effect |
|---|---|---|---|
model | opus | sonnet | ~60% cost reduction. Sonnet handles ~80% of coding tasks just as well. Switch to Opus mid-session with /model opus when you actually need deep reasoning. |
MAX_THINKING_TOKENS | 31,999 | 10,000 | ~70% reduction in thinking costs. Extended thinking reserves up to 31,999 output tokens per request for internal reasoning — you’re billed for all of it. 10,000 is plenty for most coding tasks. Set to 0 to disable entirely for trivial tasks. |
CLAUDE_AUTOCOMPACT_PCT_OVERRIDE | ~83% | 50 | Earlier compaction = better session quality. Compresses context at 50% capacity instead of waiting until ~83%. Keeps sessions healthier and avoids quality degradation in long tasks. Note: values above 83 are internally capped — you can only compact earlier, not later. |
CLAUDE_CODE_SUBAGENT_MODEL | (main model) | haiku | ~80% subagent cost reduction. Subagents (Task tool) handle file exploration, test runs, log reading. Haiku is sufficient for these mechanical tasks and runs in its own context window — verbose output stays there, only a summary returns to your main session. |
Fact-checked: The default for CLAUDE_AUTOCOMPACT_PCT_OVERRIDE is ~83%, not 95% as sometimes cited. The variable has an internal Math.min() clamp — values above ~83 are silently capped. Setting it to 50 compacts earlier than the default, which improves session quality on long tasks.
Pair with these daily commands for maximum savings
# Switch models dynamically mid-session
/model sonnet # default — most tasks
/model opus # complex architecture, deep reasoning only
/model haiku # formatting, renaming, trivial edits
# Context management — most overlooked cost lever
/clear # between unrelated tasks — stale context wastes tokens every turn
/compact # at logical breakpoints before context grows
# Monitor your actual spend
/cost # shows token usage and cost for current session
/context # shows exactly where tokens are going (system prompt, tools, history)
Hidden cost most people miss: Claude reprocesses your entire conversation history on every turn. Message 30 costs 31× more than message 1 in input tokens. /clear between unrelated tasks isn’t optional — it’s the highest-leverage habit you can build.
💰
The official Anthropic blog post has the full docs, system prompt recommendations, and benchmark methodology. Worth reading before you implement.
Read Anthropic’s Official Post →
Bookmark this for when you’re ready to implement. The code snippets above are ready to paste.
Share this guide
Know someone paying too much for Opus? 💸
This one-line API change could save them thousands a month.
Every share reaches a dev who’s been burning Opus tokens on routine tasks 🙏
