Skip to content
VAR/LOG/INFO
Claude's advisor tool: a cheaper model with a senior reviewer on call
AI

Claude's advisor tool: a cheaper model with a senior reviewer on call

Claude's advisor tool lets a cheaper model do the work and call a stronger one at key moments. How to enable it, what it costs and which pairs are allowed.

Picture a junior developer who is quick, cheap and good at routine work, and a senior engineer who is expensive and sits in the next room. You would not ask the senior to write every function, but you would want the junior to knock on the door before choosing an architecture, when the same bug keeps coming back, and before saying the work is done. The advisor tool is that arrangement for Claude.

It is easy to miss, even for people who use Claude Code every day, because nothing prompts you to turn it on. This article is based on Anthropic’s own documentation for Claude Code and for the Claude API, both of which describe the feature as experimental or in beta, so details may change.

How the mechanism works

The main model, which the API docs call the executor, runs the task as usual. When it decides it needs guidance, it calls the advisor like any other tool. Anthropic then runs a separate inference on the advisor model on its own servers, and that model receives the executor’s whole transcript: the system prompt, tool definitions, earlier turns and every tool result. What comes back is a short piece of advice, which the executor reads before it carries on.

Two details explain why the economics work. The advisor runs without tools of its own and its thinking is discarded before the result is returned, so only the advice text reaches the executor. And the API docs put typical advisor output at 400 to 700 text tokens, or 1,400 to 1,800 including thinking, which is small next to the thousands of tokens the executor writes to actually do the job.

Nothing here is automatic in the sense of a schedule. The executor chooses when to ask, and Claude Code offers no switch to force or cap the number of consultations. If you want more of them, say so in the prompt, for instance by asking Claude to consult the advisor before it continues.

Why not simply use the stronger model

There are two obvious alternatives, and both have a cost. Running everything on a mid-tier model like Sonnet is affordable, but a wrong early decision can send a long task down the wrong road for dozens of steps. Running everything on Opus or Fable gives better plans, yet you pay top rates for the many turns that only read a file or run a test.

The advisor sits between the two. Anthropic says the pattern suits long agentic work where most turns are mechanical but the plan matters, and that you get close to advisor-solo quality while most tokens are generated at the executor’s rate. That claim is task-dependent, and the docs themselves say to evaluate it on your own workload. They also say the benefit shrinks as the executor gets closer to the advisor in capability.

The second benefit has nothing to do with price. An advisor consulted before a task is declared finished acts as an independent reviewer. Claude does not treat the advice as an order, either: if a recommended step fails when tried, or the files contradict it, the documentation says Claude surfaces the conflict instead of following the advice blindly.

Short tasks are the weak spot. With little to plan, there is nothing to escalate, and for work where every turn needs the strongest model, you should simply switch the main model instead.

Setting it up in Claude Code

There is nothing to install. The advisor is built into Claude Code and runs on Anthropic’s servers, for subscription and API-billed accounts alike. What matters are the conditions around it:

  • It needs the Anthropic API. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud’s Agent Platform or Microsoft Foundry. Behind an LLM gateway, it works only if the gateway forwards the request intact.
  • Claude Code switches it on through a feature flag fetched from Anthropic, so if a variable that disables flag fetching is set, such as DISABLE_TELEMETRY, the advisor stays off.
  • Newer models need newer builds: Fable 5.1 as a pairing needs Claude Code 2.1.257 or later, and Haiku 5.5 needs 2.1.293. Keeping Claude Code current covers all of it.
  • If your organisation restricts models with availableModels, an excluded advisor will not be used.

To turn it on, pick one of three routes. Typing /advisor opens a model picker, and /advisor opus sets it directly and saves it as your default. The same value can live in your settings file as "advisorModel": "opus". For a single session, launch with claude --advisor opus, a flag that does not appear in claude --help. The aliases are fable, opus and sonnet, or you can use a full ID like claude-opus-5-5.

