Playbooks · Coding tasks
Run Sonnet with an Opus advisor in Claude Code
Written November 5, 2026
Sonnet does the routine work; Opus advises at decision points. How the advisor tool works, what it costs, and where it doesn't apply.
Running Opus on every turn burns money, but Sonnet alone can lock in a bad plan. The advisor tool splits the difference: Sonnet runs the session, and Opus — or another stronger model — is consulted at the moments that matter. The advisor is a server-side tool on Anthropic's infrastructure. It receives the full conversation, including every tool call and result, and returns guidance that Claude applies before continuing. Claude decides when to call it: before committing to an approach, when an error keeps recurring, or before declaring a task done.
Enable it three ways
The advisor documentation gives three ways to set the advisor model:
/advisorcommand: run/advisorwith no argument to open a picker of available advisor models, or pass the model directly, for example/advisor opus. The command confirms withAdvisor set tofollowed by the model name, and saves the choice toadvisorModelin your user settings so it persists across sessions. Run/advisor offto turn it off. The command needs Claude Code v2.1.260 or later.advisorModelsetting: set it in your settings file to configure a persistent default without opening a session.--advisorflag: launch withclaude --advisor opusto set the advisor for a single session without changing your saved setting. The flag is not listed inclaude --help.
After the session starts, Claude Code shows an Advisor Tool (experimental) is on and may use more tokens · /advisor notification. To disable the advisor tool entirely, set CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1.
Which pairings work
An advisor must rank at or above the session's main model. The accepted pairings for the models most people run:
| Main model | Accepted advisors |
|---|---|
| Haiku 4.5 | Fable, Opus, Sonnet, Haiku 5.5 |
| Sonnet 4.6 | Fable, Opus, Sonnet, Haiku 5.5 |
| Opus 4.6 | Fable, Opus, Sonnet 5 or later, Haiku 5.5 |
| Sonnet 5 or Haiku 5.5 | Fable, Opus 4.7 or later, Sonnet 5 or later, Haiku 5.5 |
| Opus 4.7 or Opus 4.8 | Fable, Opus 4.7 or later, Sonnet 5.5 |
| Sonnet 5.5 | Fable, Opus 5 or later, Sonnet 5.5 |
| Opus 5 or Opus 5.5 | Fable, Opus 5 or later |
| Fable 5 | Fable 5.1 or Fable 5 |
| Fable 5.1 | Fable 5.1 |
Set the advisor as fable, opus, or sonnet. Those aliases resolve to Claude Code's built-in default version for each model family, which advances with new releases. You can also pass a full model id such as claude-opus-5-5. Two rules to know: Haiku 4.5 can call the advisor but cannot act as one, and subagents inherit the configured advisor with the same pairing check against their own model. A few pairings need newer versions: Fable 5.1 needs v2.1.257 or later, Sonnet 5.5 as the advisor for an Opus 4.7 or 4.8 main model needs v2.1.287 or later, and Haiku 5.5 as main or advisor needs v2.1.293 or later.
If the advisor ranks below the main model, Claude Code does not attach it to the main model's requests — the session runs without the advisor, and a notification says so. If the API refuses a pairing that Claude Code did attach, Claude Code resends the request without the advisor and the conversation continues with no error and no advisor calls.
The three-model split
The pairing that fits most long tasks is Sonnet as the main model with Opus as the advisor: Sonnet handles routine work and escalates planning, ambiguous failures, and completion checks to Opus. The documentation lists exactly that pairing in its common pairings table.
One pattern circulating in posts about the advisor adds a third model: Sonnet as the main model, read-only subagents on Haiku 5.5 for search, grep, and docs, and Opus as the advisor. That split is a community pattern matched against the documentation, not Anthropic's recommendation. What the documentation does support is each part of it: subagents can be set to run on Haiku with a model field, the built-in Explore subagent is read-only with Write and Edit denied, and subagents inherit the configured advisor. If you use the split, set the subagent model explicitly — the default Explore subagent runs on the main conversation's model unless you define one with model: haiku.
What you see during a session
When Claude calls the advisor, the transcript shows an Advising line with the advisor model name while the call is in progress. When the result returns, the line reports whether the advisor gave guidance:
- Reviewed: the advisor reviewed the conversation. When it returned readable guidance, press
Ctrl+Oto read it. - Declined: the line reads
Advisor declined to advise on this request. If the advisor gave a reason, pressCtrl+Oto read it. - Unavailable: the advisor call failed, and the line reads
Advisor unavailable (<error_code>).
Claude generally follows the advisor's guidance, but adapts when its own evidence contradicts a specific claim: if a recommended step fails when tried, or the file contents contradict the advice, Claude surfaces the conflict rather than following the guidance unconditionally.
What it costs
When Claude calls the advisor, the advisor model reads the conversation, so each call consumes tokens at the advisor model's rates in addition to your main model's usage. On API billing, you pay the advisor model's input and output rates for advisor tokens. On subscription plans, advisor usage counts toward your plan's usage limits — except that a Fable advisor bills to usage credits on plans where Fable usage does. Advisor usage counts toward the session totals shown by /usage.
Two cost details matter. First, there is no setting to cap or force advisor calls: Claude decides when to consult, and you can ask for a consultation in your prompt the same way you would request any tool, for example consult the advisor before you continue. Second, each advisor call re-reads the full transcript uncached. Toggling the advisor does not invalidate your main model's prompt cache, but the advisor's own read of the conversation is not cached — every call processes the full transcript anew. The documentation says pairing a faster main model with a stronger advisor typically costs less than running the stronger model throughout. That is the documentation's claim, not a measured saving: no cost measurement exists for the pairing.
Where it doesn't apply
- Anthropic API only. The advisor is a server-executed tool. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, or Microsoft Foundry. Through an LLM gateway, availability depends on whether the gateway forwards the request intact.
- Feature-flag fetching. Claude Code turns the advisor on through a feature flag it fetches from Anthropic. In a session where a variable that turns flag fetching off is set, such as
DISABLE_TELEMETRY, the advisor stays off. - Allowlists. Claude Code does not invoke a saved advisor that your organization's
availableModelsallowlist excludes. Pick an allowed model with/advisor. A Fable advisor also needs your one-time consent to bill Fable usage to usage credits on some plans. - Silent continuation. If the API refuses the advisor, the conversation continues without one and you see no error. If you then pick a different advisor, it takes effect after
/clearor/compact, and in new sessions.
Advisor, opusplan, or subagents
The advisor is one of several ways to combine model strengths. The documentation compares them:
| Approach | When the stronger model runs | How it starts |
|---|---|---|
| Advisor tool | At decision points mid-task | Claude calls it when it needs guidance |
opusplan | During plan mode when allowed by availableModels, then switches to Sonnet for execution | You enter plan mode |
Subagents with model set | For the entire delegated subtask | Claude delegates, or you invoke the subagent |
/model | From the next request onward | You switch models |
Use the advisor when most turns are routine but plan quality determines the outcome — large refactors, debugging sessions where an error keeps recurring, and tasks you want independently checked before Claude declares them done. It adds less value on short tasks where there is little to plan, or on work where every turn needs the strongest model. For the difference between forked and parallel subagents, see run parallel subagents in Claude Code. For staying inside a plan's allowance while the advisor adds usage, see baseline usage before a shared allowance.
Limits
- This guide is written from the documentation. It reports no live session: the
Advisinglines are the ones the docs describe, and no/usagetotals were measured here. - The advisor's timing is model-driven, not rule-based. You cannot force a consultation at a fixed point, and you cannot cap how often it is called.
- Whether the advisor behaves as described on a given setup depends on the account, the gateway, and the allowlist. A refused pairing continues silently with no advisor.
Related playbooks
- Goose fixed the prompt Opus 5.5 refuses
- Run LongCat-2.5 in Claude Code without the 200K cap
- Move off Claude Sonnet 4.5 before it retires
- Run three independent lines of research at the same time in Claude Code, then combine the short summaries
Sources
- Escalate hard decisions with the advisor tool — Claude Code docs: enable methods, pairing table, transcript lines, cost, requirements
- Create custom subagents — Claude Code docs: read-only Explore subagent, setting a subagent's model, advisor inheritance
- Run parallel subagents in Claude Code — Agent Upstart: fork vs parallel subagents
- Baseline usage before a shared allowance — Agent Upstart: measuring usage before the advisor adds to it
Back to: Coding playbooks hub · Also: Run parallel subagents in Claude Code · Claude Code 2.1.318: sign-in expiry and fork effort · Baseline usage before a shared allowance