You will see a lot of posts telling you to switch everything to Fable 5.2. I read what Anthropic itself says about it, and the honest answer is more careful. Fable 5.2 came out on 9 November 2026 at $8 per million input tokens and $40 per million output tokens, twice the price of Opus 5.5. Anthropic's own advice is to start most work on Opus 5.5 and move up to Fable for the most ambitious, open-ended jobs. So the real question is not how to use Fable for everything. It is how to use it only where it earns its price.

Fable is not a setting. It is a bill. Spend it on purpose.

A big job on the strongest model can finish well and still eat a large part of your limit. Anthropic says as much about one cause: sub-agents can be a big part of what a session costs, so check which model they use. That is the first thing most people never look at.

This guide is the short list of settings that change the result, in plain words, with the source for each. Where the internet says something Anthropic's docs do not confirm, I say so and leave it out of the steps.

// Build this with your AI agent

Build this with your AI agent

Want your own setup checked? Copy this prompt into Claude Code, together with this guide's link. It only audits. It changes nothing until you say yes.

Read this guide: https://codewithnishant.dev/free/fable-5-2-big-jobs-guide/ and Anthropic's own pages it links to (the Fable 5.2 prompting guide, the Claude Code model-config, advisor and sub-agents docs). Audit my Claude Code setup for Fable 5.2 without changing anything. Report: my Claude Code version (Fable 5.2 needs v2.1.321 or later), my current model and effort level, whether CLAUDE_CODE_SUBAGENT_MODEL is set or any agent file has a model field, which advisor model is set, and every rule in my CLAUDE.md and memory notes that says never, always stop or always ask, since those can make Fable ask for approval too often. Then propose changes as a short list with one item per layer (prompt, context, loop, harness) and wait for my OK on each one. Do not edit any file or setting, and do not switch models, until I say yes. Tell me what you could not check instead of guessing.
  • Before you start: Claude Code v2.1.321 or later (run claude update) and access to a Fable model on your plan.
  • Cost: This guide is free. Fable 5.2 bills at $8 and $40 per million tokens on the API, or against your plan limits and usage credits. The audit itself is a short session.
  • Expected result: a one-page audit of your setup and a short list of changes you approve one by one. I have not run this prompt myself, so expect to adjust it.

01. Six settings, in order

The short answer: start on Opus 5.5 and move to Fable only for big, open-ended jobs. Put sub-agents on Opus 5.5, because they copy your main model. Try /advisor fable on one task and compare /usage. Plan at medium effort, run at high. Say who owns the code only when you want the structure improved.

If you read nothing else, do these in this order. Each row says where it lives and why. The sections after it explain each one and what it costs.

#SettingHowLayer
1Fable only for the big job/model fable (everyday work stays on Opus 5.5)Harness
2Sub-agents on Opus 5.5, not FableCLAUDE_CODE_SUBAGENT_MODEL or a model: line in the agent fileHarness
3Opus as main, Fable only for hard decisions/advisor fableHarness
4Effort: plan at medium, run at high/effort medium, then /effort highLoop
5Fable plans, Opus executesWrite a plan file, then switch with /model at a natural breakLoop
6Say who owns the code, and what needs your approvalOne line in the prompt, used only when you want the structure improvedPrompt

Before any of it: no Fable model is the default on any plan. You pick it yourself, and on some plans Claude Code asks you once to agree to bill Fable usage to usage credits. That is in the Claude Code model docs.

02. Start inside: the four layers

When an AI coding run goes badly, people reach for the outside first. A bigger model. A new setting. A plugin. Usually the problem is closer in. Here is how I sort every setting in this guide. It is my own way to think about it, not an Anthropic diagram.

HarnessFails: unsafe, or you cannot verify the result

Models, tools, permissions, checks

Fable 5.2 settings/model, sub-agent models, /advisor, usage limits, your own confirmation step

LoopFails: repeats the same mistake

Act, check, retry, stop

Fable 5.2 settingseffort level, plan then execute, a finish-the-job line, /goal

ContextFails: missing or noisy facts

Everything the model can see

Fable 5.2 settingsold "never" rules in CLAUDE.md and memory, a lean main context

PromptFails: a vague answer

What you ask

Fable 5.2 settingsthe outcome, the ownership sentence, exact approvals

Start inside, fix outward. Fix the innermost layer that is broken.

