[KongchangAI]
· 3 min read· 1,629 words

Claude Code Advisor Mode Explained: How Fable 5.2 and Sonnet 5.5 Collaborate on Code

Claude Code Advisor Mode Explained: How Fable 5.2 and Sonnet 5.5 Collaborate on Code

Claude Code's Advisor mode lets the main model call a stronger advisor model at key junctures—pay-as-you-go, but mind the version and billing thresholds.

Anthropic added an experimental Advisor tool to the Claude Code terminal, using model tiering: day-to-day coding is handled by the main model (e.g., Sonnet 5.5), while at key junctures like architecture planning, infinite-loop debugging, and final checks, a more capable advisor model (Fable or Opus 5 tier) is invoked. The advisor's capability must not be lower than the main model's, and weak advisors are auto-disabled. The feature is limited to Anthropic API and AWS Claude Platform, with minimum version requirements. Enable it via interactive `/advisor` selection, direct specification, or the one-off `--advisor` parameter. Fable has separate billing rules and requires authorization on first enable; officially, only that on-demand invocation reduces costs is confirmed—the X post's "3.4x cost reduction" and four-model chain claims have no official basis.

Claude Code Advisor Mode Explained: How Fable 5.2 and Sonnet 5.5 Collaborate on Code

Anthropic has added an experimental tool called Advisor to the Claude Code terminal. The idea is straightforward: rather than running every coding step on the most expensive model, bring in a stronger "advisor" at key decision points. In a video, the AI persona of Turkish creator Hikmet Tanrıverdi walked through this tool end to end—from installation to billing—based on Anthropic's official documentation, and also fact-checked some claims circulating on social media.

Note that this video is a single-source technical breakdown. Most of its factual descriptions can be traced to the official documentation, but when it comes to the "cost-reduction multiplier" circulating in the community, the author explicitly cautions that it is not an official figure.

Cloud Update: upgrading Claude Code to the latest version

What Advisor Is For: Bringing a Strong Model In at Key Junctures

Advisor's core logic is model tiering. Day-to-day coding goes to the main model (for example, Sonnet 5.5, repeatedly mentioned in the video). When it hits architecture planning, a repeated error loop, or a final check before wrapping up a task, the main model proactively hands the problem to a more capable advisor model.

According to the official documentation, the advisor model's capability tier must not be lower than the main model's. If the main model is Sonnet 5.5, the advisor can only be chosen from the Fable or Opus 5 tier; smaller models like Haiku 4.5 cannot serve as advisor. If a user forces a weaker advisor than the main model, Claude Code doesn't terminate the session—it silently disables the advisor. This design detail shows that Anthropic would rather downgrade than let a weak model offer misleading advice.

The advisor model itself doesn't write code or take over the keyboard. It only outputs strategic judgments or review feedback when invoked; actual execution is still handled by the main model.

Advisor model capability cannot be lower than the main model

Access Conditions and Version Requirements

This feature is currently available through the Anthropic API and Claude Platform on AWS. It is not yet supported on infrastructure such as Amazon Bedrock, Google Cloud Agent Platform, or Microsoft Foundry. The video also notes that Turkish users can interact with the model in Turkish in the terminal using an Anthropic API account or a Claude subscription.

Version requirements are another hurdle. To use Fable 5.2 as an advisor, Claude Code requires at least version 2.1.321; users running on AWS Claude Platform need at least 2.1.300. If the version is too old, the system won't recognize the advisor model, the tool won't take effect at all, and the session will start in normal mode. Upgrading is simple: run /update in the terminal.

Claude Platform on AWS vs. Bedrock

The "Claude Platform on AWS" mentioned in the article and Amazon Bedrock are two different access paths. Bedrock is AWS's unified hosting service for multiple model vendors, with Claude being just one category of model; Claude Platform on AWS is a separate platform built through an Anthropic-AWS partnership specifically for Claude, with interfaces and feature cadence closer to Anthropic's own API. This explains why Advisor is available on Claude Platform on AWS but not yet on third-party multi-cloud hosting services like Bedrock, Google Cloud Agent Platform, or Microsoft Foundry—the latter typically require each platform to complete its own adaptation and feature alignment, so new experimental features often lag.

/update and Version Semantics

Claude Code's /update is an in-terminal self-update command that pulls the latest official release and replaces the local executable, with no manual reinstall needed. The versions 2.1.321 and 2.1.300 mentioned are semantic version numbers: the first two segments represent major and minor versions, and the last is the patch number. Experimental tools like Advisor are often rolled out gradually via smaller patch numbers, so the minimum versions differ across deployment environments (direct API vs. AWS platform).

Three Ways to Enable It and Invocation Details

