- The advisor lets Claude Code run a lighter main model, such as Sonnet, and consult a stronger model, such as Opus or Fable, at key moments: before committing to an approach, when an error keeps recurring, and before declaring a task done.
- Turn it on with /advisor opus. It is saved as your default; /advisor off turns it off. It needs the Anthropic API (not Bedrock, Vertex or Foundry) and is experimental.
- Each advisor call reads the whole conversation at the advisor model's rates, and that read is not cached. On a subscription it counts toward your usage limits.
- In our worked example (a 60-step session growing to 140K tokens, 4 advisor calls) Sonnet with an Opus advisor cost 13% less than Opus throughout and 73% more than Sonnet alone. With a 300K-token session and 8 calls it cost 63% more than Opus throughout.
- Rule of thumb: use the advisor on long tasks where a few decisions matter, keep sessions short with /clear, and use plain Sonnet for routine work.
Most of what a coding agent does is routine: reading files, running tests, making small edits. A few moments decide whether the task goes well: choosing the approach, getting unstuck, and checking the work before calling it done. Claude Code's advisor is built around that split. A lighter model does the routine steps, and a stronger model is consulted only at those moments. It sounds like an easy saving. It often is, but not always, and the difference comes down to how the advisor is billed.
What the advisor does
The advisor is a server-side tool. When it is on, your main model (the executor) can call a second, usually stronger model. The advisor receives the full conversation, including every tool call and result, and returns guidance that the main model applies before continuing. Anthropic's documentation says Claude tends to consult it before committing to an approach, when an error keeps recurring, and before declaring a task complete. The timing is decided by the model, not by fixed rules, and there is no setting to cap or force calls; you can ask for a consultation in your prompt, for example "consult the advisor before you continue".
Claude generally follows the advice, but if a recommended step fails or the files contradict it, it surfaces the conflict rather than following the advice blindly.
How to turn it on
- In a session: run
/advisor opus(or/advisorfor a picker). The choice is saved toadvisorModelin your user settings and applies to later sessions. - As a default: add
"advisorModel": "opus"to your Claude Code settings file. - For one session: start with
claude --advisor opus. - To stop:
/advisor off. To disable it entirely, setCLAUDE_CODE_DISABLE_ADVISOR_TOOL=1.
Pair it with a lighter main model, for example /model sonnet then /advisor opus. The advisor is experimental and works only through the Anthropic API: it is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform or Microsoft Foundry. It also stays off when feature-flag fetching is disabled, for example with DISABLE_TELEMETRY set.
Which models can advise which
The advisor must rank at or above your main model. The pairings Anthropic lists for current models:
| Main model | Accepted advisors |
|---|---|
| Sonnet 5.5 | Fable, Opus 5 or later, Sonnet 5.5 |
| Sonnet 5 or Haiku 5.5 | Fable, Opus 4.7 or later, Sonnet 5 or later, Haiku 5.5 |
| Opus 5 or Opus 5.5 | Fable, Opus 5 or later |
| Fable 5.1 | Fable 5.1 |
Fable as an advisor needs Fable access, and on some plans its usage bills to usage credits after a one-time consent. Haiku 4.5 can call an advisor but cannot be one. If you pick an advisor that ranks below your main model, Claude Code does not attach it.
How it is billed
- API billing: advisor tokens are charged at the advisor model's input and output rates, on top of your main model's usage.
- Subscription plans: advisor usage counts toward your plan's usage limits (a Fable advisor bills to usage credits on plans where Fable does).
- No cache for the advisor's read: each call reads the full transcript afresh. Your main model's prompt cache is not affected by turning the advisor on or off.
That last point is what decides whether you save. The main model reads its growing conversation from cache at a small fraction of the input rate. The advisor reads the same conversation at the full input rate of a more expensive model, every time it is called. The longer the session, the more each call costs.
Worked example: does it save money?
A 60-step Claude Code session. The conversation grows from 20,000 to 140,000 tokens; each step reads it from cache, adds 3,000 new tokens and writes 1,500 tokens of output. The advisor is called 4 times, spread through the session, each time reading the full conversation and writing 700 tokens of guidance. Prices are Anthropic's list prices per million tokens: Claude Opus 5.5 $4 input, $0.20 cache read, $20 output; Claude Sonnet 5.5 $2, $0.10 and $10.
| Setup | Cost of the session |
|---|---|
| Opus 5.5 for every step | $3.66 |
| Sonnet 5.5 for every step | $1.83 |
| Sonnet 5.5 main + Opus 5.5 advisor (4 calls) | $3.17 (Sonnet $1.83 + advisor $1.34) |
The pairing saves 13% against running Opus throughout, and costs 73% more than Sonnet alone. What you buy with the extra is Opus-level judgement at the decision points. Now change the two things that matter most, how long the session gets and how often the advisor is called:
| Saving vs Opus throughout | 2 advisor calls | 4 calls | 8 calls |
|---|---|---|---|
| Session grows to 60K tokens | 39% | 28% | 6% |
| Session grows to 140K tokens | 32% | 13% | 23% more |
| Session grows to 300K tokens | 21% | 7% more | 63% more |
Short sessions with a few consultations save real money. Long sessions with frequent consultations can cost more than simply running Opus, because every call re-reads a large, uncached transcript at Opus input rates. On a subscription the same arithmetic applies to your usage limit.
When to use it, and when not
- Use it for long, multi-step work where most steps are routine but the plan matters: large refactors, debugging an error that keeps coming back, tasks you want checked before they are declared done.
- Keep sessions short. Write a handover note and start fresh with
/clearwhen a task changes. It cuts the main model's cost and makes each advisor call cheaper. - Steer the number of calls. If the advisor is called more than the task needs, say so in your instructions, for example "only consult the advisor before major decisions".
- Skip it for short tasks with little to plan: switch the main model with
/modelinstead. And if every step needs the strongest model, run that model; the advisor adds cost without adding much. - Alternatives:
opusplanuses Opus in plan mode and Sonnet for execution; subagents with their own model run a whole subtask on a chosen model.
How to tell if you need it
The signal is simple: how many of your steps ran on your most expensive model without needing it, such as approvals, status checks and short answers. If that share is high, a lighter main model with an advisor, or plain Sonnet, will stretch your limit or budget. AiGanak Scan measures this from your Claude Code logs, together with how long your sessions get, and gives you the setup to paste.
Sources
- Claude Code docs: Escalate hard decisions with the advisor tool (checked 16 November 2026)
- Claude API docs: Advisor tool
- Anthropic: Claude API pricing (checked 9 November 2026)
Provider prices and limits change often. Figures were checked on 16 November 2026; confirm current terms with each provider before you rely on them.