Skip to main content

Claude Fable 5.2 is Anthropic’s strongest generally available model, and it is priced like it: $8 per million input tokens and $40 per million output tokens on the API, double Opus 5.5. On a Claude subscription, Fable use can count against a capped share of your weekly limits or bill to usage credits, depending on your plan.

Claude Code has a built-in way around much of that cost. With the advisor tool, a cheaper model such as Sonnet 5.5 does the work, and Claude consults Fable only at the moments that decide the outcome. Anthropic’s own testing of an earlier pairing found it kept most of the stronger model’s score at a clearly lower price.

This guide explains how the advisor actually works, what Anthropic has measured, how to set it up in Claude Code, how to confirm it is running, what it costs, and when it isn’t worth it. The facts come from Anthropic’s Claude Code and API documentation, its advisor announcement and its developer account, as of November 16, 2026. We have not run cost tests of our own.

In this article
  1. What the Advisor Does
  2. Why Pair Fable With a Cheaper Main Model
  3. Set It Up in Claude Code
  4. Check That It’s Working
  5. What It Costs
  6. Get Better Advice From It
  7. When to Use It, and When Not

1.What the Advisor Does

The advisor is a second model that your main model can ask for guidance during a task. Anthropic’s Claude Code documentation describes it as a way to consult a second, typically stronger model at key moments. The advisor receives the full conversation, including every tool call and result, and sends back guidance that the main model applies before it continues.

Claude Code documentation page titled Escalate hard decisions with the advisor tool
The advisor tool page in the Claude Code docs. Source: code.claude.com

The important detail is who decides when that happens. It is not a fixed plan-then-execute pipeline where the strong model plans and the cheap one follows. Your main model keeps working and decides for itself when to call the advisor. According to the docs, it tends to consult at three points:

  • Before committing to an approach, such as choosing how to structure a refactor.
  • When an error keeps recurring, instead of trying the same fix again.
  • Before declaring a task done, as an independent check.

The advisor itself has no tools and writes nothing you see directly. Anthropic’s API documentation says it typically returns about 400 to 700 tokens of written guidance, a few short paragraphs. Your main model then reads that guidance and acts on it, and it can push back: if a suggested step fails when tried, or a file contradicts the advice, the main model is designed to raise the conflict rather than follow the guidance blindly.

That design is why the approach can save money. The strong model reads the situation a handful of times and thinks hard once each time, while the cheaper model does the many routine turns of reading files, editing and running commands.

If you can describe the advisor as a senior colleague your main model calls at decision points, rather than a model that runs the whole job, you have it right.

2.Why Pair Fable With a Cheaper Main Model

Anthropic has published two sets of results for advisor pairings. They measured different model generations on different benchmarks, so it helps to keep them separate. The table lists each pairing, the benchmark it was tested on, what Anthropic reported and where it reported it.

Pairing Benchmark Result Source
Sonnet 5 main, Fable 5 advisor SWE-bench Pro About 92% of Fable 5’s score at about 63% of the price @ClaudeDevs, July 2026
Sonnet 4.6 main, Opus 4.6 advisor SWE-bench Multilingual 2.7 points higher than Sonnet alone, 11.9% lower cost per task Anthropic, April 2026
Haiku 4.5 main, Opus advisor BrowseComp 41.2% against 19.7% for Haiku alone Anthropic, April 2026

The first row is the one that matters for Fable. Anthropic’s developer account reported it in July with Fable 5, and noted that Fable was called roughly once per task to steer while Sonnet did most of the work.

Read that number precisely. About 63% of the price means a saving of about 37%, not more. It was measured on one coding benchmark with Fable 5 and Sonnet 5, not with today’s Fable 5.2 and Sonnet 5.5, and Anthropic hasn’t published a repeat for the newer models. Our expectation is that the pattern carries over to the newer models, but that is an inference, and the exact percentages belong to that test.

The April advisor announcement shows the other side of the same idea: adding a strong advisor to a cheaper main model can raise its score while lowering cost, because the cheaper model wastes fewer turns going down wrong paths.

Anthropic article titled The advisor strategy: Give agents an intelligence boost, dated April 9, 2026
Anthropic’s announcement of the advisor strategy. Source: claude.com

