Claude Advisor Tool vs a Bigger Model: When the Pairing Pays

Use the Claude advisor tool when a cheaper executor runs a long agent loop and actually asks for help; otherwise raise effort or switch models. Anthropic's own coding runs show a Fable 5.1 advisor adding 1.7 points to Opus 5.5 at high for about 2.1 times the cost - roughly what more effort buys.

That is the short version of a cost guide Anthropic has updated with runs from as recently as October 7, and it is less flattering to the advisor pattern than the launch pitch. The advisor tool (advisor_20260301, beta header advisor-tool-2026-03-01) lets an executor model such as Claude Haiku 5.5 or Sonnet 5.5 consult a stronger model mid-request, server-side, in one /v1/messages call. Claude Code exposes the same thing as /advisor, and v2.1.293, the release that added Haiku 5.5, is the minimum version for using Haiku 5.5 on either side of the pairing. The question developers are actually asking is whether to pay for a pairing or just run the bigger model. Here is what the primary sources say, with every number labelled.

Official Sources#

At a Glance: Executors, Advisors, Prices#

The rule from the API docs: the advisor must be Claude Sonnet 4.6 or more capable, and at least as capable as the executor. An invalid pair returns a 400 invalid_request_error. Prices are list input/output per million tokens from Anthropic's pricing page, checked October 9, 2026.

Two things in that table surprise people. Sonnet 5.5 no longer accepts a Sonnet 5 or any Opus 4.x advisor, which is one of the breaking changes in the Sonnet 5.5 release guide. And the API docs list the advisor as available in beta on the Claude API and Claude Platform on AWS, but not on Amazon Bedrock, Google Cloud or Microsoft Foundry. Claude Code's own advisor page is stricter and says it needs the Anthropic API, listing Claude Platform on AWS among the unsupported routes. If you run on a cloud marketplace, the decision is already made for you: raise effort or switch models.

What One Advisor Call Costs#

Anthropic's docs say advisor output is "typically 400 to 700 text tokens, or 1,400 to 1,800 tokens total including thinking", and the advisor reads the executor's full transcript as input. The worked numbers below are our arithmetic at list prices, assuming a 50,000-token transcript, 1,600 advisor output tokens, and advisor-side caching off (its default).

The pattern that falls out: every model in this table prices output at five times input, so once the transcript is more than five times the length of the advice, the advisor's bill is mostly its reading, not its writing. On a long coding loop that is almost always true. Two levers follow, both from the docs:

• caching: {"type": "ephemeral", "ttl": "5m"} on the tool definition caches the advisor's own transcript across calls. Anthropic says it "breaks even at roughly three advisor calls", so turn it on for long loops and leave it off for short tasks. Claude Code's advisor page says Claude Code does not cache the advisor's read at all: each call processes the full transcript anew.
• max_tokens on the tool definition (minimum 1024) caps the advisor's thinking plus text per call. On a hard reasoning benchmark, Anthropic measured max_tokens: 2048 cutting mean advisor output from about 4,200 to 5,900 tokens down to about 630 to 840, with near-zero truncation. The top-level max_tokens does not bound advisor tokens.

There is also a cost you pay even when the advisor is never called. The tool definition is "about 1,000 prompt tokens per request". On GPQA Diamond, where neither executor consulted once, that alone added 12% to Haiku 5.5's cost per question and 25% to Sonnet 5.5's. For the economics of caching that prefix, see our Claude prompt caching production guide.

Benchmarks: What Anthropic Measured#

