Claude Code Lets Fable 5.1 Advise Opus 5.5, but the Model Decides When to Ask
Crafting seamless user experiences with a passion for headless CMS, Vercel deployments, and Cloudflare optimization. I'm a Full Stack Developer with expertise in building modern web applications that are blazing fast, secure, and scalable. Let's connect and discuss how I can help you elevate your next project!
Claude Code's /advisor command puts Fable 5.1 on call while Opus 5.5 writes the code: the advisor reads the whole session, every tool call included, but Opus 5.5 decides when to ask. Anthropic's documentation, read on October 2, 2026, lists Opus 5.5 with Fable 5.1 as an accepted pairing. It also states three limits to know before you enable it. Fable needs a one-time billing consent on some plans, no setting forces or caps consultations, and each consultation re-reads the full conversation at the advisor's rates.
One setup step is easy to get wrong. Writing effortLevel at the top level of your user settings.json has no effect on Opus 5.5.
How the advisor works
The advisor is a server tool that runs on Anthropic's infrastructure, and it is available to subscription and API-billed accounts. You choose which model advises. Claude decides when to call it. The advisor receives the full conversation, including every tool call and result, and returns guidance that the main model applies before it continues. Anthropic's April 9, 2026 announcement adds that the advisor never calls tools or produces user-facing output. It only guides.
The main model does not follow the advice blindly. The documentation says that when a recommended step fails, or the file contents contradict the advice, Claude surfaces the conflict.
There are three ways to turn it on:
- Run /advisor in a session. It opens a picker, or you can pass a model directly, such as /advisor opus. The choice is saved to advisorModel in your user settings.
- Set advisorModel in a settings file for a persistent default.
- Launch with claude --advisor opus to set the advisor for one session without changing saved settings. The documentation says this flag is not listed in claude --help.
Run /advisor off to stop using it. Setting CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1 disables the tool entirely: /advisor becomes unavailable and any configured advisorModel is ignored.
When Claude calls the advisor, the transcript shows an Advising line with the advisor's model name. It then reports Reviewed, Declined or Unavailable. Press Ctrl+O to read the guidance.
When it speaks up is the model's call
The documentation says Claude tends to consult the advisor before committing to an approach, when an error keeps recurring, and before declaring a task done. The timing is model-driven rather than rule-based. No setting caps or forces advisor calls. If you want more or fewer consultations, say so in your prompt or instructions. The documentation's own example is "consult the advisor before you continue."
Treat the three moments as a default tendency, and write the request down if you need it to hold.
Which pairings Claude Code accepts
Both Claude Code and the API require an advisor at least as capable as the main model, and the two rank some models differently. With Opus 5.5 as the main model, Fable or any Opus 5 or later model is accepted.
| Main model | Accepted advisors | Notes |
|---|---|---|
| Opus 5.5 or Opus 5 | Fable, and Opus 5 or later | An Opus 4.6 or Sonnet advisor is rejected; the API refuses Opus 4.7 and 4.8 |
| Sonnet 5.5 | Fable, Opus 5 or later, Sonnet 5.5 | A Sonnet 4.6 advisor is rejected; the API refuses Sonnet 5, Opus 4.6, 4.7 and 4.8 |
| Fable 5.1 | Fable 5.1 only | An Opus or Sonnet advisor is rejected; the API refuses a Fable 5 advisor |
| Haiku 4.5 | Fable, Opus, Sonnet | Haiku can call the advisor but cannot act as one |
The API refusals are the ones that bite. Claude Code attaches the advisor, the API refuses it, and Claude Code resends the request without it. The rest of the conversation then runs with no advisor, so you see no error and get no advisor calls. Pick an accepted advisor with /advisor. The change takes effect after /clear or /compact and in new sessions.
The aliases fable, opus and sonnet resolve to Claude Code's built-in default version for each family, and that default advances with new releases. A full model ID such as claude-opus-5-5 pins the version. Subagents inherit the configured advisor and apply the same pairing check against their own model.
Four gates before the advisor works
The documentation labels the advisor experimental: behavior, pricing and availability may change. Miss any of these four requirements and it will not behave as you expect.
| Gate | What the documentation requires | Documented consequence |
|---|---|---|
| Platform | A server tool that needs the Anthropic API. Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform and Microsoft Foundry are unsupported. Through a gateway set with ANTHROPIC_BASE_URL, the gateway must forward the request intact | Unavailable on unsupported platforms |
| Version | Fable 5.1 needs Claude Code v2.1.257 or later and Fable access. Using /advisor in -p mode, the Agent SDK, the desktop app or Remote Control needs v2.1.260 or later | Not stated |
| Feature flag | Claude Code turns the advisor on through a flag it fetches from Anthropic. DISABLE_TELEMETRY, DO_NOT_TRACK, DISABLE_GROWTHBOOK and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC stop that fetch | The advisor stays off in those sessions |
| Fable billing consent | On some plans, Fable usage bills to usage credits and needs one-time consent. Run /model fable and choose to continue | Before consent, /advisor fable saves nothing, and claude --advisor fable exits at launch |
What it costs
Each time Claude calls the advisor, the advisor model reads the conversation, and those tokens bill at the advisor's rates on top of the main model's usage. The advisor's own read is not cached, so every call processes the full transcript again. Turning the advisor on or off mid-session does not invalidate the main model's prompt cache.
How it bills depends on how you pay. On API billing you pay the advisor model's input and output rates. On subscription plans, advisor usage counts toward your usage limits, except that a Fable advisor bills to usage credits on plans where Fable usage does. The totals in /usage include advisor usage.
Anthropic has published numbers, for different pairings. Its April 9, 2026 announcement reports that Sonnet 4.6 with an Opus 4.6 advisor scored 2.7 percentage points higher than Sonnet alone on SWE-bench Multilingual, while cutting cost per agentic task by 11.9%. Haiku 4.5 with an Opus advisor scored 41.2% on BrowseComp against 19.7% for Haiku alone. It trails Sonnet alone by 29% in score and costs 85% less per task. Those runs used the API advisor tool, and the executor was cheaper than the advisor each time.
We found no published results for Opus 5.5 with a Fable 5.1 advisor in the documentation or the announcement, so there is no public number on whether that pairing saves money or improves quality. The documentation describes an Opus main model with an Opus advisor as a second Opus reviewing the first, useful when an independent check matters more than cost. It describes a Sonnet main model with a Fable advisor as Fable guidance at decision points without running Fable throughout. Opus 5.5 with Fable 5.1 does not appear in its table of common pairings.
The effort setting that does not apply to Opus 5.5
To pin the main session at high effort, the obvious move is a top-level effortLevel in ~/.claude/settings.json. The documentation says that key does not count for Opus 5.5 when it sits in your user settings file. It is the older form that /effort wrote before Claude Code saved levels per model, and it still applies to Opus 5, Fable 5.1 and earlier models. Opus 5.5 and later models start at their own default until you choose a level with /effort or the /model picker. Opus 5.5's default is medium.
There are two correct routes. Run /effort high and press Enter to save it as your default, which Claude Code stores per model under modelSettings (v2.1.251 or later). Or write modelSettings yourself:
{
"modelSettings": {
"claude-opus-5-5": {
"effortLevel": "high"
}
}
}
A top-level effortLevel in project, local or managed settings, or one passed with --settings, applies to every model. The CLAUDE_CODE_EFFORT_LEVEL environment variable has the highest precedence. It beats --effort, /effort and both settings forms, and it beats the effort field in a subagent's frontmatter. High effort spends more tokens, so keeping Opus 5.5's default of medium is a reasonable choice when you have no specific reason to raise it.
A setup prompt you can paste into Claude Code
The target is one main session, three subagents and an advisor on call:
Main session: Opus 5.5, effort high
├─ explorer: reads the code (model: opus, effort: medium)
├─ worker: edits files and runs tests (model: opus, effort: medium)
├─ researcher: pulls the docs (model: opus, effort: medium)
└─ advisor: Fable 5.1, on call
Paste the tree and the prompt below into Claude Code. The prompt asks it to inspect first, show every change as a diff, and wait for your go-ahead. Step 2 uses modelSettings for the reason in the previous section.
Rebuild my Claude Code setup around this tree:
Main session: Opus 5.5, effort high
explorer reads the code, worker edits files and runs tests, researcher pulls the docs, all three on medium
Fable 5.1 on call as the advisor
1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher.
- Draft new ones only for missing roles
- Give each model: opus, effort: medium
- Skip any that pin a different model and list them for me
2. Under modelSettings in ~/.claude/settings.json, set effortLevel to high for claude-opus-5-5, and set advisorModel to fable. A top-level effortLevel does not apply to Opus 5.5, so do not use it. If my account needs the one-time Fable billing consent, tell me to run /model fable first and do not handle it for me.
3. Find anything that keeps the advisor off: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, and any variable that stops feature-flag fetching. Also find CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them and change nothing.
4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done.
Show me every change as a diff first. No edits until I say go.
The three subagents inherit the advisor, so they can also ask Fable for help on hard problems, and total cost may run higher than with the main session alone.
How to tell whether the advisor is running
After the session starts, Claude Code shows a notification that reads Advisor Tool (experimental) is on and may use more tokens. If you do not see it, confirm the main model supports the advisor and recheck the four gates.
If a long task never shows an Advising line, check the pairing, the environment and the consent. The API may have silently refused the pairing. The environment may set a variable that stops feature-flag fetching. The Fable billing consent may be incomplete. When Fable is saved as advisorModel but the consent is missing, Claude Code sends requests without the advisor and, in an interactive session, shows a notification that points to /model fable.
Frequently asked questions
What if /advisor fable does not take effect?
Check whether your account needs the Fable billing consent: until you accept it, /advisor fable saves nothing. Then confirm Claude Code is v2.1.257 or later, that the main model and advisor form an accepted pairing, and that nothing like DISABLE_TELEMETRY sets the environment to skip feature-flag fetching.
Does the advisor edit my code?
No. It returns guidance, and the main model decides whether to apply it. The documentation says that if a recommended step fails or the files contradict the advice, Claude surfaces the conflict.
Can I cap how often the advisor is called?
Not in Claude Code. The documentation says no setting caps or forces advisor calls, so you adjust the frequency by saying so in your prompts or instructions. The API advisor tool has a max_uses parameter that limits calls per request, but that applies only to direct API use.
Does the advisor work on Amazon Bedrock, Google Cloud or Microsoft Foundry?
No. It is a server tool that requires the Anthropic API. Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform and Microsoft Foundry are all unsupported.
What is Opus 5.5's default effort level?
Medium. To raise it to high, use /effort high or modelSettings, and avoid a top-level effortLevel in your user settings file.
Sources
- Claude Code Docs: Escalate hard decisions with the advisor tool
- Claude Code Docs: All settings
- Claude Code Docs: Model configuration
- Claude Code Docs: Create custom subagents
- Claude Code Docs: Environment variables
- Anthropic: The advisor strategy
Author Insight
The most useful idea in the advisor design is splitting review from execution: the model doing the work does not grade its own plan. That only pays off if the advisor gets called at the right moments, and the documentation says timing is the model's call. So I would treat adoption as an experiment you measure. Pick three to five tasks that normally take an hour or two. Run each once with the advisor and once without. Record the /usage totals, how many times the advisor was called, and what a person had to redo. If the advisor never gets called, check the pairing and the environment variables before asking whether Fable is worth it.