My own sorting of the settings below. The layer names are mine. The settings and numbers come from Anthropic's docs.

So the order of the next four sections is inside to outside: prompt, context, loop, then harness. The model split everyone talks about lives in the outermost layer. It is the most visible one. It is rarely the first thing to fix.

03. Ownership sentence: what it changes in Fable 5.2

Layer 1 · the innermost

Anthropic's Fable 5.2 prompting guide says the model pays close attention to who owns the code. In Anthropic's tests on small coding tasks, when the prompt said nothing about ownership, or presented the code as someone else's, Fable tended to add to the existing structure, even when that duplicated code. When the prompt said the code was the model's own, it often cleaned up and merged duplicates, and sometimes made related fixes nobody asked for.

The line Anthropic suggests starts like this: "You are the owner and long-term maintainer of this codebase." With a line like that, the model merged duplicated code in about 75 percent of runs, against under 10 percent without it.

It is a trade, not a free upgrade. The same guide says output tokens rose by about 70 to 80 percent, the model made changes nobody asked for (many of them new tests and docs), and in some runs it changed how an existing feature behaves. Its closing summary often left out small changes. So read the diff, not just the summary.

  • Use it on your own project, when you want the structure improved as the work goes.
  • Leave it out when you want the smallest possible change, for example a bug fix in a client's code. Anthropic found that a scope rule, such as no drive-by refactors, did not cancel the ownership line once it was in the prompt, so remove the line, do not fight it.

Describe the outcome, not the steps

The Claude Code docs give four tips for Fable: describe the outcome and let it plan the path, hand it ambiguous problems, skip the "remember to test" reminders because it verifies its own work, and give it work you would normally break into pieces.

You may see posts saying Fable needs longer, more detailed prompts. I could not find that advice in Anthropic's docs. For the steps they say the opposite. What the docs do ask you to spell out is smaller: who owns the code, and exactly what needs your approval. On approvals, the prompting guide says to name the action, for example "ask for approval before deleting files", rather than a blanket "never delete files", because the model treats "never" as absolute.

04. Context: clear out old rules

Layer 2

Fable follows instructions closely. That is great until your CLAUDE.md and memory notes are full of old cautions. The prompting guide has a whole section on caution that builds up: an old note that says never retry, or stop at the first error, can keep blocking autonomous work long after the reason is gone.

  • Delete notes you no longer need. Memory collects old rules, and some may have been written by the model itself.
  • Name the steps that need no approval. "Act more freely" is too vague. List the routine things it may do on its own.
  • Rewrite absolutes with a scope. "Ask for approval before deleting files" instead of "never delete files".
  • Keep your own confirmation step for anything risky or irreversible.

Also keep the main conversation lean. Anthropic's model post makes the point that a lean main context matters more the bigger the main model is: keep the expensive model's context for decisions, and let cheaper sub-agents do the verbose reading. If you have not set up your rules file yet, start with my CLAUDE.md template, and see Claude Code memory setup for what gets remembered between sessions.

05. Which effort level for Fable 5.2, and plan then execute

Layer 3

Effort level

Effort sets how much the model thinks, how many tool calls it makes, how long a turn takes and how many tokens it spends. Fable models have five levels: low, medium, high, xhigh and max. In Claude Code, Fable 5.2 starts on medium. On the API the default is high. Change it with /effort high, or launch with claude --effort high for one session.

LevelWhat Anthropic says (prompting guide and Claude Code docs)
lowQuick back-and-forth, well-specified tasks, fast sub-agents
mediumInteractive coding and everyday work. The Claude Code default for Fable 5.2
highHard coding, research, agentic work and long unattended runs. Most of the capability gain comes at this level
xhighYour hardest long-running work, where you measured a gain. Slightly higher scores, many more tokens
maxThe model's ceiling, or rare tasks where time and tokens do not matter. Slow, many more tokens. The Claude Code docs say it may show diminishing returns and overthink

One pattern comes straight from the guide: plan and iterate at medium, then raise effort for the long unattended part. At high and above, Fable thinks before almost every reply, even a greeting, so drop back to medium for quick questions.

Anthropic's model post adds two numbers worth knowing. On FrontierCode 2.0, Fable 5.2 at high scored about level with Opus 5.5 at max (45.3% against 45.5%) for roughly half the cost per task. So before you push Opus past high on a hard task, try Fable at high instead. And on one test with the older Fable 5.1, max scored no better than Opus 5.5 at high while using about twice the tokens. Past high, more effort is not automatically better.