There are three paths to enabling an advisor in a terminal session:

  • Interactive selection: type /advisor, and the available advisor models are listed;
  • Direct specification: type /advisor opus or /advisor fable; the choice is written to user settings and persists long-term;
  • One-off trial: add the --advisor opus parameter at startup; it applies only to the current session and reverts to default after closing.

For manual configuration, you can also write the advisor model field in settings.json in the user directory.

When the advisor is invoked, an "advising" status line with the model name appears in the terminal; after the call ends, "reviewed" is displayed, and pressing Ctrl+O lets you read the advice the advisor gave. If the advisor declines to give direction, "declined" is shown; if the call errors out, "unavailable" is shown.

The terminal shows an advising status when the advisor is invoked

It's worth noting that the main model does not unconditionally adopt the advisor's opinions. If existing evidence in the project conflicts with the advisor's suggestions, the main model presents the disagreement to the user rather than blindly executing.

Only One Advisor per Call

A widely circulated post on X described Fable 5.2 as the "thinker," Sonnet 5.5 as the "coder," Opus as the "reviewer," and Haiku as the "sub-agent," looking like a four-model pipeline. After checking the official documentation, the video's author points out: Claude Code allows only one main model paired with one advisor in a session. The four-model chain described in that post is not an official single-command mode but a workflow the user built themselves. Sub-agents can independently use models in their respective tasks, but the advisor tool listens to only one model per session.

Billing Rules: Fable's Special Treatment

Advisor itself is not a free plugin; tokens generated by calls are deducted from the account at the rate of the invoked model. Because the Fable series has the highest reasoning capability, it has a separate billing rule: even if the user has a subscription plan, Fable usage may be deducted directly from usage credits. So before enabling a Fable advisor for the first time, the terminal requires a one-time confirmation of credit authorization; without confirmation, the system directs you to the /model fable command and the advisor is not activated.

Regarding cost, the X post claims the feature reduces costs by 3.4x. The video's author explicitly states this number is not in the official documentation. Officially, only a qualitative conclusion is confirmed: invoking a strong model only at decision moments, rather than using an expensive model throughout, does indeed reduce costs. But each time the advisor is invoked, it re-reads the entire session context, and its own reads do not enter the cache. Although the main model's cache is not broken, the returned advice is also cached locally in subsequent steps.

Prompt Caching and the Cost Source of "Re-reading Context"

Anthropic API's prompt caching allows prefix content that repeatedly appears in a session to be cached, so subsequent requests that hit the cache are billed at a lower price and with lower latency. This is exactly where Advisor's cost pain point lies: when the advisor is invoked, it re-reads the current full session as input, and these reads are designed not to enter the cache, so every summons is billed for input tokens at full price. The cache on the main model side is unaffected, and the advisor's returned advice is also cached locally in subsequent steps to avoid repeated transmission. Understanding this makes it clear why "invoking only at key junctures" saves money while "summoning frequently" significantly inflates the bill—cost is almost entirely determined by the advisor's input token volume and number of invocations.

How to Turn It Off

When you no longer need the advisor, run /advisor off in the session to disable it. To remove it entirely at the system level, set the environment variable CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1; the /advisor command then becomes unavailable in the terminal.

The advisor can be disabled via command or environment variable

Practical Judgment

The value of Advisor mode lies in separating "expensive" from "fast": the main model maintains high-frequency, low-cost output, while the strong model steps in only at the nodes that truly require deep reasoning—architecture decisions, debugging infinite loops, and final checks. It's more like a senior colleague you can call back at any time, rather than something that takes over the entire pipeline. For projects that often get stuck on the same error, or that need architectural review before starting, this switch is worth a try; the cost is that every summons re-reads the context, so overuse actually drives up costs.

The full command list and official source links from the video are in the video description; interested readers can verify them themselves.

One-line Summary

Claude Code's Advisor mode lets the main model call a stronger advisor model at key junctures—pay-as-you-go, but mind the version and billing thresholds.

Paragraph Summary

Anthropic added an experimental tool called Advisor to the Claude Code terminal, using a model-tiering approach: day-to-day coding is done by the main model (e.g., Sonnet 5.5), while at key junctures such as architecture planning, infinite-loop debugging, and final checks, a more capable advisor model (Fable or Opus 5 tier) is invoked. The advisor model's capability must not be lower than the main model's, and a weak advisor is automatically disabled. The feature is limited to Anthropic API and AWS Claude Platform, with minimum version requirements. It can be enabled via interactive /advisor selection, direct specification, or the one-off --advisor parameter. On billing, Fable has separate rules and requires authorization confirmation on first enable; officially, only that on-demand invocation can reduce costs is confirmed—the X post's claim of a "3.4x cost reduction" and the four-model chain have no official basis.

#Claude Code#Advisor mode#Anthropic#Fable 5.2#Sonnet 5.5#model tiering#prompt caching
Share:

Related articles