Skip to content
Giallo

Claude Code Fable 5.2: how to use it well and when to stay on Opus 5.5

Claude Code Fable 5.2: medium effort by default, fast mode, subagent costs and when to stay on Opus 5.5. A practical guide with official data from 9 November.

Editorial team: Giallo Studio

Published on

Updated on

Reading time: 10 min

Claude Code Fable 5.2: how to use it well, with a decision chart for Fable 5.2 vs Opus 5.5, effort, fast mode and subagents

Claude Code with Fable 5.2, released by Anthropic on 9 November 2026, works well if you treat it as the model for hard tasks and not as the everyday one. Anthropic itself recommends starting with Opus 5.5 for most coding work and moving up to Fable when the task is ambitious and open-ended. In Claude Code the default effort is medium, fast mode is available and subagents can drive up the cost of a session.

This guide lays out what the official pages accessed on 9 November 2026 say about using Fable 5.2 for development work: when to choose it, how to set the effort, what to do with fast mode, how to keep subagents under control and how to avoid turns that stop halfway. For the model's technical profile, see our article on what Claude Fable 5.2 is. Here we only cover how to work with it.

In summary

  • Anthropic names Opus 5.5 as the everyday model for code and knowledge work and reserves Fable and Mythos for the most ambitious work, according to the official announcement.
  • In Claude Code and in the Claude apps, Fable 5.2's default effort is medium, according to the announcement; in the API it is high, as explained on the what's-new page.
  • Fable 5.2's fast mode is listed among the platforms that offer it, Claude Code included: up to 2.5 times faster, at double the price in the API.
  • Subagents can weigh heavily on the cost of a session, because in an environment that encourages delegation the model delegates readily.
  • On long tasks it may end its turn early, more often at low and medium effort: you prevent this with a clear finish line.
  • Reasoning cannot be switched off: for simple requests, lower the effort.

When should you choose Fable 5.2 in Claude Code, and when stay on Opus 5.5?

Choose Fable 5.2 when a task has already defeated Opus 5.5 and is worth twice the cost per token. Everything else stays on Opus. The rule is not ours: in its announcement, Anthropic writes that Fable and Mythos are meant for the most ambitious, open-ended technical work, while for most coding tasks it recommends Opus 5.5, which it calls its best everyday model, and switching only if the work requires it.

The numbers help show where the line is. According to the internal tests reported in the official announcement on FrontierCode 2.0, Fable 5.2 at High effort scores about the same as Opus 5.5 at Max effort (45.3% vs 45.5%) for about half the cost per task. At Xhigh it reaches 49.1%. These are results declared by the vendor and not replicated by third parties: read them as an indication, not as a guarantee for your code.

Situation in Claude Code Model to try first Why (prices in $ per million tokens, input/output)
Everyday bugs, small functions, local refactoring Opus 5.5 It is the everyday model recommended by Anthropic, at 4/20
A broad migration that Opus 5.5 does not close Fable 5.2 at high Same result as Opus at Max in an internal test, at about half the cost per task
The hardest problem of the week, after Opus has failed Fable 5.2 at xhigh It is the level Anthropic indicates for the hardest agentic work, where you have measured a gain
Quick questions, renames, boilerplate Sonnet 5.5 or Haiku 5.5 Anthropic says to move down a model when the task is simple

The full comparison between the two models, with prices and use cases, is in Fable 5.2 vs Opus 5.5. If you need the guide to Opus in Claude Code, with stop rules and checklists, it is in Claude Opus 5.5 in Claude Code.

Which effort should you choose, and why is medium the starting point?

In Claude Code the effort starts at medium, and for Fable 5.2 that is a good starting point. The announcement says so: at medium the model completes demanding tasks with fewer tokens than Fable 5.1. The default in the apps and in Claude Code is therefore an efficiency choice by Anthropic, not a stopgap.

The five levels are low, medium, high, xhigh and max. The official documentation gives this hierarchy for the API, where the default is high: most of the capability gain is already there at high; xhigh is for the hardest and longest coding and agentic work, where you have measured an improvement; max should be reserved for those who want to measure the model's ceiling or have a rare task where time and tokens do not matter.

Translated for Claude Code: start at medium, move up to high if the result is weak, and use xhigh only with a hard task and a way to check that it is needed. The details on the levels are in our article on Fable 5.2 reasoning levels.

Reasoning cannot be switched off Fable 5.2 uses adaptive thinking only. According to the documentation, a line such as “answer directly without reasoning” does not stop it from medium effort upwards, and from high upwards the model reasons before almost every answer. If easy requests cost too much or are slow, the lever is a lower effort for those turns, not an instruction in the prompt.

Fable 5.2 fast mode in Claude Code: when does it make sense?

Fast mode makes sense when you are in front of the screen waiting for the text, not when you leave a long session running. Anthropic's announcement says it speeds up generation by up to 2.5 times and that for Fable 5.2 and Mythos 5.2 it is available in Claude Code, on the Claude Platform, on Google Cloud and on Microsoft Foundry.