The practical conclusion is that Sonnet 5.5 with a Fable advisor gives up a little of Fable’s quality in exchange for a lower bill, on work where most turns are routine. It does not give you Fable’s full quality for free.

3.Set It Up in Claude Code

Setting up the advisor takes a minute, but the order matters. You need Claude Code version 2.1.321 or later for Fable 5.2, and the advisor works only through Anthropic’s own API, Claude Platform on AWS, or Claude Models on Google Cloud (Anthropic managed). It is not available through Amazon Bedrock, Google Cloud’s Agent Platform or Microsoft Foundry.

First, make sure Fable is allowed on your account. On some plans, Fable bills to usage credits and needs a one-time consent, and Claude Code won’t save Fable as your advisor until you’ve given it. The consent prompt appears only when you select Fable as your main model, so run this once even though you won’t keep Fable as the main model afterwards:

Bash

/model fable

Accept the prompt, then switch your main model back to something cheaper. This step is essential: a Fable main model only accepts a Fable advisor, so leaving Fable as the main model gives you no saving at all.

Bash

/model sonnet

Now set Fable as the advisor. Typing /advisor on its own opens a picker of the available advisor models, while passing the model name sets it directly in one step:

Bash

/advisor fable

Claude Code replies with a line beginning Advisor set to, and saves the choice to your user settings so it persists into new sessions. If you would rather configure it in a file, add the same choice to your settings:

{
  "model": "sonnet",
  "advisorModel": "fable"
}

For a single session without changing your saved settings, launch with the flag instead: claude --model sonnet --advisor fable. The flag isn’t listed in claude --help, but it is documented. Claude Code exits with an error at launch if the main model can’t use an advisor or Fable consent is missing, but an advisor that ranks below the main model is simply left off, without an error.

You can also use Opus 5.5 as the advisor with /advisor opus. It costs half as much per token as Fable, which makes it the cheaper choice when you mainly want a second opinion rather than Fable’s top-end reasoning.

You’ve finished setup when the confirmation line names Fable and your status shows Sonnet as the main model.

4.Check That It’s Working

Several conditions switch the advisor off without an error message, so it is worth confirming it is really running before you count on the savings.

When the advisor is active, you see these signs:

  • At session start, a notice reading Advisor Tool (experimental) is on and may use more tokens.
  • During a task, an Advising line with the advisor’s model name whenever Claude consults it.
  • After each consultation, the line shows whether the advisor reviewed the work, declined, or was unavailable. Ctrl+O shows the guidance when the advisor returned readable text. Fable and Opus 5.5 advisors return their advice encrypted, so with the setup in this guide you will usually see only that the advisor reviewed the conversation, not what it said.
  • In /usage, advisor usage appears in your session totals.

If you see none of these on a multi-step task, work through the usual causes:

  • No Fable consent yet. Claude Code points you to /model fable instead of saving Fable as the advisor.
  • An old version. Fable 5.2 as advisor needs Claude Code 2.1.321 or later.
  • A main model stronger than the advisor. The advisor must rank at or above the main model, so a Fable main model with an Opus advisor gets no advisor at all.
  • An unsupported provider or gateway. Bedrock, Agent Platform and Foundry don’t support it, and some LLM gateways don’t pass it through.
  • Telemetry disabled. The advisor depends on a feature flag fetched from Anthropic, which settings such as DISABLE_TELEMETRY prevent.
  • An earlier refusal in the same conversation. If the API refused a pairing, the advisor stays off until /clear or /compact.

A short task may also finish without any consultation, because Claude decides when advice is needed. Test on something with several steps, such as a bug that takes a few attempts to fix, before concluding it isn’t working.

5.What It Costs

The advisor adds cost on top of your main model’s usage every time it is called. How you pay depends on your account.

On a Claude subscription, advisor usage counts toward your plan’s usage limits. The exception is a Fable advisor on plans where Fable usage bills to usage credits; there, the advisor bills to credits too. The /model picker labels Fable “Requires usage credits” when that applies to you, so check it before relying on your plan’s limits.

On the API, you pay the advisor model’s rates for its tokens. These are the current list prices per million tokens for the models involved.

Model Input Output
Claude Fable 5.2 $8 $40
Claude Opus 5.5 $4 $20
Claude Sonnet 5.5 $2 $10