Fable plans, Opus executes

You will see "Fable plans, Opus builds" suggested online as a setup. What Anthropic confirms is narrower: the prompting guide says early testers had good results with Fable 5.2 as the planner and orchestrator for other models. Anthropic does not publish a savings number for it.

If you want to try it, do it by hand and switch at a natural break. Anthropic's model post explains why: the prompt cache belongs to the model that wrote it, so your first turn on a new model pays the cache-write price on the whole conversation, and a move from Fable 5.2 to another model drops Fable's earlier reasoning. So:

  1. On Fable, ask for a written plan in a file, with a check for every step. No code yet.
  2. Clear the thread. Run /compact (if long chats lose detail when Claude Code compacts, see my Billion-Context guide), or start a fresh session that holds only the short plan.
  3. Switch with /model opus and tell it to follow the plan and stop if a step looks wrong.

Then measure it. Anthropic's own quick test: run one task from your backlog on two models with /model and compare what /usage reports.

Make it finish the job

At low and medium effort, Fable 5.2 sometimes ends a turn before the work is done: it lists what is left, offers to continue, or stops at an ordinary error. If you see that, tell it plainly to keep going through ordinary problems like timeouts and failing tools, to leave real blockers alone and say what it found, and to keep asking you before risky or irreversible actions. In Anthropic's replay test a similar line roughly halved unfinished sessions, but output tokens rose by about 30 percent. For a long goal, the Claude Code docs also point to /goal: you set a completion condition and Claude keeps working until a check says it is met.

06. Which model do sub-agents use? Put them on Opus 5.5

Layer 4 · the outermost

Here is the one that surprises people. Sub-agents copy your main model. The sub-agent docs list the order Claude Code uses to pick a sub-agent's model: the model Claude passes for that call, then the model line in the sub-agent's file, then the CLAUDE_CODE_SUBAGENT_MODEL variable, and last of all the main conversation's model.

If you set none of them, the sub-agents you define run on Fable too. The built-in Explore sub-agent follows its own rule, so check /tasks to see what each one really used.

Why it matters: Anthropic's prompting guide warns that sub-agents can be a large part of a session's cost. Anthropic's model post says Opus 5.5 costs half as much per token as Fable 5.2 ($4 and $20 per million tokens, against $8 and $40).

Way 1: set it once for every session. In your Claude Code settings file, add this. It uses the full model ID the docs give as an example:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-opus-5-5"
  }
}

Two details from the docs. The variable is a default: a sub-agent file that names its own model still wins. And by itself it does not change the built-in Explore and Plan sub-agents. To apply one model to every sub-agent, also set CLAUDE_CODE_SUBAGENT_MODEL_FORCE to 1 (Claude Code v2.1.257 or later).

Way 2: set it per sub-agent. Put a model line in the agent's file, for example .claude/agents/reviewer.md. Accepted values are sonnet, opus, haiku, fable, a full model ID, or inherit:

---
name: reviewer
description: Reviews a finished change and reports bugs. Use after edits.
tools: Read, Grep, Glob, Bash
model: claude-opus-5-5
---
Review the change you are given. For each problem, report the file, the line and the fix. Do not edit any files.

Check it worked. Run /tasks. Claude Code names the model on each sub-agent's row (v2.1.242 or later). Do not trust the setting, read the row.

One honest limit: this fixes the cost of the helpers, not the cost of the main model. And Anthropic's guidance is to keep small models on work where a mistake is cheap to spot, like finding files and reading logs, and keep code edits and judgment calls on the main model. For more on agent files, see my Claude Code agent stack guide.

The cheaper-team setup, where a big model leads and small models do the bulk work, is its own topic and gets its own guide.

07. What does /advisor fable do?

The reverse split

The model split above puts Fable on top. The advisor flips it. Opus stays your main model and does the routine turns. Fable is only consulted at key moments: before Opus commits to an approach, when an error keeps repeating, or before it says it is done. You set it with:

/advisor fable

