# Claude Code Advisor: run Opus 5.5, let Fable 5.2 advise

URL: https://systemdesignsimple.com/claude-code-advisor-opus-fable/
Published: 2026-11-10
Category: AI Tools
Publisher: System Design Simple (https://systemdesignsimple.com)

## Summary

The Claude Code advisor lets your main model consult a stronger model at key moments. Set "advisorModel": "fable" (or run /advisor fable) and an Opus 5.5 session asks Fable 5.2 before choosing an approach, when an error keeps coming back, and before saying it is done. It needs Claude Code 2.1.321 or later and the Anthropic API.

## Key facts

- **Setting:** "advisorModel": "fable" in settings, /advisor fable in a session, or claude --advisor fable for one session
- **Pairing rule:** The advisor must rank at or above the main model; Opus 5.5 accepts Fable or Opus 5 and later
- **Version:** Fable 5.2 as advisor needs Claude Code 2.1.321 or later
- **What the advisor sees:** The full conversation, every tool call and result
- **Who decides when:** Claude, at decision points; you can ask for a consultation in the prompt
- **Where it runs:** Anthropic API only (not Bedrock, Google Cloud's Agent Platform or Microsoft Foundry); experimental

The Claude Code advisor lets one model do the work while a stronger model is consulted only at the moments that decide the outcome. With Opus 5.5 as the main model and Fable 5.2 as the advisor, you get Fable's judgement on the plan, on recurring errors and on the final check, without running Fable on every turn.

## What the Claude Code advisor does {#what}

The advisor is a [server tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool) that runs on Anthropic's side. At a key moment the main model calls it; the advisor model receives the full conversation, every tool call and result included, and returns guidance. The main model applies that guidance and keeps working. The advisor never edits files itself, and when the main model's own evidence contradicts the advice (a recommended step fails, a file says otherwise), it surfaces the conflict instead of following blindly ([Claude Code docs](https://code.claude.com/docs/en/advisor)).

## How to set Fable 5.2 as the advisor {#setup}

There are three ways, from the docs:

```bash
# 1. Inside a session: set it and save it as your default
/advisor fable

# 2. In your settings file (~/.claude/settings.json): a persistent default
{
  "advisorModel": "fable"
}

# 3. For one session only, without changing the saved setting
claude --advisor fable
```

`fable`, `opus` and `sonnet` are aliases for Claude Code's current default in each family; a full model id such as `claude-opus-5-5` also works. To check what is active, run `/advisor` with no argument. On our Mac (Claude Code 2.1.322) it printed this before and after adding the setting:

```text
$ claude -p "/advisor"
Advisor: off
Usage: /advisor <fable|opus|sonnet|off>

# after adding "advisorModel": "fable" to ~/.claude/settings.json
$ claude -p "/advisor"
Advisor: Fable 5.2
Usage: /advisor <fable|opus|sonnet|off>
```

On some plans, Fable as the advisor first needs a one-time consent: run `/model fable` and continue on Fable once, then pick Fable as the advisor. Until then Claude Code points you to `/model fable` and does not save Fable as the advisor.

## Which advisor works with which model {#pairing}

The rule: the advisor must rank at or above the session's main model. Claude Code checks the pairing before each request, and the API checks it again.

[Image: Claude Code docs table of main models and the advisor models each accepts | Accepted pairings, from the Claude Code docs. Captured November 10, 2026. [Source](https://code.claude.com/docs/en/advisor)]

| Main model | Accepted advisor | Note |
|---|---|---|
| Opus 5 or Opus 5.5 | Fable, Opus 5 or later | Opus does the work, Fable advises |
| Sonnet 5.5 | Fable, Opus 5 or later, Sonnet 5.5 | Fable advice without running Fable throughout |
| Fable 5.2 | Fable 5.2 only | Claude Code does not attach an Opus or Sonnet advisor to Fable |
| Haiku 4.5 | Fable, Opus, Sonnet, Haiku 5.5 | Haiku 4.5 can call an advisor but cannot be one |

Subagents inherit the advisor and run the same check against their own model. If you pick an advisor below your main model, Claude Code saves it but does not attach it.

## When Claude asks the advisor {#when}

Claude decides, not a fixed rule. In practice it tends to consult:

- before committing to an approach,
- when the same error keeps coming back,
- before declaring the task done.

You can ask for one directly ("consult the advisor before you continue"). There is no setting that caps or forces calls; say in your instructions if you want more or fewer. During a call the transcript shows an `Advising` line; press `Ctrl+O` to read the guidance. Turning the advisor on or off mid-session does not break the main model's prompt cache.

## Advisor vs opusplan vs subagents {#compare}

[Image: Claude Code docs table comparing the advisor tool, opusplan, subagents and switching models | When the stronger model runs in each approach, from the Claude Code docs. Captured November 10, 2026. [Source](https://code.claude.com/docs/en/advisor)]

Use the advisor for long tasks where most turns are routine but the plan decides the outcome: large refactors, a bug that keeps returning, work you want checked before it is called done. If you already run [Codex CLI next to Claude Code](/claude-code-vs-codex-cli/) for a second opinion, the advisor gives you one inside the Claude session. For short tasks, or work where every turn needs the strongest model, switch the main model with `/model` instead. To hand a whole subtask to another model, use a subagent with its own model.

## Requirements and limits {#limits}

- Experimental, and Anthropic API only: not on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform or Microsoft Foundry.
- Fable 5.2 as advisor needs Claude Code 2.1.321 or later and Fable access.
- The advisor reads the whole conversation on every call, and an agent's [history grows every turn](/why-an-ai-agent-re-sends-its-history/). That read is not cached, so each call uses Fable's allowance on top of the main model ([how weekly limits work](/claude-ultra-no-5-hour-limit/)). On some plans a Fable advisor bills to usage credits.
- It stays off when feature-flag fetching is off (for example with `DISABLE_TELEMETRY` set).
- `/advisor off` turns it off; `CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1` disables the tool entirely.

## Why this design works {#design}

It is the coordinator pattern turned around: instead of a strong model directing many workers, one capable worker asks a stronger reviewer only at the decision points. Most turns of a coding task are routine (read a file, run a test, make a small edit), and those do not need the strongest model. The few that set direction do. Paying for judgement only where it changes the result is the same trade-off as a [second AI that reviews the first](/one-ai-writes-one-ai-reviews/), applied inside one session. For what Fable 5.2 itself can do, see the [Claude Fable 5.2 review](/claude-fable-5-2-mythos-5-2/); for the rest of the setup that makes long sessions reliable, see [how to use Claude like a professional](/claude-like-a-pro/).

## Frequently asked questions

**How do I turn on the Claude Code advisor?**
Run /advisor fable (or /advisor opus) in a session, add "advisorModel": "fable" to your settings file, or start a single session with claude --advisor fable. Run /advisor with no argument to see the current advisor.

**Can Opus 5.5 use Fable 5.2 as an advisor?**
Yes. With Opus 5 or Opus 5.5 as the main model, Claude Code accepts Fable or Opus 5 and later as the advisor. Fable 5.2 needs Claude Code 2.1.321 or later and Fable access.

**Does the advisor edit my files?**
No. The advisor reads the full conversation and returns guidance; the main model applies it, and surfaces a conflict when its own evidence contradicts the advice.

**How is it different from opusplan or subagents?**
The advisor is consulted at decision points mid-task. opusplan uses the stronger model during plan mode only, and a subagent with its own model runs a whole delegated subtask.

## Sources

- [Claude Code docs: Escalate hard decisions with the advisor tool](https://code.claude.com/docs/en/advisor)
- [Claude API docs: Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool)
- [Claude blog: The advisor strategy](https://claude.com/blog/the-advisor-strategy)
- [Claude Code docs: Model configuration](https://code.claude.com/docs/en/model-config)