Claude Code Advisor Mode: Two-Model Collaboration for Cost-Effective Coding

Claude Code launches experimental Advisor Mode, letting high-reasoning models intervene only at key decision points to balance cost and quality.
Anthropic introduced the experimental Advisor Mode tool into the Claude Code terminal, where the primary model handles execution and writing code, while a high-reasoning advisor model is invoked only at three points—architecture planning, repeated error troubleshooting, and final review—and outputs suggestions only without acting directly. Available via Anthropic API and Claude Platform on AWS but not yet on Bedrock, it has minimum version requirements and bills per token of the invoked model, with the Fable series potentially deducted from usage credits and requiring one-time authorization. Model pairing has a hard rule: the advisor's capability cannot be lower than the primary model's. The community-circulated four-model pipeline and 3.4x savings claims are not official, and the advisor re-reads the entire session history uncached on each call, so actual savings depend on the trigger frequency of key decisions.
Anthropic has introduced an experimental tool called Advisor Mode into the Claude Code terminal. The core idea is to keep the expensive, high-reasoning model from participating throughout the entire coding process, instead having it intervene only at critical decision points. The AI avatar of YouTube channel Hikmet Tanriverdi did a complete breakdown of this feature, and by combining official documentation with community discussion, we can get a clear picture of its actual usage and cost logic.

What Problem Does Advisor Mode Solve
In traditional workflows, developers usually either run the entire task with the most expensive model from start to finish, or to save money, use a lightweight model for all the work. The former is absurdly expensive, while the latter tends to fail on architecture decisions and complex bugs. Advisor Mode offers a third path: the primary model handles execution and writing code, while the advisor model is invoked only at three key moments—before formulating major architecture plans to get strategic confirmation, when the same error keeps recurring to help troubleshoot, and for an independent review before the task wraps up.
Under this design, the advisor does not directly write code or take over the keyboard. It only outputs suggestions during the session, and the primary model decides on its own whether to adopt them. If the advisor's suggestions conflict with evidence already present in the project, the primary model flags this inconsistency to the user rather than blindly following it.
Access Methods, Version Requirements, and Pricing Rules
The official documentation specifies that this feature is available through the Anthropic API and Claude Platform on AWS, but is not yet supported on infrastructure such as Amazon Bedrock, Google Cloud Agent Platform, and Microsoft Foundry. Before use, you must update the Claude Code version: run cloud update in the terminal. Using Fable 5.2 as an advisor requires at least version 2.1.3.2.1, while the AWS platform requires at least version 2.1.3.0.0. If the version is too old, the system cannot recognize the model and will start as a normal session, rendering the advisor tool useless.
It is not a free add-on; it is billed at the token pricing of the invoked model and deducted from your account balance. The Fable series, because of its strongest reasoning capability, is subject to special billing rules—even if you have an active subscription, Fable usage may be deducted directly from usage credits. Before enabling the Fable advisor for the first time, you need to complete a one-time quota authorization in the terminal; without authorization, the system will direct you to the /model Fable command, and the advisor cannot be activated.

usage credits are a separate billing pool that Anthropic sets up for model calls beyond subscription plans. Subscription plans typically have usage caps for regular models, while the models with the strongest reasoning capability and highest per-token cost (such as the Fable series mentioned in the article) are often not included in the plan quota. They require separate top-up or a one-time authorization before first use, after which actual token consumption is deducted from the quota. This explains why even with an active subscription, enabling the Fable advisor still triggers an authorization flow—otherwise the system cannot confirm that the user accepts this additional expense.
Three Ways to Enable and Model Pairing Rules
There are three paths to enable the advisor. Typing /advisor directly in a session brings up a list of selectable models; typing /advisor opus or /advisor fable directly specifies the model and permanently saves the choice to user settings. To avoid typing it every time, you can manually edit settings.json in your user directory and set the advisor model key to opus or fable. If you just want to experiment temporarily, use the claude --advisor opus startup flag; after the session closes, the terminal automatically reverts to default without polluting the configuration file.