Once a session starts you should see a notice that the Advisor Tool is on and may use more tokens. When Claude consults the advisor, the transcript shows an Advising line, and Ctrl+O expands the advice. Use /advisor off to stop, or set CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1 to remove the feature altogether. Subagents inherit the advisor and are checked against the pairing rules using their own model.

Which pairs work and which do not

One rule governs everything: the advisor must rank at or above the main model. A weaker model cannot advise a stronger one, while equals can advise each other, so Opus 4.7 and Opus 4.8 can review one another, and Opus can even review Opus. The practical consequences are easiest to see by starting from the main model:

  • Haiku 4.5 or Sonnet 4.6 as main: Fable, Opus, Sonnet or Haiku 5.5 may advise. Haiku 4.5 can call an advisor but can never be one.
  • Opus 4.6: Fable, Opus, Sonnet 5 or later, or Haiku 5.5.
  • Sonnet 5 or Haiku 5.5: Fable, Opus 4.7 or later, Sonnet 5 or later, or Haiku 5.5.
  • Opus 4.7 or 4.8: Fable, Opus 4.7 or later, or Sonnet 5.5.
  • Sonnet 5.5: Fable, Opus 5 or later, or Sonnet 5.5.
  • Opus 5 or 5.5: only Fable or Opus 5 and later.
  • Fable 5: Fable 5.1 or Fable 5. Fable 5.1: only Fable 5.1.

So the combination people hit by accident is a Fable main model with an Opus or Sonnet advisor, which Claude Code will not apply. The mirror image fails as well: a Haiku 5.5 advisor behind a Sonnet 5.5 main model is rejected because it ranks lower. Fable models also require Fable access, and on some plans Fable as advisor bills to usage credits after a one-time consent that you give through /model fable.

The failures are quiet. If the advisor ranks below the main model, Claude Code simply does not attach it and says so in the /advisor output. If the API rejects a pairing that Claude Code did attach, the request is resent without the advisor, so you see no error, only no advice. A replacement advisor chosen afterwards takes effect after /clear or /compact. When you are unsure, run /advisor with no argument and read what it reports.

Anthropic’s own suggestions for sensible pairs are Sonnet with Opus for routine work with escalated planning, Sonnet with Fable when you have access, Haiku with Opus for the cheapest main model with strong planning, and Opus with Opus when an independent check matters more than cost.

What it costs

Each advisor call is billed at the advisor model’s rates, because the advisor reads the whole conversation again and that reading is not cached between calls. Through the API you pay the advisor’s input and output prices for those tokens, and on a subscription they count against your plan limits. In API responses the advisor tokens are listed separately in usage.iterations, since they are not folded into the top-level totals.

Claude calls the advisor at decision points rather than every turn, which is why a faster main model plus an occasional strong advisor usually costs less than the strong model throughout. How much less depends on how often it is called. Session totals, advisor included, appear in /usage.

Using the same thing from the API

If you build your own agents, the same capability is available in the Messages API. You add a tool of type advisor_20260301, named advisor, with the advisor’s model ID, and send the beta header advisor-tool-2026-03-01. The model pair must be valid: the advisor has to be Sonnet 4.6 or better and at least as capable as the executor.

The tool definition also takes optional limits. max_uses caps advisor calls per request, max_tokens caps the advisor’s output per call with a minimum of 1,024, and caching turns on prompt caching of the advisor’s own transcript across calls. Anthropic’s docs additionally cover resuming a paused turn and prompting executors that under-call the advisor.

Advisor, opusplan, subagents and /model

Claude Code has several ways to put a stronger model to work, and they differ in timing. With the advisor, the stronger model speaks at decision points and Claude decides when. With opusplan, the stronger model runs during plan mode, which you enter yourself, and Sonnet takes over for execution. A subagent with its own model runs an entire delegated subtask on that model. And /model changes the main model from the next request on.

If you want one thing to try, take a long task that you would normally give to Sonnet, run /advisor opus, and compare the /usage figures with what you usually see. The setting is saved, but it takes seconds to remove, so the experiment costs very little.