Claude Opus 5.5 Executes, Claude Fable 5.1 Advises: Pricing Claude Code's Advisor Loop

Claude Fable 5.1 writes the design plan. Claude Opus 5.5 executes it in a loop. Fable 5.1 comes back as the advisor and accepts or rejects the result. That is the pattern X/@dotey posted on September 22, 2026 — the day the vendor released Claude Opus 5.5 — framing it as a token-saving arrangement arrived at under cost pressure: set the advisor to Fable, run Opus, and let the expensive model speak only at decision points. What they are using is no longer a prompt trick or a subagent configuration. It is Claude Code's built-in advisor tool, a server-side feature billed at the advisor model's rates, on top of everything the main model spends. And the advice is the cheap part. Re-reading the conversation to produce it is not — the executor's context has become cheap to re-read, and the advisor's never was. That single asymmetry decides whether the loop is worth running, and it is what the rest of this article prices out.

What the loop actually is

The advisor tool pairs your main model with a second, usually stronger model that Claude consults at key moments — before committing to an approach, when an error keeps recurring, or before declaring a task done. The advisor receives the full conversation, including every tool call and its result, and returns guidance the main model then applies. It never calls tools and never produces user-facing output. You choose which model advises; Claude decides when to call it.

That last part is what separates this from the orchestrator-and-subagent pattern the Claude Code community was circulating in August. Subagents are delegation: a planner decomposes work and dispatches it to workers, and you configure each lane's model explicitly. The advisor is escalation: one model drives the whole task, and the expensive model is pulled in mid-flight for a decision the driver can't make alone. There is no worker pool, no task graph, and no orchestration prompt to maintain. The practical loop @dotey describes — plan, execute, verify, repeat — is what that mechanism looks like when you point the advisor at Fable 5.1 and let it police the loop's exit condition.

Anthropic's own framing of the strategy is blunt about the shape of the win: the advisor "can only hand over capability the executor lacks." Everything below follows from how much capability is actually missing, and how often the executor admits it.

Why Claude Opus 5.5 changed the arithmetic

Anthropic's published rate card, per million tokens. These are vendor figures, not estimates:

• Claude Opus 5.5 — $4 input, $20 output, $0.20 cache read, $5 for a 5-minute cache write

• Claude Opus 5 — $5 input, $25 output, $0.50 cache read, $6.25 for a 5-minute cache write

• Claude Fable 5.1 — $10 input, $50 output, $0.25 cache read, $12.50 for a 5-minute cache write

Two details in that list matter more than the headline prices. First, cache reads on Opus 5.5 are 5% of base input, per Anthropic's own footnote, where most Claude models sit at 10% and Fable 5.1 sits at 2.5%. Fable 5.1 has the better multiplier and still loses on absolute dollars — $0.20 against $0.25 — because its base input rate is two and a half times higher.

Second, and this is the mechanic the loop turns on: toggling the advisor in Claude Code does not invalidate the main model's prompt cache, so the executor's long, repeatedly re-sent context stays cheap at $0.20 per million. The advisor's own read of the conversation is not cached. Each consult processes the full transcript anew, at Fable 5.1's $10 per million input rate. An executor that re-reads a 500K-token context ten times pays for cache reads; an advisor consulted ten times pays ten fresh input bills on a transcript that is growing the whole time. The cheaper your executor's context gets, the more the advisor's uncached read stands out — and Opus 5.5 just made the executor's context 60% cheaper than Opus 5's.

Setting it up in Claude Code

The advisor is experimental and Anthropic says so in the session banner — "Advisor Tool (experimental) is on and may use more tokens." Behavior, pricing and availability can change. With that caveat stated, the mechanics are documented:

• Turn it on with /advisor fable, or run /advisor with no argument for a picker. The choice is saved to the advisorModel setting in your user settings and persists across sessions. /advisor off turns it off.

• For a single session without changing the saved default, launch with claude --advisor fable. The flag is not listed in claude --help, and Claude Code exits at launch if the pairing is invalid rather than starting with a silently ignored advisor.

• Set a persistent default in your settings file with {"advisorModel": "fable"}.

• To kill it entirely, set CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1 — the /advisor command disappears and any configured advisorModel is ignored.

• The pairing must be at least as capable as the main model. Claude Opus 5.5 accepts Fable and Opus 5-or-later as advisors. An Opus 4.6 or Sonnet advisor is rejected by Claude Code; an Opus 4.7 or Opus 4.8 advisor is attached and then refused by the API. Fable 5.1 as the main model accepts only Fable 5.1.

• Version floors: the advisor tool needs Claude Code v2.1.98 or later; Fable as either main model or advisor needs v2.1.170 or later; Fable 5.1 needs v2.1.257 or later. The token form of /advisor — the one that works in -p, the Agent SDK, the desktop app and Remote Control — needs v2.1.260 or later.