In the API the price is doubled: $16 per million input tokens and $80 per million output tokens, against $8 and $40 in normal mode, according to the official pricing table. The activation command in Claude Code and the plan conditions are not stated in the official pages accessed on 9 November 2026: before counting on it, check the Claude Code documentation. To reason about the speed-versus-cost trade-off, what we wrote for the previous model applies, in Opus 5.5 fast mode: you pay for the time of a person who is waiting, not for a process that works on its own.

An illustrative example: on the same day you make twenty small interactive requests and run one migration that works autonomously for an hour. Fast mode is useful on the first twenty, where every wait adds up. On the migration it doubles the cost without shortening the time you care about.

Why do subagents push up the cost with Fable 5.2?

Because each subagent is a conversation of its own, with its own tokens, and Fable 5.2 delegates readily when the environment suggests it. The what's-new page says so plainly: in a coding product whose prompts encourage delegation the model delegates easily, and subagents can account for a large share of what a session costs.

The announcement tells the opposite extreme: an Anthropic engineer gave Fable 5.2 the task of designing a prototype operating system. The model coordinated over 1,000 subagents for eight days, writing, testing and reviewing code, and produced a system that boots on a laptop. It is an internal experiment, not a typical use, but it shows that delegation can grow without limit if nobody contains it.

Three habits keep it under control:

  1. Say when to delegate. In the prompt or in the repository's instruction file, write which jobs subagents are allowed for (audits of many services, independent research) and which not (a change to a single file).
  2. One subagent, one part. Each subagent works on a service or folder of its own, never two on the same file, and reports verifiable evidence: file and line, test output.
  3. Check consumption after the first session. If the cost is a surprise, the most likely cause is delegation, not the length of the code.

The stop rules, the file checklist and the structure of the final report are the same as those described for Opus in Claude Opus 5.5 in Claude Code, and they work here too.

How do you stop Fable 5.2 from stopping before it finishes?

By asking for the whole task with a finish line that can be verified. Among the known behaviors, the official documentation notes that on long multi-step tasks the model sometimes ends its turn with a list of what remains, an offer to continue, or a stop at an ordinary obstacle, and that this happens more often at low and medium effort. Since Claude Code starts at medium, the problem is real.

Two fixes, both at no cost:

  • Define “done”. “Every endpoint uses the new client, the old one is removed, the tests pass” is a finish line. “Fix the module” is not.
  • Distinguish real obstacles from ordinary ones. Write that the model should stop only if it cannot continue without you or before a destructive action, such as deleting data or force-pushing.

If turns still get interrupted, go up one effort level for that task. The full picture of the known limitations, with countermeasures, is in Fable 5.2 known limitations and how to work around them.

What should you put in the repository instructions for Fable 5.2?

Three things that the official documentation links to observed behaviors, plus one of method.

  • Who owns the code. In Anthropic's tests on small tasks, when the prompt did not say who owned the code, the model tended to add to the existing structure and to flag nearby problems instead of fixing them. If you want it to fix what it finds, say so.
  • Updates during long turns. Long sequences of tool calls can run with little text, and the first call can start without any explanation. Ask for a status line before each block of work.
  • Simple style rules. The model follows them literally: a hard limit on sentence length can make the prose choppy.
  • Permissions on destructive actions. They stay active: the rule decides when the model asks, it does not take its brakes off. To assess commands before they run, there is Blast Radius; for automatic checks tied to session events, see the Claude Code hooks guide.

For a collection of ready-made phrasings, see how to write prompts for Fable 5.2.

What changes in the API with Fable 5.2 if I use Claude Code?

Practically nothing. The what's-new page lists four changes from Fable 5.1 that can break code: edited earlier turns return a 400 error on every account, Fable 5.2's thinking blocks can be read only by Fable 5.2 and Mythos 5.2, the old computer_20251124 returns a 400 error outside Amazon Bedrock, and the advisor of a Fable 5.2 executor must be Fable 5.2 or Mythos 5.2. Forcing tool_choice and disabling thinking return a 400 error, but they are not new for anyone coming from Fable 5.1 or Opus 5.5. On edited turns the page adds that nothing changes for you if the requests are built by Claude Code, claude.ai, Claude Managed Agents or the Claude Agent SDK.

It is different if you have written a script that calls the API directly to automate something around the repository: there the constraints matter. Our article on the migration to Fable 5.2explains them. Compaction on demand, which lets you choose when to replace old turns with a summary, is a beta API feature: in the pages accessed it is not described as a Claude Code command.

Two cases to see whether it is worth it

Example: a freelance developer who maintains management systems. They have a warehouse management system written years ago for a client, with an orders module that nobody wants to touch. Ordinary changes (a new field, a new filter) they make with Opus 5.5 at medium effort. When they have to migrate the module to a new framework version, with dozens of files and fragile tests, they first try Opus 5.5 at high effort. If it stops or gets it wrong, they repeat the same task with Fable 5.2 at high, with a written finish line (“tests green, no direct queries left”) and a ban on delegating to subagents without asking. Then they compare time, cost and manual corrections across both runs.

