Fable 5 and Opus 5: The Controls Changed, Not Just the Scores

Anthropic now ships two models at the top of its range. Opus 5 is the one most teams will actually run, at five dollars per million tokens going in and twenty five coming out. Fable 5 sits above it as the ceiling, at double that. Both read a million tokens of context and write up to 128,000 in a single response. The benchmark talk will sort itself out. The part worth your attention is quieter: the dials you used to turn are gone, and the careful prompts you wrote for older models are now working against you.

We build AI systems for companies in Cyprus and the wider region, so we live with these changes rather than reading about them. Here is what genuinely differs, and what we would change in a codebase this month.

Thinking stopped being a setting

For the last two years, getting good reasoning out of a model meant switching it on and handing it a token budget. You decided how much room it had to think. That whole idea has been retired.

On Fable 5, thinking is always on and you cannot turn it off. Asking it to stop is rejected outright. On Opus 5, thinking runs by default, which is a reversal of the model before it, where silence meant no reasoning at all. Instead of a token budget you now set an effort level, from low up to max, and the model decides how deep to go on each request.

There is a practical trap in that reversal. If you had a request that never mentioned thinking and you sized its output limit tightly around the answer, that same request now spends part of its budget reasoning before it writes. The reply can run out of room halfway through. Anything you carried over from an older model needs its output ceiling raised.

One more thing changed here. You never see the raw reasoning. Both models return a readable summary if you ask for one, and nothing at all if you do not. If your product used to stream the model's thoughts to a user, the default now looks like a long pause before anything appears.

Temperature is gone

This is the one that surprises people. Temperature, top p and top k are not accepted on either model. Send one and the request fails. A decade of habit, and a lot of configuration files, quietly stop applying.

If you used temperature at zero for repeatable output, the honest note is that it never actually guaranteed identical answers. Use a low effort level and a tighter instruction instead. If you used a high temperature to get variety, the replacement is words rather than numbers. For design work, the approach that works is to ask the model for four distinct directions first, pick one, then build only that.

Your old prompts are holding it back

This is the least obvious change and the one that costs teams the most quality. Prompts written for earlier models tend to be too prescriptive for these two, and being too prescriptive now makes the output worse rather than safer.

The clearest example is asking the model to check its own work. Telling a model to double check before answering has been sensible advice for years. Opus 5 verifies its own work without being asked, so the instruction pushes it into checking and rechecking, spending time and tokens on reassurance nobody needed. Removing those lines improves the result. Deleting the separate verification step some teams built into their tooling does too.

The same applies to progress reports. Older models needed to be told to summarise every few steps. These models narrate as they go, so that instruction produces a running commentary nobody asked for. And the aggressive phrasing people added to force tool use, the capitals and the you must, now overshoots, because the model follows the system prompt closely enough that plain language is enough.

The cheap settings got genuinely good

The reflex with a new frontier model is to run it at the highest setting and accept the bill. That reflex is now wrong often enough to be worth testing. Low and medium effort on these models frequently beat the top settings of the previous generation, at a fraction of the tokens and the wait.

Higher effort still earns its place on the hardest work, and on long autonomous runs it can reduce total cost by needing fewer turns. But the relationship is not a straight line, so the useful exercise is boring and cheap: run your own evaluation set at low, medium and high, and look at where quality stops improving. Most teams find they were overpaying.

A smaller saving that adds up: the minimum size of a prompt big enough to cache halved on Opus 5, down to about 512 tokens. Prompts you had written off as too short to cache now cache with no change on your side.

Single requests can now run for minutes

On a genuinely hard task at high effort, one Fable 5 request can work for many minutes before it answers. A fifteen minute single call is normal when the job involves gathering context, building something and checking it.

That is a product decision disguised as a technical detail. Timeouts written for two second replies will fire. A spinner is no longer an acceptable interface. The pattern that works is to stream, show real progress, and let people leave and come back rather than sit and wait. If you are wiring one of these models into something a customer touches, design the waiting before you design the prompt.

Two things to check before you commit

Fable 5 requires thirty day data retention and is not available to organisations configured for zero retention. If your policy or your client's contract requires zero retention, every request fails, and the error looks like a malformed request rather than a policy problem. Worth knowing before you spend an afternoon debugging a payload that was fine.

Both models also carry safety classifiers that can decline a request. When that happens you get a normal successful response that contains a refusal instead of an answer. Code that reads the first block of the reply without checking will break. Benign work in security and life sciences occasionally trips these, so if you operate anywhere near those fields, handle the refusal case and configure a fallback model. Opus 5 makes that easy: you can ask the platform to pick the fallback for you rather than naming one and maintaining the list yourself.

Give it somewhere to remember

One small habit produces an outsized difference. These models perform noticeably better when they have a place to write down what they learn, even a plain markdown file. Tell it where the file is, tell it to read the file at the start of future sessions, and give it a format. One lesson per entry, a one line summary at the top, and a note on why it mattered.

It sounds trivial next to a million token context window. It is not. Context lasts one conversation. A file lasts as long as the project.

What we would do this quarter

1. Start with Opus 5, not Fable 5. Half the cost, the same context window, and enough capability for almost every job. Reach for Fable 5 when a task has genuinely beaten Opus 5, not before.
2. Strip the scaffolding out of your prompts. Delete the verification lines, the forced summaries and the shouted rules, then compare the output. This costs nothing and often wins the most.
3. Sweep the effort levels on your own examples. Thirty real cases from your business will tell you where quality plateaus. Run there, not at the top.
4. Raise your output limits and your timeouts. Both models think before they write, and hard requests take minutes. Old ceilings truncate good answers.
5. Handle the refusal path. Check why the model stopped before you read what it said, and set a fallback. It is a few lines, and it saves a broken page in production.

If you are running an older model in production and wondering whether any of this is worth the migration, that is the right question to ask before you touch anything. See how we build AI agents for workflows like yours, or tell us what you are running today. We will give you a straight answer about whether moving is worth your time this quarter.