Claude Fable 5.2 vs Fable 5.1 vs Opus 5.5: when to use each

Anthropic released Claude Fable 5.2 on November 9, 2026. It replaces Fable 5.1 as the most capable Claude model anyone can sign up for, and it costs 20% less per token. Anthropic still recommends Opus 5.5 for most work.

So there are now three models a team might reasonably be running for hard tasks, and the newest one is not automatically the right choice. This post goes through price, benchmarks and cost per task, then says which model suits which job. The figures come from Anthropic's announcement, the Fable 5.2 documentation and Artificial Analysis.

Price and limits

All three have a 1M token context window and allow 128k output tokens per request, so context size does not help you choose between them. Anthropic says Fable 5.2 writes output up to 30% faster than Fable 5.1. There is also a fast mode for Fable 5.2 at $16 / $80 per million tokens, which Anthropic says is up to 2.5 times faster.

Benchmarks

These are Anthropic's published scores. Unless the label says otherwise, each model was run at its highest effort level. The Fable 5.2 score on the Remote Labor Index is at high effort.

Fable 5.2 is ahead of Opus 5.5 on all six. The gap is small on computer use (2.1 points) and large on the Remote Labor Index, where its score is nearly double. Fable 5.1 is behind Opus 5.5 on every one of these, which was already true in September.

Opus 5.5 does come out ahead on one measure in Anthropic's table. On the AA-Briefcase knowledge work benchmark its Elo rating is 1800 against 1785 for Fable 5.2, although Fable 5.2 has the higher rubric score on the same benchmark (66.1% against 61.2%).

Cost per task

A lower price per token does not mean a lower bill. Artificial Analysis runs every model through the same set of tasks for its Intelligence Index and reports the score, the average cost per task and the time taken. These are independent figures, on version 5.0.1 of the index. The index has been revised since September, so the scores do not match the ones in our Opus 5.5 comparison.

Three things stand out in this table.

• At max effort, Fable 5.2 costs about twice as much per task as Fable 5.1 ($26.54 against $12.99), even though each token is cheaper. It wrote 275M output tokens across the index, where Fable 5.1 wrote 163M.
• Fable 5.2 at medium effort scores 56 for $3.80 a task. Opus 5.5 needs xhigh effort to reach 57, and that costs $6.05. On this index, turning Fable down is cheaper than turning Opus up.
• Fable 5.2 scores 62 at both high and xhigh. The extra $5.75 a task for xhigh bought nothing here, which fits Anthropic's advice to start at high and only go higher where you have measured a gain.

Anthropic reports the same pattern on its own tests. On FrontierCode, Fable 5.2 at high effort scored 45.3%, about level with the best Opus 5.5 result of 45.5%, at roughly half the cost per task.

When to use each

Opus 5.5is still the default. Anthropic's model guide says most workloads should start there, and to move to Fable 5.2 only when your own tests on Opus 5.5 at xhigh or max effort still fall short. Changing the effort level is a smaller change than changing the model, so try that first.

Fable 5.2 is for work you hand over and expect back finished: a long agent run, a research task with many steps, an analysis that ends as a document or a spreadsheet. If the task takes a person a few minutes, Fable is more than you need. Two limits are worth knowing before you move a workload to it. It requires 30-day data retention, and it runs safety classifiers for cybersecurity and biology that can refuse a request. Anthropic says Fable 5.2 blocks about 55% fewer requests than Fable 5.1 did, and a refused request can fall back to an older Opus model.

Fable 5.1 has no job that Fable 5.2 does not do better for less per token. It remains available on the API, with retirement no sooner than September 1, 2027, so there is no rush. The reason to stay on it for now is the migration work below.

Moving from Fable 5.1 to Fable 5.2

For many integrations this is a model ID change. The migration guide lists four changes that can break code:

• Editing conversation history returns an error. If a request sends back a thinking block after the system prompt, the tools or an earlier message has changed, the API returns a 400. On Fable 5.1 this only applied to accounts created on or after August 31, 2026. On Fable 5.2 it applies to every account.
• Thinking blocks stay with Fable 5.2. Only Fable 5.2 and Mythos 5.2 can read them. If a router moves a conversation to Opus 5.5 or back to Fable 5.1, the request succeeds but the earlier reasoning is dropped.
• The old computer use tool is rejected. computer_20251124 returns a 400 everywhere except Amazon Bedrock. Declare computer_toolset_20260801 instead.
• The advisor tool needs a matching advisor. A Fable 5.2 executor only accepts Fable 5.2 or Mythos 5.2 as its advisor. A Fable 5.1 advisor returns a 400.

One behaviour change returns no error. At high effort Fable 5.2 thinks before almost every reply, and a prompt line such as "answer directly" no longer stops it. If simple requests have become slow or expensive, lower the effort for those requests.

If your app calls Claude through the API

If you use Claude in the desktop app or in Claude Code, you pick the model from the menu and the sections above are all you need. This last part is for teams whose own product calls Claude from its backend, such as a support assistant or an agent feature.

In that case the model is a setting in your code, and changing it affects every customer at once. The tables above are averages over someone else's tasks, so they will not tell you what a model costs on yours. One way to find out is to put the model ID and the effort level behind a feature flag and send a share of accounts to the new one.

import Featureflow from 'featureflow-node-sdk';

const featureflow = new Featureflow.Client({
  apiKey: process.env.FEATUREFLOW_SERVER_KEY,
});

const MODELS = {
  'opus-xhigh': { model: 'claude-opus-5-5', effort: 'xhigh' },
  'fable-medium': { model: 'claude-fable-5-2', effort: 'medium' },
  'fable-high': { model: 'claude-fable-5-2', effort: 'high' },
};

// Bucket by account so a conversation stays on one model
const user = new Featureflow.UserBuilder(accountId)
  .withAttribute('plan', account.plan)
  .build();

const variant = featureflow.evaluate('agent-model', user).value();
const { model, effort } = MODELS[variant] ?? MODELS['opus-xhigh'];

// Record the outcome you care about for each variant
featureflow.track('task-completed', user);

Bucketing by account matters because Fable 5.2 thinking blocks do not carry over to other models, so a conversation that switches halfway loses its earlier reasoning. Compare cost per completed task across the variants, since that is the number the per-token price hides. If the new model misbehaves, change the flag and requests go back to the old one without a deploy. The LLM rollouts post covers the setup in more detail, and the SDK is documented at docs.featureflow.io.

#ClaudeFable#ClaudeOpus#LLMOps#AICoding#FeatureFlags