The cost that catches people out is that each advisor call reads the whole conversation from scratch. Claude Code’s documentation states that the advisor’s read is not cached and processes the full transcript again on every call, while your main model benefits from cached, much cheaper reads of the same history.

Here is our own rough example. Suppose your session has grown to 120,000 tokens and Claude consults a Fable advisor, which returns about 1,600 tokens including its thinking:

  • Reading the conversation: 120,000 tokens at $8 per million is about $0.96.
  • Writing the guidance: 1,600 tokens at $40 per million is about $0.06.
  • One consultation therefore costs roughly $1.00 at this session length, or about half that with an Opus advisor.

That is why the advisor pays off when Claude consults it a few times per task, as in Anthropic’s test where Fable was called about once. A long session with many consultations can cost more than you expect. Two habits help: start a fresh session or run /compact between unrelated tasks so each read is shorter, and check /usage after your first few real tasks to see what the advisor actually adds.

6.Get Better Advice From It

Claude decides when to consult the advisor, but your instructions can shift that. Claude Code has no setting to cap or force calls, and the documentation says to ask in plain language instead, the same way you would request any tool.

For a task where the plan matters, put the request in the prompt. A good prompt names the moments you want checked, which keeps consultations to the decisions that are worth the cost:

▣ Claude Code⌁ project⑂ main
Migrate the billing module from the old payments client to the new one. Consult the advisor once before you choose an approach and once before you tell me you’re done.

If you want the same behavior in every session for a project, write it into your CLAUDE.md file, where Claude reads it at the start of each conversation. This is our own example, phrased only as moments to consult; Anthropic’s guidance warns against mixing a consult reminder with instructions telling the model to hold back, because the two pull against each other:

## Advisor
- Consult the advisor before committing to an approach on any task with more than three steps.
- Consult it if the same error appears twice.
- Consult it before declaring a task complete.

Timing matters more than frequency. Anthropic’s API documentation reports from its own testing that reminding a small model such as Haiku to consult early raised its pass rate by about seven points, while the same reminder made no measurable difference for Sonnet. For Opus as the main model the common problem was the opposite: consulting too late or not at all. A hard checkpoint, consulting before the first file edit or state-changing command, improved Opus results by seven to ten points on tasks where it had under-consulted, though results were roughly flat across a mixed workload. With Sonnet as your main model, expect smaller effects from timing instructions; their main value is keeping consultations at the moments you care about.

You can also ask for shorter advice. The documentation suggests telling the advisor to keep its guidance under a fixed number of words, which cuts its output cost, though it treats that as a soft limit rather than a hard one.

If you build with the advisor through the API rather than Claude Code, you get two extra controls. max_uses caps advisor calls per request, and max_tokens caps each consultation’s output; Anthropic’s documentation suggests 2,048 as a starting point, which cut advisor output to roughly a seventh in its tests without truncating most answers.

You’ll know your instructions are working when the Advising lines appear at the moments you named and not on every small step.

7.When to Use It, and When Not

The advisor suits long, multi-step tasks where most turns are routine but the quality of a few decisions determines the result. Large refactors, debugging sessions where an error keeps coming back, and work you want independently checked before it is called done all fit that description.

It adds little on short tasks with nothing to plan, and it is the wrong tool when every turn needs the strongest model. Claude Code offers other ways to combine models, and each suits a different shape of work:

  • Advisor: the strong model joins at decision points that Claude chooses. Best for long tasks with a few critical decisions.
  • opusplan: Opus plans in plan mode, then Sonnet carries out the plan. Best when you want to approve a plan before any work starts.
  • Subagents with a set model: the stronger model handles a whole delegated subtask. Best for a self-contained piece of hard work.
  • /model fable: Fable runs every turn. Best when the whole task is hard and the budget allows it.

A sensible way to decide is to take one real task you have done recently, run it once with Sonnet and a Fable advisor, and compare the result and the /usage totals with how it went before. If the quality holds and the bill drops, keep the advisor as your default for that kind of work.

Leave a Reply

Close Menu

About aiartimind

Hands-on guides to the AI tools creators actually use: Claude Code and coding agents, AI video and motion graphics, and AI agents that automate your work. Every workflow is tested before we publish it.