Pairing a fast model with a second opinion
Most of an agentic coding task is routine: read a file, make an edit, run a check, move to the next step. The moments that actually decide whether a task lands well are rarer, a plan worth getting right before a lot of work builds on top of it, an error that keeps recurring in a way that suggests the whole approach is wrong, or a point where Claude is about to declare something finished and it's worth a second look first. Claude Code's advisor tool lets your main model consult a second, typically stronger model at exactly those moments, without running the stronger model for the entire session.
You configure which model plays the advisor. Claude decides when to call it. The advisor receives the full conversation, every tool call and result included, and returns guidance Claude applies before continuing.
This is the same underlying advisor server tool available directly on the Claude Messages API, and the same pattern behind multiagent orchestration in Claude Managed Agents. Claude Code's /advisor is the CLI's own front end to it: where the Messages API version has you wire up executor and advisor roles yourself as a tool definition, Claude Code just needs you to pick a model.
The advisor tool is experimental and requires the Anthropic API. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, or Microsoft Foundry.
Turning it on
Three ways to set the advisor, in order of how long the choice sticks:
The /advisor command, for setting or changing it mid-session (and saving it as your default going forward):
/advisor opus
Run /advisor with no argument to open a picker instead. The command confirms with Advisor set to and the model name, and saves the choice to advisorModel in your user settings.
The advisorModel setting, for a persistent default without opening a session:
{
"advisorModel": "opus"
}
The --advisor flag, for one session only, without touching your saved setting:
claude --advisor opus
Once enabled, Claude Code shows an Advisor Tool (experimental) is on and may use more tokens · /advisor notice at session start. To stop, run /advisor off or select No advisor in the picker, which also clears your saved advisorModel.
Which pairings are accepted
The advisor has to be at least as capable as your main model. Claude Code enforces this before every request:
| Main model | Accepted advisors | Notes |
|---|---|---|
| Haiku 4.5 | Fable, Opus, Sonnet | Haiku can call an advisor but can never act as one |
| Sonnet 4.6 | Fable, Opus, Sonnet | |
| Sonnet 5 | Fable, Opus, Sonnet 5 | A Sonnet 4.6 advisor is rejected |
| Opus 4.6 | Fable, Opus, Sonnet 5 | Sonnet 5 and Opus 4.6 rank as equally capable |
| Opus 4.7 or later | Fable, Opus 4.7 or later | Any two Opus 4.7+ models can advise each other; an Opus 4.6 or Sonnet 5 advisor is rejected |
| Fable 5.1 or Fable 5 | Fable 5.1, or the same Fable version | An Opus or Sonnet advisor is always rejected for a Fable main model |
Set the advisor with the shorthand aliases fable, opus, or sonnet, which resolve to Claude Code's current built-in default for that model family, or pass a full model ID such as claude-opus-5 directly. Fable 5.1 as an advisor requires Claude Code v2.1.255 or later; Fable 5 requires v2.1.170 or later, plus Fable access. Subagents inherit the session's configured advisor and are checked against the same pairing rules using their own model.
If a saved advisor turns out to be too weak for the main model you switch to, or your organisation's model allowlist excludes it, Claude Code simply doesn't attach it to that request rather than erroring out; the /advisor output and a session notice both say so.
Fable as advisor and usage credits
On plans where Fable usage bills to usage credits, a Fable advisor bills the same way, and needs the same one-time consent as selecting Fable as your main model. Until you've given that consent, Claude Code won't save Fable as your advisor, whether through /advisor fable, the picker, or --advisor fable, and points you to /model fable instead. Accept the consent there, and Fable becomes available as an advisor too.
Common pairings and what they're for
| Pairing | When to use it |
|---|---|
| Sonnet main + Opus advisor | Sonnet does routine work, escalates planning and ambiguous failures to Opus |
| Sonnet main + Fable advisor | Fable-quality guidance at decision points, without running Fable throughout |
| Haiku main + Opus advisor | Lowest-cost main model with strong planning; costs more than Haiku alone, less than switching the main model up |
| Opus main + Opus advisor | An independent second Opus review, for high-stakes tasks where cost matters less than an independent check |
| Fable main + Fable advisor | The highest-capability pairing available |
| Sonnet main + Sonnet advisor | A cheap second opinion for catching routine oversights |
What you see during a consultation
When Claude calls the advisor, the transcript shows an Advising line naming the advisor model while the call runs. Once it returns:
- Reviewed: the advisor gave guidance. Press
Ctrl+Oto read it. - Declined: the line reads
Advisor declined to advise on this request. If a reason was given,Ctrl+Oshows it too.
Claude generally follows the advice, but not unconditionally: if a recommended step fails when actually tried, or the file contents contradict what the advisor said, Claude surfaces that conflict rather than pushing ahead regardless. There's no setting to force or cap how often the advisor gets called; if you want it consulted more or less, say so directly in your prompt, for example "consult the advisor before you continue."
Cost and prompt caching
Each advisor call reads the full conversation at the advisor model's own input and output rates, on top of whatever your main model is already costing. On subscription plans, that counts toward your usage limits the same as any other model call (a Fable advisor bills to usage credits specifically, on plans where Fable does). Because Claude only calls the advisor at decision points rather than on every turn, this typically costs less than running the stronger model as your main model for the whole session, the entire premise behind pairing a fast main model with an occasional, expensive check-in rather than a uniformly expensive one. Advisor usage is included in the totals /usage reports for the session.
Toggling the advisor mid-session, unlike switching your main model, does not invalidate your prompt cache: the cached prefix stays intact, and the advisor's returned guidance becomes part of the cached transcript on later turns. The advisor's own read of the conversation isn't cached, though. Every consultation re-reads the full transcript from scratch, with nothing carried over between calls.
How it compares to opusplan and subagents
Claude Code already has other ways to bring a stronger model into a task. The advisor is one of four:
| Approach | When the stronger model runs | How it starts |
|---|---|---|
| Advisor tool | At decision points mid-task | Claude calls it when it judges guidance is needed |
opusplan | During plan mode, then switches to Sonnet for execution | You enter plan mode |
Subagents with a model set | For the entire delegated subtask | Claude delegates, or you invoke the subagent directly |
/model | From the next request onward | You switch models yourself |
The advisor's distinguishing feature is that Claude, not you, decides the moment: it's suited to tasks where most turns are routine and a small number of decisions determine the outcome, rather than tasks where every turn genuinely needs the stronger model's judgment.
Requirements and turning it off entirely
The advisor tool needs all of the following:
- Anthropic API only: not available through Bedrock, Claude Platform on AWS, Vertex, or Foundry. Through an LLM gateway using
ANTHROPIC_BASE_URL, whether it works depends on whether the gateway forwards the request to the Anthropic API unmodified. - A supported main model: Fable, Opus 4.6 or later, Sonnet 4.6 or later, or Haiku 4.5.
- Feature-flag fetching: Claude Code enables the advisor through a feature flag it fetches from Anthropic. A session with flag fetching disabled, such as one with
DISABLE_TELEMETRYset, never gets it.
To disable the advisor entirely rather than just clearing your model choice, set CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1. That removes /advisor from the command list, ignores any configured advisorModel, and makes --advisor a no-op rather than an error.
Troubleshooting
/advisor shows no models to pick. Confirm your main model actually supports the advisor (Fable, Opus 4.6+, Sonnet 4.6+, or Haiku 4.5) and that your session has feature-flag fetching enabled, not disabled by DISABLE_TELEMETRY or a similar variable.
I set an advisor but it's never actually consulted. There's no way to force a call from configuration alone; Claude decides based on the task. Ask explicitly in your prompt if you want more frequent consultations, or check whether the pairing was silently rejected, an advisor weaker than your main model doesn't attach, and Claude Code notifies you when that happens.
--advisor exits at launch instead of starting the session. This happens when the main model doesn't support the advisor, the requested advisor can't fill that role for your main model, your organisation's model allowlist excludes it, or you asked for Fable without having given the usage-credits consent yet. A background session started with --advisor under any of these conditions starts without the advisor instead of exiting.
Advisor spend looks higher than expected. Check /usage for the session breakdown; because the advisor bills at its own model's rate for every call it makes, a task with many decision points can accumulate more advisor cost than an equivalent task with a smoother path through it.
Where this fits
The advisor tool sits alongside Claude Managed Agents' multiagent roster and the Messages API's standalone advisor tool as three surfaces for the same underlying idea: get a stronger model's judgment at the moments that matter, without paying for it throughout. For the rest of Claude Code's model controls, see model configuration, and for everything else the CLI supports, browse Claude Code's platform page.