The advisor docs say what to expect:

  • Experimental. It works on the Anthropic API and Claude Platform on AWS. It is not available on Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry.
  • Claude decides when to ask. There is no setting to force or cap it. You can ask in your prompt, for example "consult the advisor before you continue".
  • The pairing has rules. An advisor must rank at or above the main model. An Opus 5.5 main model accepts Fable as its advisor. A Fable 5.2 main model accepts only Fable 5.2.
  • Fable access still applies. On some plans a Fable advisor needs your one-time consent to bill Fable to usage credits. Run /model fable once to give it.
  • It costs tokens. The advisor reads the whole conversation on each call, and its read is not cached. A Fable advisor bills to usage credits on plans where Fable does.
  • Off switch. /advisor off. You can also try it for one session with claude --advisor fable.

"Up to 3.4x cheaper"? Not confirmed.

You may see a big savings number for this setup. I could not find any such number in Anthropic's docs, so it is not in the steps. What Anthropic does say is softer: because the advisor is only called at decision points, a faster main model plus a stronger advisor typically costs less than running the stronger model throughout.

And Anthropic's own measured example is a warning. In its model post, an Opus 5.5 main model at high with a Fable 5.1 advisor scored 1.7 points above Opus 5.5 alone, for about 2.1 times the money, a gain that sits at the edge of run-to-run noise. The post adds that none of the four pairings in the platform's cost guide clearly beat the main model alone. That test used the older Fable 5.1, not 5.2, so it is a caution, not a verdict. The honest way to use /advisor is to try it on one real task and compare /usage.

08. What does Fable 5.2 really cost?

Every setting above has a price. Here they are in one place, each with its source.

WhatThe cost (source)
Fable 5.2 itself$8 input and $40 output per million tokens, twice Opus 5.5 (launch post for Fable's price, model post for Opus 5.5's)
Fast modeUp to 2.5 times faster for $16 and $80 per million tokens, double the normal rate (launch post)
Ownership sentenceOutput tokens up about 70 to 80 percent, plus changes nobody asked for (prompting guide)
Finish-the-job lineOutput tokens up about 30 percent in Anthropic's replay test (prompting guide)
Asking for an opening line and a recapOutput tokens up about 20 percent (prompting guide)
High effort and aboveMore tokens and more time. xhigh and max use many more (prompting guide)
Sub-agentsCan be a large part of what a session costs (prompting guide)
AdvisorExtra tokens on every advisor call, not cached (advisor docs)
Your plan limitsAt launch, Anthropic said Fable is included for up to 50 percent of weekly limits on Pro plans and standard Team seats, and some plans bill Fable to usage credits. Check your own plan before a long run (launch post for the 50 percent line, Claude Code model docs for usage credits)

The only way to know what a setting costs you is to run one real task and read /usage afterwards. Do that before you hand Fable a long job.

09. Which setup for which job

My picks, built on the sources above. Not a tested playbook.

The jobSetup
A bug fix or a feature with a clear scopeOpus 5.5 at medium, no Fable. This is Anthropic's own starting point
A hard bug where Opus 5.5 at high is stuck/model fable at medium, then high. Describe the outcome. Skip the ownership line
A big migration or a refactor you ownFable as main, sub-agents on Opus 5.5, high effort, the ownership line, a written goal, and a diff review at the end
A long job where most turns are routineOpus main with /advisor fable. Try one task, compare /usage
A client's code where changes must stay small (new to client work? see my first client playbook)No ownership line. Ask for the smallest change and a list of other problems it saw
Quick questions and small editsDrop effort to low or medium, or use Sonnet 5.5

10. Copyable prompts

1. The ownership prompt (when you want the structure improved)

You are the owner and long-term maintainer of this codebase. The design is yours to improve. While you work on [the job], merge duplicated code into shared functions where it makes sense. At the end, list every change you made that I did not ask for, and tell me before you change how any existing feature behaves.

2. The small-change prompt (leave ownership out)

Fix only [the bug]. Make the smallest change that fixes it. Do not refactor, rename or add tests. If you notice other problems, list them at the end and do not fix them.

3. Ask Fable for the plan

Plan [the job] and write it to PLAN.md. Include the goal, numbered steps small enough for another model to do one at a time, how to check each step, what needs my approval before it happens, and what must not be touched. Do not write any code yet.

4. Hand the plan to Opus

Read PLAN.md and do it step by step. Check each step the way the plan says. If a step looks wrong, stop and tell me why instead of changing the plan. Ask before deleting files or touching anything outside this project.

