# How to get the most out of Fable 5.2 and Opus 5.5 in November 2026

> Opus 5.5 or Fable 5.2: which model to start with, how much effort to give it, and when to switch, with Anthropic’s benchmarks and prompt cache costs.

- URL: https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/
- Author: Danilo Giudice
- Published: 2026-11-11

![Danilo, with the parrot on his shoulder and a lit light bulb above his head, writes on the blackboard: Opus 5.5, start here; the effort dial on medium; then Fable 5.2](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/01-apertura-lavagna.jpg)

For every task you have to choose two things: the model and its effort. Addy Osmani explains how in his post [“Which Claude model should you build with?”](https://claude.dev/blog/which-claude-model-should-you-build-with/), from November 9, 2026. Here’s an example from the post:

Per token, Fable 5.2 costs twice as much as Opus 5.5 (a token is a small piece of the text that goes into and comes out of the model). Yet on FrontierCode 2.0, a set of tests that is the same for every model (a benchmark), Fable 5.2 at high effort scored 45.3% and Opus 5.5 at max scored 45.5%, with Fable at about half the cost per task.

**The spoiler:** if you make it to the end, you’ll know which model to start with for each job, and in what order to raise effort and model when the result isn’t good enough. And you’ll take home a file ready to copy, which has Haiku 5.5 read the logs instead of the expensive model.

I work with Claude Code every day, and I’ve found that the best compromise, for almost everything, is Opus 5.5 at medium. Handing the execution to Sonnet 5.5, though, saves tokens and speeds up the work: Sonnet 5.5 costs half as much as Opus 5.5 per token and is 30% faster than Sonnet 5. I use Fable 5.2 for the hardest jobs, at medium (I’ll show you why later on).

A note on sources: the post calls these models “ours,” so I cross-checked prices and limits against the Claude API reference, and the benchmarks are still Anthropic’s.

## Start with Opus 5.5, at medium effort

Let’s get to the point. The model to start with is Opus 5.5, with effort at medium: it’s the Claude Code default, and per token it costs half as much as Fable 5.2.

> **Effort** is the parameter that sets how much work the model does before it returns the answer: how many thinking tokens it generates (the intermediate text before the answer, which Anthropic calls reasoning), how many tool calls it makes, and how many checks it runs. There are five levels: low, medium, high, xhigh, and max.

In practice, it’s a dial between speed and accuracy. The higher you turn it, the more work the model does, and the more you pay in tokens and in waiting time. At low it makes fewer tool calls and gives shorter answers; at high it makes more of them and checks its own work more.

Keep this in mind, because the higher the effort, the longer you wait: with a lot of thinking, the execution comes only after it. On some tasks you don’t need that thinking, and it’s just a waste of tokens and time.

## The four models and their prices

All four work with a context (everything the model receives in one request) of up to 1 million tokens. Each response, on the other hand, can be at most 128,000 tokens long, thinking included: about an eighth of the context. They differ in price and speed.

![Fable 5.2 is twice the price of Opus 5.5: output prices per million tokens, $40 for Fable 5.2, $20 for Opus 5.5, $10 for Sonnet 5.5, $0.50 for Haiku 5.5](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/02-prezzi.jpg)

| Model | What for | Default effort (API) |
|---|---|---|
| Fable 5.2 | The hardest, most open-ended technical work: code, finance, science | high (medium in Claude Code) |
| Opus 5.5 | Complex code and document work, every day | medium |
| Sonnet 5.5 | Well-defined tasks, 30% faster than Sonnet 5 | high (medium in Claude Code) |
| Haiku 5.5 | Volume, with the lowest cost and wait time | medium |

> 💡 Pro tip: **Haiku 5.5 is the only one with tiered pricing.** Above 100,000 prompt tokens you pay 5 times the low rate, which is still a quarter of the price of Sonnet 5.5. If every call has a long prompt, compare the two on the cost per finished task, not on the price list.
>
> Fast mode (from the API reference, not from the post) generates up to 2.5 times more tokens per second with the same model, at double the rate: $8 / $40 on Opus 5.5, $16 / $80 on Fable 5.2. It has a rate limit of its own, it isn’t available with the Batch API, and switching speed invalidates the cache.

| | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 | Fable 5.2 |
|---|---|---|---|---|
| Cache read, per million tokens | $0.01 up to 100,000 tokens, $0.05 above | $0.10 | $0.20 | $0.20 |
| Thinking on the API | on, can be turned off | on; `between_tools` skips the initial thinking | always on | always on |
| Fast mode | no | no | yes | yes |

Claude Mythos 5.2, for cybersecurity and life sciences research, is only available through Anthropic’s verification programs, so it’s not part of this comparison.

## Which model for which task

How do you choose the model? I look at two things: how hard the task is and how much a mistake costs. If the task is well written and a mistake shows up right away (a failing test, a wrong label), a small model is enough. If the task needs judgment, or the work is long and open-ended, you move up. The table below, taken from the post, puts this into practice, and two of its rows are about subagents.

> **Subagent**: a separate instance of the agent, with its own context. The main agent hands it a task and gets back only the result.

It’s like asking a coworker to “find this file for me”: they do the search, you get only the answer, and your context stays clean.

| Task | Model | Starting effort |
|---|---|---|
| Everyday coding and debugging, large features delivered in stages | Opus 5.5 | medium, then high |
| Computer use (the model drives the mouse and keyboard) and image-heavy workflows | Opus 5.5 | medium |
| You don’t know where to start yet | Opus 5.5 | medium |
| Major code rewrites and migrations, architecture, coordinating many subagents | Fable 5.2 | medium, then high |
| Deep research, scientific and quantitative analysis | Fable 5.2 | medium, then high |
| Opus 5.5 at high isn’t enough, or long unsupervised sessions | Fable 5.2 | medium, then high |
| Bug fixes, features built from a spec | Sonnet 5.5 | medium, then high |
| Documents, slides, and spreadsheets | Sonnet 5.5 | high (medium in Claude Code) |
| Agents that repeat the same job: investigations, reviews, drafts | Sonnet 5.5 | medium |
| Chat and interactive sessions | Sonnet 5.5 | low or medium |
| High-volume classification, routing, and extraction | Haiku 5.5 | medium |
| Subagents that search files, read logs, summarize | Haiku 5.5 or Sonnet 5.5 | the default |

When in doubt, Opus 5.5 at medium.

One warning from the post: a migration or a performance optimization can have a very clear spec and still need Opus 5.5, or Fable 5.2 for a major one. The same goes for a complex financial model or a document built on many sources: there you start with Opus 5.5, not Sonnet.

## Effort first, then the model

Raising the effort helps on hard tasks, which need more steps and more checks. It costs time and tokens, and it doesn’t give the model knowledge or abilities it doesn’t have.

How much does each level cost? For Opus 5.5 on SWE-bench Pro, a coding benchmark, the post gives these numbers, with high as the baseline.

![From high to xhigh, 2.5 times the cost: Opus 5.5 on SWE-bench Pro, cost per task with high at 100; low 33, medium 70, xhigh 250](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/03-effort.jpg)

Going from high to xhigh, you pay 2.5 times as much for 1.4 points. Compared with high, low loses about 8 points and medium about 2.5, and medium costs 30% less: that’s why it’s the starting point.

**RULE:** before you switch models, raise the effort by one level. Past high, though, try the next model up at a lower effort, because one more level can cost as much as a bigger model.

> 💡 Pro tip: **In Claude Code you can see the effort with `/effort status`; on the API it goes inside `output_config`, not at the top level of the request.** The API default is medium on Opus 5.5 and high on Fable 5.2: always set it by hand, so a change in the default doesn’t catch you off guard. On Opus 5.5 and Fable 5.2 thinking can’t be turned off, and `temperature`, `top_p`, and `top_k` return a 400 error: effort is the only lever.
>
> For Fable 5.2, the API reference recommends starting at high, because above it the gains are uneven. Changing the effort in the middle of a conversation invalidates the message cache; on Opus 5.5 and Fable 5.2 there’s per-message effort (beta `mid-conversation-output-config-2026-07-01`, with thinking on), which leaves the cache intact.

```json
{
  "model": "claude-opus-5-5",
  "max_tokens": 16000,
  "output_config": { "effort": "high" },
  "messages": [{ "role": "user", "content": "…" }]
}
```

## The biggest model at max doesn’t always win

Many people find this assumption reasonable: “the most capable model costs more, but at least the result is the best, so I’ll set it to max and stop worrying about it.” In reality, it’s a trap.

In the end, what you pay is the cost per finished task. The price per token is like the price of gas per gallon: what matters is how much you spend to get there, and that also depends on how many gallons you burn.

| Benchmark | Comparison | Score | Cost |
|---|---|---|---|
| Chartography | Fable 5.2 at medium vs. Opus 5.5 at max | 66.4% vs. 64.4% | less than a tenth per task |
| FrontierCode 2.0 | Fable 5.2 at high vs. Opus 5.5 at max | 45.3% vs. 45.5% | about half per task |
| Terminal-Bench 3.0 | Opus 5.5 at high vs. Fable 5.1 at max | 58.9% vs. 58.0% | half the tokens |

The result? On FrontierCode 2.0, Fable 5.2 at high ties Opus 5.5 at max, at about half the price. On Terminal-Bench 3.0 it goes the other way: Opus 5.5 at high narrowly beats Fable 5.1 at max, with half the tokens. I’ll be honest: these numbers come from the people who sell the models, and the Terminal-Bench comparison is about Fable 5.1, not 5.2 (the post takes it from [“Spending your effort”](https://claude.dev/blog/spending-your-effort/), on the same blog). In both cases, the max level costs more and doesn’t give a better score.

For Fable 5.2, the best compromise is medium, according to the benchmarks in the [Fable 5.2 launch](https://www.anthropic.com/claude-fable-and-mythos-5-2) (Anthropic, November 9, 2026). On Chartography, Fable 5.2 at medium scores 66.4%, against 64.4% for Opus 5.5 at max, at less than a tenth of the cost per task. On WANDR, again at medium, it matches the best score of Opus 5.5 with about 40% of the spend. So Fable 5.2 at medium uses far less than Opus 5.5 at max, with an equal or better result.

![Fable at medium beats Opus at max: on Chartography, Fable 5.2 at medium scores 66.4% and Opus 5.5 at max 64.4%, at less than a tenth of the cost per task](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/04-chartography.jpg)

When you do the math, include the hardest tasks too, because they’re the ones that cost the most. On a 20-problem research benchmark, two problems, that is 10%, accounted for 43% of the spend.

**Opus 5.5 for everyday work**

- Start at medium and move up to high for large features and hard bugs.
- Always give it a way to check its own work, for example a test it has to pass.
- For computer use and image-heavy workflows, it’s the starting point, at medium.
- Thinking can’t be turned off: to spend less, lower the effort.
- If you need speed, the API has [fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode): the same model generates faster, at double the rate ($8 / $40 per million tokens).

**Fable 5.2 for the hardest jobs**

- Save it for jobs where Opus 5.5 at high isn’t enough and for long unsupervised sessions: large migrations, architecture, research, and quantitative analysis.
- Effort: I start at medium, which is already the default in Claude Code (on the API the default is high). Go higher only where you’ve measured a gain.
- Give it the whole task at the start, and expect a single request to take many minutes: have the response sent in pieces as it’s generated (streaming), and show whoever is waiting that the work is moving forward.
- Don’t edit messages you’ve already sent: if you change anything before a thinking block, the API returns a 400 error (this is [preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking)).
- It generates output up to 30% faster than Fable 5.1. And if it coordinates other agents, put cheaper subagents under it (we’ll get to that shortly).

> 💡 Pro tip: **Fable 5.2 requires 30-day data retention.** Without approval from Anthropic, it doesn’t work with zero data retention: for organizations that don’t meet the requirement, the API returns a 400 error. No prefill of the last turn, no forced `tool_choice`, and no `temperature`, `top_p`, or `top_k`.
>
> You never get the full thinking text: with `display: "summarized"` you receive a summary; otherwise the field comes back empty. With the advisor tool, a Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as its advisor. Fast mode costs $16 / $80 per million tokens, in direct API requests and not in Managed Agents.

## When it’s not enough, change one thing at a time

> 💡 Pro tip: **When a model can’t handle a task, I turn the dials in this order, one at a time.** First: I check that it has a way to verify its own work, with a test, a build, or a script that actually exercises the service (the problem is often here, not in the model). Second: I raise the effort by one level. Third: I move to the next model up, starting at a lower effort than I was using, so from Opus 5.5 at high I go to Fable 5.2 at medium.
>
> **And if the outcome can be checked automatically, I run everything at low and rerun only the failed tasks at high.** You need an automatic check that tells you which tasks to rerun.

![Everything at low, failed tasks at high: Opus 5.5 on a subset of SWE-bench Pro passes about 97% of tasks at $0.17 each, against 95.3% at $0.29 with everything at high](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/05-low-high.jpg)

## Context costs money, even in the cache

Every turn of a conversation sends the whole context back to the model. So in long sessions, [most of the input is billed as cache reads](https://claude.com/blog/claude-opus-5-5-built-for-coding-sessions-that-use-more-context).

> **Prompt cache**: the opening part of the request, identical to the one in previous turns, which the service keeps aside and bills at a reduced rate. Reading from it is called a cache read.

On Opus 5.5 and Fable 5.2, a cache read costs $0.20 per million tokens. A turn with 20,000 cached tokens costs about $0.004, and one with 150,000 about $0.03: 7.5 times as much. A hundred turns come to about $0.40 versus about $3.

Fable 5.2 and Opus 5.5 have the same cache read rate. In a session that’s mostly cache, the difference between the two is in the uncached input and in the output, where Fable costs twice as much.

**What it costs to resume after an hour**

In my Claude Code setup, the cache lasts an hour. If I resume a job after that, the first request writes the whole context to the cache again, and on the API a cache write that lasts an hour costs twice the normal input price: on Opus 5.5 that’s 40 times a cache read. With 150,000 tokens of context, you go from about $0.03 to about $1.20, just to start again.

![Resuming after an hour rewrites the cache: with 150,000 tokens on Opus 5.5, you go from about $0.03 to about $1.20, 40 times as much](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/06-cache.jpg)

That’s why I added a cache indicator to the Claude Code status line in my Warp terminal. While the cache is warm, it shows how many minutes it has left (`cache 48m`, in yellow when it’s about to expire); once it’s frozen, it shows a snowflake and the tokens the next request will have to write again (`cache ❄ +150k`). That way I know what resuming a job will cost me before I even type the first message.

In practice: keep the expensive model’s context for decisions, and have subagents do the long reading of files and logs. I wrote about how much the Claude Code context weighs in [“Claude Code hygiene”](https://stocasticparrot.ai/en/explainers/claude-code-hygiene/).

> 💡 Pro tip: **The cache is tied to the model that wrote it: switch models only between one job and the next.** If you switch halfway through, the new model starts over without a cache. In Claude Code the post suggests `/compact` before the switch; I prefer a HANDOFF.md and a `/clear`, and I explained why in [“Auto-compaction is a colossal piece of crap”](https://stocasticparrot.ai/en/explainers/auto-compaction/). On the API, open the new model’s conversation with a summary of the work done so far.

## Mixing models: when it pays off and when it doesn’t

The post describes three cases, and only mass delegation has measured savings. Let’s go through them piece by piece, and at the end I’ll tell you how I do it.

**Small subagents for work you can check at a glance**

Searching files, running tests, reading logs: if a mistake shows up right away, Haiku 5.5 or Sonnet 5.5 is enough. Code changes and the decisions that matter stay with the main model. How to define subagents is in the [Claude Code documentation](https://code.claude.com/docs/en/sub-agents).

> 💡 Pro tip: **The file for a subagent on Haiku 5.5: save it as `.claude/agents/log-reader.md`.** It’s the example from the post: it reads the logs and reports the failing cases, without touching any files. `CLAUDE_CODE_SUBAGENT_MODEL` sets the model for subagents that don’t declare one, and `ANTHROPIC_DEFAULT_HAIKU_MODEL` pins the model behind the `haiku` alias.
>
> The built-in Explore subagent uses the session’s model, capped at Opus on the API: to explore on a budget, define your own `Explore` with `model: haiku`. On the Anthropic API, the `haiku` alias points to Haiku 5.5 from Claude Code 2.1.293 onward; on Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS, it still points to Haiku 4.5.

`.claude/agents/log-reader.md`:
```
---
name: log-reader
description: Reads test output and logs, and reports each failing case. Use after a test run.
tools: Read, Grep, Glob, Bash
model: haiku
---

Read the logs you're given. For each failure, report the file, the test name and the first error line. Don't edit any files.
```

**Mass delegation, if the work can be split**

![An Opus 5.5 coordinating 25 Sonnet 5.5 agents spends a third less than Opus 5.5 alone, with the same score, when searching for defects in about 22 million tokens of code](https://stocasticparrot.ai/en/numbers/fable-5-2-opus-5-5/img/07-delega.jpg)

The benchmark is internal: searching for defects in about 22 million tokens of code, 22 times a model’s maximum context, with the same score as Opus 5.5 alone. It doesn’t apply to steps that depend on each other, or to work that fits in a single context. The tool the post uses is the [multiagent orchestration](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration) in Claude Managed Agents.

**opusplan and advisor: measure first**

In Claude Code, [`opusplan`](https://code.claude.com/docs/en/model-config) has Opus do the planning and Sonnet write the code, which is the opposite of what I described above: try it on your own tasks before you make it your default. The [advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool) (in beta) pairs a cheap executor with a stronger advisor, and you pay for almost all the tokens at the executor’s rate. [Anthropic’s cost guide](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence), though, admits that no pair clearly beat the executor on its own.

> 💡 Pro tip: **An advisor example from the post: Opus 5.5 at high as the executor, Fable 5.1 as the advisor.** 90.1% at $2.92 per attempt: 1.7 points above Opus 5.5 alone at high, for about 2.1 times the spend. A Sonnet 5.5 executor accepts Fable 5.2, Opus 5.5, Opus 5, and Sonnet 5.5 as advisors, and the advisor has to be at least as capable as the executor, or the API returns a 400 error.

> 💡 Pro tip: **Bigger models can read the thinking blocks of smaller ones, but not the other way around.** This matters when you switch models in the same conversation, on Claude API and Claude Models on Google Cloud: Opus 5.5 reads those of Sonnet 5.5 and Haiku 5.5, Sonnet 5.5 reads those of Haiku 5.5, and Fable 5.2 reads those of all three. If you move from Fable 5.2 to another model, its thinking blocks are lost; when a model can’t read them, the API drops them and the request goes through anyway.

**How I do it: octopus**

For long jobs in Claude Code I use [octopus](https://stocasticparrot.ai/en/toolbox/octopus/), a Claude Code command I built that splits the work across three models. Opus 5.5 plans and decides. Sonnet 5.5 builds, runs the tests, puts the pieces back together, and reviews the work with a clean context. Haiku 5.5 runs the mechanical subtasks, and when a subtask is harder, the same executor starts again on Sonnet 5.5.

The post recommends keeping code changes on the main model. I delegate them, but only when Opus 5.5 has already planned them, with the files to touch and the verification criteria written down, and with a reviewer that checks the result.

One last thing. If the routing rule is simple, for example one model for each type of step, let your code pick the model rather than asking another model to.

## Before you migrate, six things to check

If you move code written for the previous models onto these ones, some requests that used to go through now return an error.

- **Fable 5.2, preserved thinking.** A 400 error if anything changes before a thinking block (system prompt, tools, earlier messages), unless you ask for it to be dropped. Keep the history append-only: add to it, don’t rewrite it.
- **Opus 5.5 and Fable 5.2, thinking.** An error if you try to turn it off: adjust the effort instead. Sonnet 5.5 has thinking on by default; on Haiku 5.5 you can turn it off, but only at high effort or lower. Read the response blocks by `type`.
- **Sonnet 5.5, Opus 5.5, and Fable 5.2, `tool_choice`.** A 400 error with `any` or `tool`: use `auto` and tools with `strict: true`, and write in the prompt when to use them.
- **All four, computer use.** It only works with `computer_toolset_20260801`, on Claude API and Claude Models on Google Cloud: update the tool.
- **From Haiku 4.5 to Haiku 5.5.** A 400 error with non-default `temperature`, `top_p`, or `top_k`, or with a final assistant message, and `budget_tokens` is gone: switch to an effort level, remove those parameters, and end `messages` with a user turn.
- **The safety classifiers.** They mostly flag requests about cybersecurity and biology. In Claude Code, a flagged request can be retried on an older model, with a warning: Opus 4.8 for cybersecurity, Opus 5 for biology. Build every request for the strictest model, and plan for the fallback.

> 💡 Pro tip: **Always check `stop_reason` before you read `content`.** The classifiers can refuse a request with HTTP 200 and `stop_reason: "refusal"`. On Opus 5.5, Fable 5.2, and Sonnet 5.5, the API reference recommends turning on server-side fallback by default, with the beta header `anthropic-beta: server-side-fallback-2026-07-01` and the parameter `"fallbacks": "default"`, which picks the backup model based on the type of refusal. On Amazon Bedrock, Vertex, and Foundry there’s no server-side fallback, and you need the SDKs’ client-side middleware: before you go to production, check the exact names in the documentation.

## Measure on your own work

Benchmarks tell you where to start. You make the final choice by measuring on your own tasks, with the post’s four-step method:

1. **Take a sample of real tasks** and write an outcome check for each one: a passing test, a closed ticket, a correct row count.
2. **Run each candidate at two or three effort levels**, each in its own session, and record the cost per task from the `usage` field of each response.
3. **Plot score against spend.** Keep a multi-model setup only if it beats every single-model point.
4. **Run the winner in shadow** on a slice of real traffic before you switch everything over.

If you have five minutes right now: take a task from your list, run it on two models with `/model`, and compare what `/usage` reports.

## The moral

So? The moral? Start with Opus 5.5 at medium, hand the execution to the smaller models, and move to Fable 5.2, at medium, when Opus isn’t enough. The end.

## Sources

The benchmarks come from the post and from Anthropic’s launch, that is, from the people who sell the models, and I haven’t verified them independently. The hundred turns, the 10% of the problems, and the cost of resuming after an hour are my own calculations.

- Addy Osmani, [“Which Claude model should you build with? Fable, Opus, Sonnet, or Haiku”](https://claude.dev/blog/which-claude-model-should-you-build-with/), claude.dev, November 9, 2026: tables, benchmarks, patterns for mixing models, migration notes.
- Anthropic, [“Introducing Claude Fable 5.2 and Claude Mythos 5.2”](https://www.anthropic.com/claude-fable-and-mythos-5-2), November 9, 2026: the comparisons between Fable 5.2 and Opus 5.5 on Chartography, WANDR, and FrontierCode 2.0.
- [“Spending your effort”](https://claude.dev/blog/spending-your-effort/), claude.dev: the Terminal-Bench 3.0 comparison, as reported in Osmani’s post.
- The documentation the post links to: [Choosing a model](https://platform.claude.com/docs/en/about-claude/models/choosing-a-model), [Effort](https://platform.claude.com/docs/en/build-with-claude/effort), [Fast mode](https://platform.claude.com/docs/en/build-with-claude/fast-mode), [Preserved thinking](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking), [Optimizing for cost and intelligence](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence), [Advisor tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool), [Multiagent orchestration](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration), [Claude Code model configuration](https://code.claude.com/docs/en/model-config), and [Subagents](https://code.claude.com/docs/en/sub-agents).
- Claude API reference (Anthropic), copy from November 3, 2026: fast mode prices, Fable 5.2 data retention, per-message effort, server-side fallback.