Example: a small software house with a service to analyze. It has to check ten services for the same defect. Delegation makes sense: one subagent per service, and a final table with service, outcome and evidence. The risk is cost, because subagents weigh on it. It is better to do a first run on two services, read the consumption and only then extend. If you need to set up these workflows for your team, part of the work of a software house is precisely to define rules, checks and spending limits.

An order-of-magnitude calculation, given as an example: a session that consumes 2 million input tokens and 200,000 output tokens costs, at Fable 5.2's official prices ($8 and $40 per million), 16 + 8 = $24, whereas with Opus 5.5 ($4 and $20) it would be 8 + 4 = $12, not counting caching and discounts. The ratio is the point: Fable 5.2 has to save you more than double in time or corrections to pay for itself. For costs in detail, see our article on API pricing.

What if I use Claude Code with a subscription rather than the API?

Then the cost is not measured in dollars per token but in the plan's usage limits, and the calculation changes. For the launch, the Anthropic support page describes temporary offers on eligible plans, with resets of the limits dedicated to Fable models. Conditions, excluded plans and dates are in the article on Fable 5.2 on Pro, Max and Team. Availability of Fable 5.2 on each plan, in particular the Free plan, is not stated in the pages accessed.

Which mistakes should you avoid with Fable 5.2 in Claude Code?

  • Using it for everything. For ordinary tasks Anthropic recommends Opus 5.5: Fable costs twice as much per token.
  • Jumping straight to max. The documentation reserves it for those measuring the model's ceiling. Start at medium or high.
  • Trying to switch off reasoning in the prompt. It does not work from medium upwards: lower the effort.
  • Leaving subagents without rules. It is the quickest way to get an unexpected bill.
  • Trusting “I'm done” on a long task. Verify with the tests and with the finish line you wrote.
  • Taking the benchmarks for granted. They are declared by Anthropic: the real test is your repository.

How to introduce Fable 5.2 into your workflow

A four-step method, with no commands that the official pages do not describe:

  1. Pick 5-10 real tasks already done, with a known outcome: a migration, a hard bug, a review.
  2. Run them with Opus 5.5 and note time, cost and manual corrections.
  3. Repeat them with Fable 5.2, at medium and then high effort, with the same instructions and the same finish line.
  4. Decide by task category, not by model: Opus where it is enough, Fable where the difference is measurable.

For a broader view of where Claude fits in software development, see Claude for the code.

The practical takeaway

Fable 5.2 in Claude Code is a tool to keep for the tasks that other models do not close: medium effort at the start, high or xhigh when needed, subagents with rules, verifiable finish lines. For everyday work, Anthropic's advice to start with Opus 5.5 still stands. Always check the official pages: model names, prices and behaviors change.

If you maintain management systems or software for clients and want to set up rules, tests and spending limits so that AI writes code safely, Giallo Studio develops custom-made software with verification processes already in place.

Giallo Studio guides: methodology and sources

Want to apply this to your business?In 30 minutes, free of charge: the first process to automate and its estimated return, in writing.

Book the free audit

How we apply it in the company

Related resources

AI consulting services and process automation

FAQ

Is it worth using Fable 5.2 in Claude Code instead of Opus 5.5?

Usually not, as an everyday model. In its announcement of 9 November 2026, Anthropic recommends starting with Opus 5.5 for most coding tasks and moving up to Fable only for the most ambitious work. Fable 5.2 costs twice as much per token ($8 and $40 vs $4 and $20), so you pick it when a hard task will not close with Opus.

Which effort level does Fable 5.2 use in Claude Code?

Medium, according to Anthropic's announcement: it is the default level in the Claude apps and in Claude Code. In the API, the default is high instead. Five levels are available: low, medium, high, xhigh and max.

Is fast mode available for Fable 5.2 in Claude Code?

Yes. The official announcement lists Claude Code among the platforms with fast mode. It generates tokens up to 2.5 times faster and, in the API, costs $16 per million input tokens and $80 per million output tokens. The activation command and plan conditions are not stated in the pages accessed on 9 November 2026: check the Claude Code documentation.

Why does a session with many subagents cost so much?

Because each subagent consumes tokens of its own. The official documentation warns that, in a coding product whose prompts encourage delegation, Fable 5.2 delegates readily and subagents can account for a large share of a session's cost. It pays to say in the prompt when to delegate and when not to.

Why does Fable 5.2 sometimes stop before it has finished?

It is a known limitation: on long multi-step tasks the model may end its turn with a list of what remains, an offer to continue, or a stop at an ordinary obstacle. It happens more often at low and medium effort. You reduce it by asking for the whole task with a verifiable finish line, or by raising the effort.

Can I turn off reasoning in Fable 5.2 to save money?

No. Adaptive thinking is the model's only mode, and a line such as “answer without reasoning” does not stop it from medium effort upwards. For easy requests, lower the effort, or use a smaller model.

Do the Fable 5.2 API changes break my Claude Code?

According to the official documentation, nothing changes if Claude Code builds the requests: 400 errors and constraints on thinking blocks concern those who write code that calls the API directly. If you do that too, you need the migration guide.

Put it into practice

Let's turn this guide into your first live workflow.

Tell us what process you want to lighten: we evaluate feasibility, return and first operational step.