• The advisor is Anthropic-API only. It is not available on Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform or Microsoft Foundry, and it depends on feature-flag fetching, so a session with a variable like DISABLE_TELEMETRY set keeps it off.

• On plans where Fable usage bills to usage credits, Fable-as-advisor bills the same way and needs a one-time consent. Until you accept it, /advisor fable does not save and claude --advisor fable exits at launch pointing you at /model fable instead.

Subagents inherit whatever advisor you configured and re-run the same pairing check against their own model. That is the one interaction between this pattern and the subagent pattern: a subagent running a smaller model may be allowed an advisor its parent is not.

The cost shape, worked through

Nothing below is a measurement. The token shape is invented to make the arithmetic visible; the prices are Anthropic's published rates. Assume one executor session that reads 1M fresh input tokens and emits 500K output tokens, and three advisor consults, each re-reading a 200K-token transcript and returning about 600 tokens of guidance — roughly the two-to-three consults per task Anthropic's own system prompt asks for.

• Executor on Claude Opus 5.5 — 1M input at $4.00 plus 500K output at $10.00 = $14.00

• Advisor on Claude Fable 5.1 — 600K input at $6.00 plus about 1,800 output tokens at roughly $0.09 = $6.09

• The loop, total — about $20.09

• The same shape run end-to-end on Fable 5.1 — $10.00 input plus $25.00 output = $35.00

• The same shape on Opus 5.5 alone — $14.00

The loop lands between the two, which is exactly where Anthropic positions it: about 43% cheaper than running Fable 5.1 throughout, and about 44% more expensive than the executor alone. Read the second number as the honest one. The advisor is not a saving; it is a purchase of Fable-grade judgment on three decisions, and it only pays if those three decisions change the outcome. Push the transcript to the 1M context window and each consult costs $10 on its own. Let the executor start asking on most tasks instead of a few, and you are paying advisor rates across the workload — at which point, as Anthropic puts it, running the advisor's model itself is the cheaper route to the same score.

What Anthropic's own measurements say

Anthropic has published measured results for this pattern, and they are vendor-reported: run by the company selling both models, on its own benchmark harness. They are still the only numbers of their kind, and they include the case against the pattern, which is why they are worth reading closely.

• Opus 5 as executor with Fable 5.1 as advisor scored $7.69 per attempt on Anthropic's internal agentic-coding benchmark — the most accurate configuration Anthropic measured. That is 3.5 points above Opus 5 alone at its default setting for slightly less money, and about 2.5 points above Fable 5.1 alone for about half again the money. The 3.5-point gap was separated from run-to-run noise with five attempts per task.

• The same pairing on chart-reading matched Fable 5.1 alone at medium effort within noise — 65.0 against 67.5 — at roughly 2.6 times the cost per task, because the advisor was consulted on nearly every task.

• On GPQA Diamond, the gain tracks the capability gap almost perfectly: a Haiku 4.5 executor gained a great deal, a Sonnet 5 executor a few points, and a frontier executor almost nothing.

• Consult rate is the fragile variable. A low-effort Sonnet 5 executor gained 23 points on DeepSWE with an advisor, then stopped asking altogether on SWE-bench Pro and gained nothing.

• Latency: about two extra frontier-model calls per task, each on the critical path.

Two things about that evidence bear directly on the loop as it stands this week. The measurements used Opus 5 as the executor, because Opus 5.5 did not exist when they were run. And Anthropic reports that Opus 5.5 performs at the level of Fable 5.1 on most work while costing 40% less to run — both vendor claims, neither independently reproduced. If the gap between executor and advisor is what the advisor is paid to close, then a narrower gap is a smaller purchase. The pattern did not get worse when Opus 5.5 shipped; the thing it sells got less scarce.

The failure modes you will actually hit

These are documented behaviors, not speculation, and the first one is the reason to read this section before you debug anything:

• A silently absent advisor. If the API refuses the advisor pairing, Claude Code attaches it, the API refuses it, and Claude Code resends the request without the advisor. The rest of the conversation then runs with no advisor and no error message. It stays off until /clear or /compact, even after you switch to a compatible main model.

• A quietly rejected one. For pairings Claude Code itself rejects, the advisor is simply never attached to the main model's requests. The /advisor output and a notification tell you — but nothing fails, so a session you assumed was advising may never have been.

• Consent you have not given. With Fable selected as advisor on a plan that requires usage-credit consent, requests go out without the advisor until you accept it. A background session started with --advisor fable starts without an advisor rather than exiting.

• An allowlist you do not control. If your organization's availableModels allowlist excludes the advisor model, Claude Code will not invoke it, and you need to pick an allowed model with /advisor.