All rows are vendor-reported by Anthropic on its Optimizing for cost and intelligence page. The coding benchmark is Anthropic-internal (370 repository tasks graded by the repositories' own tests), so it cannot be reproduced. No third party has published advisor-pairing measurements we could find.

One qualifier on the headline coding result: Anthropic's footnote says the 279 pairing attempts in which the advisor was turned away under load were re-run, while attempts whose consults timed out were kept. The comparison point Anthropic charts it against, Fable 5.1 alone at high, solved 317 of 370 tasks (85.7%) with one attempt per task.

Read the table as two findings. First, the advisor buys capability only when the executor asks. Three of the four pairings on Anthropic's chart rarely or never consulted, and Anthropic's GPQA runs added the tool "without a system prompt that asks the executor to consult it". Second, when it does work, the advisor lands on the executor's own effort curve: Anthropic says it "buys about what more effort does". Opus 5.5 alone at xhigh scored a point higher than the pairing (from one attempt per task, against five for the pairing), for $4.11 instead of $2.92 per attempt, but with no beta header and no second model to manage.

The cost mechanism is visible in the coding numbers. With an Opus 5.5 executor, the advice saved almost nothing on the executor side ($1.36 per attempt against $1.38 alone) while the consultations cost $1.55. In August, with an Opus 5 executor, advice saved $1.26 per attempt in executor tokens against $2.47 of consultations, paying back about half. That is the "an executor told the right approach explores fewer dead ends" effect, and it shrinks as the executor gets closer to the advisor.

Pick by Task#

The baseline rule from Anthropic is worth taping to the monitor: "first price the advisor's model alone at low effort; that is the baseline to beat." If the executor consults on most tasks, you are paying advisor rates across the whole workload and running the advisor's model directly is cheaper. For the older two-dial version of this decision, effort versus switching models, see Fable 5 effort vs model switching.

Setting It Up#

Claude API#

This is the docs' quick start with the executor swapped for Haiku 5.5, the advisor for Opus 5.5 (a valid pair in the compatibility table), and the two cost controls added. We did not run it: no API key was available in this environment.

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-haiku-5-5",  # executor
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-5-5",  # advisor, billed at its own rates
            "max_tokens": 2048,
            "caching": {"type": "ephemeral", "ttl": "5m"},
        },
        # ... your other tools
    ],
    messages=[{"role": "user", "content": "Build a concurrent worker pool in Go with graceful shutdown."}],
)

The gotchas, all from the API docs:

