The Claude Code advisor is a feature that lets a cheaper, faster model do the routine work while a stronger model steps in only at the hard moments. You run Sonnet 5.5 as your main model, pick Opus 5.5 as the advisor, and Claude consults it before committing to an approach, when it is stuck, and before it says "done". It is experimental, and in version 2.1.287 (October 1, 2026) the pairing rules got friendlier.
If you searched "what does advisor do in Claude Code?" or "how to use advisor mode in Claude Code?", this guide answers both: what it is, how to turn it on, which models pair with which, what it costs, and when it is the wrong tool. Everything below comes from the official advisor docs and the Claude Code changelog.
Key Takeaways
- The advisor lets a cheaper main model do routine work while a stronger one steps in only before committing to a plan, when stuck, and before declaring done.
- Turn it on with /advisor opus, the advisorModel setting, or claude --advisor opus for one session. The advisor must rank at or above the main model.
- Sonnet 5.5 main with Opus 5.5 advisor is the go-to pairing. In the article's assumed-numbers illustration it costs $8.20 versus $12.00 for running Opus throughout.
- Claude Code 2.1.287 added Sonnet 5.5 advising Opus 4.7 and 4.8, and now flags invalid pairings up front instead of silently dropping the advisor.
- Product managers get a built-in second opinion: ask Claude to consult the advisor before the plan and before finishing, then press Ctrl+O to read its plain-language reasoning for PRD reviews and discovery synthesis.
Learn this hands-on
Go from idea to a live product with real users. Build and ship your first SaaS with Claude Code in a live cohort, with auth, payments and deployment done by the end. Join the Ship Your First SaaS with Claude Code cohort.
What the Claude Code advisor tool actually does
The advisor tool lets Claude consult a second, typically stronger model mid-task. The advisor receives the full conversation, including every tool call and result, and returns guidance that Claude applies before continuing.
Three details matter:
- Claude decides when to call it. You choose the advisor model, but you do not schedule the calls.
- It runs server-side. The advisor runs on Anthropic's infrastructure as a server tool, and it is available to both subscription and API-billed accounts.
- It is a second opinion, not a handoff. Your main model keeps driving. The advisor never edits files or runs commands for you.
Think of a strong senior engineer who reviews the plan and the final result, while a faster colleague does the typing in between.
When Claude calls the advisor
Per the docs, Claude consults the advisor at three kinds of moments:
- Before committing to an approach, when the plan will shape everything that follows.
- When stuck on a recurring error, instead of trying the same fix a fourth time.
- Before declaring a task complete, as an independent check.
That is why the advisor fits long, multi-step tasks where most turns are routine but plan quality determines the outcome: large refactors, debugging a recurring error, or any task you want independently checked. It adds less on short tasks, and it does not help where every single turn needs the strongest model. In that case, just switch the main model.
Three ways to turn on /advisor
1. The /advisor command. Type /advisor to open a picker, or /advisor opus to set it directly. The choice is saved to advisorModel in your user settings, and Claude Code confirms with "Advisor set to
2. A settings file. Add this to any settings file:
{
"advisorModel": "opus"
}
3. A flag for one session. Start Claude Code with claude --advisor opus. It applies to that session only, and it is not listed in --help.
Once the advisor is active, Claude Code shows: "Advisor Tool (experimental) is on and may use more tokens · /advisor". To turn it off, run /advisor off. To disable the feature entirely, set the environment variable CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1.
One note for automation: running /advisor non-interactively (in -p mode, the SDK, desktop, or Remote Control) requires Claude Code v2.1.260 or later.
Which models can advise which: the pairing table
The rule is simple: the advisor must rank at or above the main model. Here is the table from the docs.
| Main model | Accepted advisors |
|---|---|
| Haiku 4.5 | Fable, Opus, Sonnet |
| Sonnet 4.6 | Fable, Opus, Sonnet |
| Opus 4.6 | Fable, Opus, Sonnet 5 or later |
| Sonnet 5 | Fable, Opus 4.7 or later, Sonnet 5 or later |
| Opus 4.7 or 4.8 | Fable, Opus 4.7 or later, Sonnet 5.5 (requires 2.1.287) |
| Sonnet 5.5 | Fable, Opus 5 or later, Sonnet 5.5 |
| Opus 5 or 5.5 | Fable, Opus 5 or later |
| Fable 5 | Fable 5.1 or Fable 5 |
| Fable 5.1 | Fable 5.1 |
Haiku can call the advisor but cannot be one. The aliases fable, opus and sonnet resolve to Claude Code's current default for each family, and full IDs such as claude-opus-5-5 work too. Subagents inherit the advisor and apply the same check.
What changed in Claude Code 2.1.287
Two things. First, Sonnet 5.5 can now advise Opus 4.7 and 4.8, which is why that row of the table carries the "requires 2.1.287" note. Second, advisors the API would refuse are now flagged up front instead of being silently dropped.
Before that, a bad pairing simply meant no advisor and no warning. If the pairing fails, Claude Code still does not attach the advisor, and if the API refuses it anyway, the request is resent without it. The difference is that you now find out immediately.
The pairings worth using
The docs list several common combinations:
- Sonnet main + Opus advisor: routine work on Sonnet, with planning, ambiguous failures and completion checks escalated to Opus. This is the cost play.
- Sonnet main + Fable advisor: the same idea with the top model as the reviewer.
- Haiku main + Opus advisor: the lowest-cost main model with a strong brain on call.
- Opus main + Opus advisor: an independent check for high-stakes tasks.
- Fable + Fable and Sonnet + Sonnet: same-tier pairs, for a fresh read of the same transcript.
With the Opus 5.5 and Sonnet 5.5 releases (Opus 5.5 is Claude Code's default Opus since 2.1.280 on September 22, 2026, and Sonnet 5.5 the default Sonnet since 2.1.284 on September 28), "Sonnet main, Opus advisor" is the pairing most people will reach for. If you want to compare the two models head to head first, read Claude Opus 5.5 vs Sonnet 5.5 in Claude Code.
A worked cost illustration: Sonnet 5.5 main, Opus 5.5 advisor
Each advisor call bills the advisor model's input and output rates on top of the main model (on the API), or counts toward your plan usage limits (on a subscription). The docs say Claude calls the advisor at decision points, not every turn, so a fast main model plus a strong advisor typically costs less than running the strong model throughout.
Here is the arithmetic, using list prices: Sonnet 5.5 is $2 input / $10 output per million tokens, and Opus 5.5 is $4 / $20.
This is an illustration with assumed numbers, not a measurement. Suppose a long task consumes 2M input tokens and 200K output tokens on the main model, and Claude calls the advisor 5 times, each call reading a 100K-token transcript and writing 2K tokens of guidance. I ignore prompt caching for simplicity.
| Setup | Calculation | Total |
|---|---|---|
| Opus 5.5 for everything | 2M x $4 + 0.2M x $20 | $12.00 |
| Sonnet 5.5 main only | 2M x $2 + 0.2M x $10 | $6.00 |
| Sonnet 5.5 main + 5 Opus 5.5 advisor calls | $6.00 + (0.5M x $4) + (0.01M x $20) | $8.20 |
Under those assumptions, the advisor setup lands around a third cheaper than running Opus throughout, while the hardest decisions still get Opus-level attention. Your numbers will differ. More advisor calls, or a longer transcript per call, push the total up.
Two docs details affect the real bill. Toggling /advisor does not invalidate the main model's prompt cache. But the advisor's own read of the conversation is not cached, so each call processes the full transcript anew. Check /usage to see what it actually costs you, and see how to reduce Claude Code token usage for the habits that matter more than any model choice. A Fable advisor bills to usage credits where Fable does.
What you see during a session
When Claude consults the advisor, the transcript shows an "Advising" line with the advisor model. The result then appears as one of three states:
- Reviewed: the advisor answered. Press Ctrl+O to read the guidance.
- Declined: the advisor declined to advise.
- Unavailable (error code): the call failed, with the error code shown.
Claude generally follows the guidance, but it surfaces a conflict when its own evidence contradicts the advice. You can also nudge it with a prompt like "consult the advisor before you continue". There is no setting to cap or force advisor calls, so a prompt is the only lever.
Advisor vs opusplan vs subagents vs /model
These four features all mix models, but they work differently.
| Feature | What it does | Who triggers it |
|---|---|---|
| Advisor | A stronger model weighs in at decision points mid-task | Claude calls it |
| opusplan | Opus during plan mode, then Sonnet for execution | You enter plan mode |
| Subagents with a model set | A whole delegated subtask runs on another model | You or Claude delegate |
| /model | Switches the main model from the next request onward | You |
The practical difference: opusplan splits by phase, so Opus plans once up front. The advisor can step in at any point, including when a plan falls apart halfway through or just before completion. If you already use planning, my complete guide to Claude Code plan mode shows how the two ideas complement each other. For another way of spending more model effort on hard tasks, see Claude Code ultracode.
Claude Code advisor for product managers
If you are a PM using Claude Code, you probably cannot judge a diff line by line. That is exactly why the advisor matters. "A second opinion before declaring done" works as a review step you do not need to be an engineer to benefit from.
Practical setup: put "advisorModel": "opus" in your user settings, keep Sonnet as your main model, and when you ask for something bigger, add one line to the prompt: "consult the advisor before you commit to a plan, and again before you tell me it is finished." Then press Ctrl+O on the "Reviewed" lines to read what the advisor said. Those notes are plain-language reasoning you can bring to your engineers.
It works well for competitive teardowns where you want a second angle, PRD or spec reviews, and discovery synthesis where the first pass may have missed a pattern.
Product manager and want to work like this? This is exactly what we teach in Claude Code for PMs, our live cohort for product teams: 3 live sessions of 90 minutes over 2 weeks. Every PM ships a real feature, builds their own agent, and gets personalized written feedback.
Limitations to know before you rely on it
- Anthropic API only. The advisor tool is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, or Microsoft Foundry.
- Experimental. Claude Code labels it that way on startup, so expect the details to keep moving.
- Supported main models only: Fable, Opus 4.6+, Sonnet 4.6+ and Haiku 4.5.
- Feature-flag fetching must be on. Setting
DISABLE_TELEMETRYturns it off. - No cap, no force. You cannot limit how often Claude calls the advisor, or require it.
- Extra tokens. Claude Code warns that it "may use more tokens", and each call re-reads the whole transcript.
Should you turn it on?
If your sessions are long and mostly routine, with a few moments where the plan decides everything, yes. Set Sonnet 5.5 as your main model, add Opus 5.5 as the advisor, and watch /usage for a week. If your tasks are short, or every step needs maximum reasoning, skip it and just switch the main model.
Anthropic explains the thinking behind the pattern in The advisor strategy, and the platform-side tool is documented in the advisor tool docs.