• Everywhere it does not exist. Anthropic API only: no Bedrock, no Claude Platform on AWS, no Google Cloud Agent Platform, no Microsoft Foundry. Through a gateway, availability depends on whether the gateway forwards the request intact to Anthropic's API — which is a property of the gateway, not something you can assume.

Where OrcaRouter fits

Both models in this loop are on OrcaRouter today at Anthropic's own list price with 0% markup — provider list price passed through, so the rate you see is the rate Anthropic publishes. Claude Fable 5.1 sits at anthropic/claude-fable-5.1 and Claude Opus 5 at anthropic/claude-opus-5, behind one API key. Claude Opus 5.5 is not one of our routes yet; it is available through Anthropic's own API and the major clouds, and we will say so rather than imply otherwise.

What one key buys you here is the ability to change your mind cheaply. The loop's economics depend on the executor-to-advisor price ratio, and that ratio moved twice in seven weeks — Opus 5 to Opus 5.5 on September 22, and Fable 5 to Fable 5.1 on September 1, which cut that model's cache read from $1.00 to $0.25 per million. Every one of those moves changes the answer to "is the advisor worth it," and testing that answer should not require a second contract. Automatic failover is the other half: it lets you point a slice of traffic at a model you have not characterised yet, with a fallback to the one you have, instead of betting a production path on a launch table. And if you are building the pattern yourself rather than using Claude Code's built-in tool, the routing DSL composes several models into a single call — a plan step on one model followed by execution steps on another, behind one endpoint.

One honesty note on scope: the advisor tool itself is a server-side tool that runs on Anthropic's API, so a routing layer is not a substitute for it. What we can do is make the models one key away, at list price, so the decision to keep or drop the advisor is yours to make on your own numbers.

How to decide for your own workload

Anthropic's own guidance is the right starting point and it is refreshingly unsentimental: run your eval suite against three configurations — the executor solo, the executor with an advisor, and the advisor's model alone at low effort — and recheck at every model release, because releases move both the capability gap and the price ratio. The last of those three is the baseline to beat. If your advisor's model alone at low effort scores the same as the loop for less money, you have your answer.

The two variables to watch are the ones Anthropic names. The capability gap: a wide gap between executor and advisor is where the advisor earns its fee, and Opus 5.5 narrowed that gap from below. The consult rate: gains track it almost one-for-one, and it is prompt-sensitive enough to collapse — an executor at low effort can stop noticing it is stuck, and a pairing that consults on most tasks at default effort can fall to almost none. Anthropic's supplied system prompt asks for one advisor call before substantive work and one before finishing, which lands at two to three consults per task; the coding pairing that produced the 3.5-point gain ran at that cadence. Budget for that, cap it, and treat every consult above it as a signal that your executor is misconfigured rather than that the task was hard.

For the specific loop in this article, three concrete settings do most of the work. Keep Claude Opus 5.5 at its default medium effort rather than reaching for high, because effort drives cost directly and Anthropic's own Opus 5.5 numbers show medium giving up very little. Set the advisor with /advisor fable and confirm the banner actually appears — a missing banner means a silently absent advisor. And before you scale the pattern, measure tokens per finished task rather than price per token, because that is the number the loop is supposed to move.

FAQ

Does the advisor consume the same Fable allowance as a Fable session?

On API billing, advisor tokens bill at Fable 5.1's own input and output rates, and advisor rate limits draw from the same per-model bucket as direct calls to that model — so a rate-limited advisor call surfaces as an error inside the tool result rather than failing your request. On subscription plans, advisor usage counts toward your plan's usage limits, except that a Fable advisor bills to usage credits on plans where Fable usage does. The practical consequence is that the advisor is not a separate budget you can spend freely; it competes with everything else you do on that model.

What does the advisor actually get to see?

The full conversation, including every tool call and every tool result — file contents, command output, error messages, the lot. It runs under its own Anthropic-supplied system prompt and returns a plan, a correction or a stop signal. Two details follow from that. First, each consult re-reads the whole transcript, which is why the cost grows with the loop rather than staying flat. Second, if your session touches material you would not send to a second model at the advisor's price tier, the advisor is a second model reading all of it.

What would change the answer

Two things, and both are closer than they look. If independent benchmarkers publish a matched-effort run of Opus 5.5 against Fable 5.1 and confirm the narrowing Anthropic claims, the advisor's remaining edge on most tasks is thin — and the loop becomes a tool for the hard tail rather than a default. If instead the consult rate holds and the capability gap stays wide on long agentic work, the arithmetic above is what you are choosing between, and $6 of advice on a $14 run is a cheap option on not shipping the wrong thing.

What will not change is the mechanic at the top of this piece. Executor context is cached and cheap; advisor context is neither. Any loop that consults a more expensive model mid-task inherits that asymmetry, whatever the price list says next month.