5. Nudge the advisor

Consult the advisor before you commit to an approach, and again before you tell me the job is done.

6. Clean old rules out of CLAUDE.md and memory

Read my CLAUDE.md and memory notes. List every rule that says never, always stop or always ask, and say what each one protects. Rewrite the absolute ones with a scope, for example "ask for approval before deleting files". Show me the diff and change nothing until I say yes.

FAQ

How do I switch to Fable 5.2 in Claude Code?

Run /model fable, or start Claude Code with claude --model fable. Fable 5.2 needs Claude Code v2.1.321 or later, so run claude update first. No Fable model is the default on any plan, you pick it yourself. On some plans Claude Code asks you once to agree to bill Fable usage to usage credits.

Do sub-agents use Fable 5.2 too?

By default, yes. A sub-agent with no model of its own runs on the main conversation's model, so a Fable session gives you Fable sub-agents. The built-in Explore sub-agent has its own default. To change that, set the model field in the sub-agent's file, or set the CLAUDE_CODE_SUBAGENT_MODEL environment variable to opus or a full model ID such as claude-opus-5-5. Run /tasks to see which model each sub-agent actually used.

What does /advisor fable do?

It lets your main model, for example Opus 5.5, ask Fable for guidance at key moments, such as before it commits to an approach, when an error keeps repeating, or before it says it is done. Claude decides when to ask. The feature is experimental and works on the Anthropic API and Claude Platform on AWS, not on Amazon Bedrock, Google Cloud or Microsoft Foundry. Turn it off with /advisor off.

Does the advisor really make Fable cheaper?

Anthropic says that pairing a faster main model with a stronger advisor typically costs less than running the stronger model throughout, because the advisor is only called at decision points. Anthropic has not published a savings figure for Fable 5.2. On one internal coding test, an Opus 5.5 main model with a Fable 5.1 advisor scored 1.7 points higher than Opus 5.5 alone for about 2.1 times the cost, so measure it on your own work.

Which effort level should I use with Fable 5.2?

Claude Code starts Fable 5.2 on medium. Anthropic's prompting guide says most of the capability gain comes at high, and that going above high gives uneven gains for many more tokens. A sensible pattern from the guide is to plan and iterate at medium, then raise effort to high for the long unattended part. Treat xhigh and max as tools for tasks where you have measured a gain.

What is the ownership sentence for Fable 5.2?

It is one line in your prompt, such as You are the owner and long-term maintainer of this codebase. Anthropic found that Fable 5.2 pays close attention to who owns the code. Without it, the model tends to add to the existing structure. With it, the model merged duplicated code in about 75 percent of small test runs against under 10 percent without it, but output tokens rose by about 70 to 80 percent and it made changes nobody asked for. Leave the sentence out when you want the smallest possible change.

Should I use Fable 5.2 for everything?

No. Anthropic recommends starting most coding and knowledge work on Opus 5.5, which costs half as much per token, and moving up to Fable for the most ambitious, open-ended work such as large migrations, long unattended runs, or problems where Opus 5.5 at high effort still falls short.

Is Fable 5.2 the same as Mythos 5.2?

Anthropic's prompting guide says Mythos 5.2 offers the same capabilities as Fable 5.2, but only to organisations verified through its cyber and life-science programs. Fable 5.2 is the one open to everyone, and it runs safety checks that can decline some cybersecurity and biology requests.

What I checked, and what I did not

On 12 November 2026 I read these Anthropic pages: the Fable 5.2 launch post, the Fable 5.2 prompting guide, the Claude Code model configuration, advisor and sub-agents docs, and the post Which Claude model should you build with? on Claude's developer blog at claude.dev, which Anthropic's own claude.com blog lists and links to. I could not open the social post that shared that guide, so I matched it by its title. Every command, number and quote above comes from those pages. I did not run these settings on a real project, so I cannot say how much any of them saves you. Items that circulate online but are not in Anthropic's docs, like the "3.4x cheaper" advisor number and the advice to write longer prompts, are named above as unconfirmed and are not in any step. Fable is brand new and Claude Code changes often, so check the docs again before you rely on a version number.

Fable is the boss you hire for the big job. Do not pay it to carry the boxes.

// Free newsletter

I send out guides like this every week

Real setups, real sources, no hype. Drop your email and I'll send you the next one.