There is a hard rule for model pairing: the advisor model's capability level cannot be lower than the primary model's. When the primary model is Sonnet 5.5, the advisor can only be chosen from the Fable or Opus 5 series; lower-tier models like Haiku 4.5 can never serve as advisor. If you force-specify an advisor weaker than the primary model, Claude Code won't crash, but it will simply disable the advisor feature.
The Exaggerated "Four-Model Pipeline"
A post circulating on X described Fable 5.2 as the thinker, Sonnet 5.5 as the coder, Opus as the reviewer, and Haiku as the subagent, making it look like a four-model pipeline. According to the official documentation, Claude Code supports only one primary model paired with one advisor model per session. Running four models in series is not an official one-click mode but a custom workflow users build themselves. Subagents can enable different models for their respective tasks, but the advisor tool itself listens to only one model per session.
Subagent is a task delegation mechanism in Claude Code: the main session can hand off a specific subtask (such as searching the codebase, batch-modifying files, running tests) to an independently running agent instance, which has its own context window and a separately configurable model, and returns only a summary of results to the main session when done. This allows low-cost models to handle mechanical work while avoiding contaminating the main conversation context with large amounts of intermediate process. Its key difference from Advisor Mode lies in responsibility: a subagent is an "executor" that actually invokes tools to complete tasks; an advisor is a "suggester" that only outputs judgments without acting. Thus the two can coexist but cannot replace each other.
The Real Boundaries of Cost Savings
The aforementioned X post claims the feature can save 3.4x in costs, but this is not a figure given in official documentation. The official docs only confirm the directional conclusion that "invoking the expensive model only at critical decisions rather than throughout" can reduce costs. Actual expenses should be discounted: each advisor invocation re-reads the entire session history from scratch, and the advisor's own reads are not cached. Fortunately, the primary model's cache remains intact, and returned suggestions are also cached locally for reuse in subsequent steps.
Prompt Caching is a cost optimization mechanism introduced by the Anthropic API in 2024: when a request contains prefix content identical to recent requests, those tokens can be priced at a substantial discount (cache reads are typically about 10% of the normal input price), avoiding repeated full-price charges for long contexts. Claude Code's long sessions are a typical beneficiary of this mechanism—system prompts, tool definitions, and earlier conversation turns can all be cached and reused. The article points out that the advisor model's reads are not cached, meaning each invocation reprocesses the entire session history at full price, and this cost cannot be amortized through caching; by contrast, the primary model's cache remains intact. The more advisor invocations, the higher the proportion of costs not covered by caching.
Invocation Status and How to Disable
When the advisor is invoked, an advising line with the model name appears on screen. After the invocation ends, Reviewed is displayed; press Ctrl+O to view the advisor's full suggestions. If the advisor declines to give guidance, declined is displayed; if the invocation errors out, unavailable is displayed.

When you don't want to consume extra tokens, run /advisor off in the session to disable it. To completely remove the tool at the system level, set the environment variable CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1, after which the /advisor command will be completely hidden from the terminal.
Editorial View
The value of Advisor Mode is not in the absolute amount of money saved, but in compressing the number of high-reasoning model invocations from "throughout" to "key moments," which represents a reasonable trade-off between cost and quality. But whether it can truly deliver on the cost advantage depends on how frequently "key decisions" appear in your tasks—if every task frequently triggers the advisor, the overhead of repeatedly re-reading session history may offset most of the savings. It is recommended to first trial-run with the single-session flag, observe your actual invocation frequency, and then decide whether to write it into long-term configuration.
One-line Summary
Claude Code launches experimental Advisor Mode, letting high-reasoning models intervene only at critical decision points to balance cost and quality.
Paragraph Summary
Anthropic introduced the experimental Advisor Mode tool into the Claude Code terminal, where the primary model handles execution and writing code, while a high-reasoning advisor model is invoked only at three points—architecture planning, repeated error troubleshooting, and final review—and outputs suggestions only without acting directly. The feature is available through the Anthropic API and Claude Platform on AWS but not yet on infrastructure such as Bedrock, and has minimum Claude Code version requirements. The advisor is billed per token of the invoked model, and the Fable series may be deducted from usage credits and requires one-time authorization. Model pairing has a hard rule: the advisor's capability level cannot be lower than the primary model's. The community-circulated four-model pipeline and 3.4x savings claims are not official conclusions, and the advisor re-reads the entire session history on each invocation without caching, so actual savings depend on the trigger frequency of key decisions.
Related articles

Claude Code Advisor Mode Explained: How Fable 5.2 and Sonnet 5.5 Collaborate on Code
A deep dive into Claude Code's experimental Advisor mode: how Fable 5.2 and Sonnet 5.5 split the work, access requirements, version thresholds, three ways to enable it, Fable's special billing rules, and a fact-check of the "3.4x cost reduction" claim against official docs.

Build a Money-Making App from Scratch Without Code: The 8-Step Process and a $151 Bill
A YouTube creator breaks down the full eight-step process to build a money-making app without code: AI coding, GitHub, Cloudflare hosting, D1 and R2 backend, a New Mexico LLC, a free EIN, Stripe payments, and legal pages—totaling $151.

Two Cursors: A Hopeful Song About Writing Software with AI
YouTube music video *Two Cursors* uses lyrics to portray AI-assisted programming: from a single cursor to two-cursor collaboration to a three-party debugging scene, offering a hopeful view of conversational collaboration between developers and AI.