1. Round-trip results verbatim. Some advisors return an encrypted advisor_redacted_result (the docs' example is Opus 5) and some return plaintext advisor_result (Opus 4.8). Pass the block back unchanged on the next turn, and branch on content.type if you switch advisors.
2. Top-level usage excludes advisor tokens. Sum usage.iterations and price advisor_message entries at the advisor's rates, or your cost dashboard will under-report.
3. Streaming goes quiet. The advisor sub-inference does not stream; you get SSE pings roughly every 30 seconds, then the whole result in one event.
4. pause_turn needs a resend with the same advisor tool and beta header, or the API returns a 400.
5. You cannot force a consult on the newest executors. Opus 5.5, Sonnet 5.5, Fable 5.1 and Mythos 5.1 executors reject tool_choice types tool and any, so use a prompt nudge. On Haiku executors, the docs' turn-2 reminder raised pass rates by "roughly 7 percentage points"; on Opus it slightly lowered them.
6. Budgets do not cover it. Advisor tokens do not draw from a task budget on the executor, and a Priority Tier commitment on the executor does not extend to the advisor.

If your agent already juggles client and server tools, the tool use production patterns guide covers the loop shape this slots into.

Claude Code#

Three ways to turn it on, verbatim from the Claude Code docs:

/advisor opus            # in a session; saved to advisorModel
claude --advisor opus    # one session only
/advisor off             # turn it off

Or set "advisorModel": "opus" in your settings file, and CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1 disables it entirely. Haiku 5.5 as main model or advisor needs Claude Code v2.1.293 or later; Fable 5.1 needs v2.1.257 or later. There is no setting to cap or force calls, so if you want more or fewer consultations, say so in your instructions.

The trap worth knowing: if the API refuses a pairing Claude Code attached, Claude Code resends the request without the advisor, and "you see no error and get no advisor calls". The advisor is also fetched behind a feature flag, so a session with DISABLE_TELEMETRY set keeps it off. If you turned it on and the transcript never shows an Advising line, check both before concluding the model just did not need help. Before adding a second model, our Opus 5.5 Claude Code playbook covers how to steer the main model itself.

What People Are Actually Saying#

• The UX case is real for interactive work. On an Ask HN thread about default models, wdm0006 runs "sonnet as main w/ opus advisor" in Claude Code and finds "a fast main model with a big smart advisor is a nice UX" when at the keyboard, but cares more about cost and quality than speed for unattended agents. That matches Anthropic's numbers: the advisor buys responsiveness and a few points, not a free lunch.
• Power users stack it with model routing. On the Opus 5.5 thread, rdli describes "a setup that uses Fable 5.1 as an advisor, Sonnet 5.5 for mechanical changes", the frontier-advisor-over-mid-tier-executor shape Anthropic calls most cost-effective.
• The counter-case: agreement is not verification. On a thread about LLM judges agreeing, ex1fm3ta finds it "kinda funny" that the Claude Code advisor "agrees with the ideas that the previous model did". The advisor sees only the executor's transcript, so it inherits the executor's framing. It is not a substitute for tests. LivePlan's corrective-steering research takes a different tack, letting a monitor decide when the advisor gets called instead of the executor.
• Open harnesses want the same thing. In the local Qwen discussion, walthamstow notes "Claude kind of has this already in their Advisor feature" and that open harnesses could call out to bigger models the same way. Our write-up of that thread is Local Qwen is a different tool, not a worse Opus.

FAQ#

What is the Claude advisor tool?#

It is a server-side tool (advisor_20260301, beta header advisor-tool-2026-03-01) that lets an executor model consult a stronger advisor model mid-request. The executor decides when to call it, Anthropic runs the advisor on the full transcript, and the advice comes back as an advisor_tool_result block in the same /v1/messages response.

Is the advisor tool cheaper than just using Opus?#

Sometimes. Anthropic's docs say a Sonnet executor with an Opus advisor "keeps total cost similar or lower" than Sonnet alone on complex tasks, but its own Opus 5.5 plus Fable 5.1 coding pairing cost about 2.1 times Opus 5.5 alone at high for a 1.7-point gain. If the executor consults on most tasks, running the stronger model directly is cheaper.

Which advisor should I pair with Haiku 5.5?#

Opus 5.5 is the natural pick at $4/$20 per million tokens, and the API accepts everything from Haiku 5.5 up to Mythos 5.1 as its advisor. Use the docs' coding system prompt or turn-2 nudge, because in Anthropic's GPQA runs a Haiku 5.5 executor with an Opus 5.5 advisor never consulted it.

How do I turn on the advisor in Claude Code?#

Run /advisor opus in a session, launch with claude --advisor opus, or set "advisorModel": "opus" in settings. Haiku 5.5 as the main model or advisor needs Claude Code v2.1.293 or later, and /advisor off turns it off.

Does the advisor tool work on Bedrock or Vertex?#

No. The API docs list it in beta on the Claude API and Claude Platform on AWS only, not on Amazon Bedrock, Google Cloud or Microsoft Foundry. Claude Code's advisor page says it requires the Anthropic API.

Sources#

Last updated: October 9, 2026

Continue Reading#

• Claude Opus 5.5 Developer Guide: Pricing, API, Claude Code - the executor and advisor most pairings above are built around
• Claude Haiku 5.5: Pricing, Migration Changes, and When to Use It - the cheapest executor, and the 100K pricing cliff to watch
• Prompt Caching in the Claude API: A Production Guide - the lever that matters more than any second model
• Tool Use in the Claude API: Production Patterns for Reliable Agents - the agent loop the advisor plugs into
• Fable 5 Effort vs Model Switching - the effort-first argument applied to Fable