Claude Fable 5.2 is Anthropic's most capable generally available model, launched on 9 November 2026 for long running agentic coding and research work. It pairs a 1 million token context window with adaptive reasoning that stays on through a whole session, and it costs 20 percent less than Fable 5.1. That combination is why it matters to developers building agents.
Key takeaways
Fable 5.2 launched on 9 November 2026 and now tops the Artificial Analysis Intelligence Index at 64.6, ahead of Gemini 4 Carbon at 60.0.
It scores 49.1 percent on FrontierCode 2.0, the highest agentic coding score Anthropic has published, against 45.5 percent for Opus 5.5 and 32.4 percent for Fable 5.1.
Pricing fell 20 percent to $8 per million input tokens and $40 per million output tokens, with an optional Fast mode at $16 and $80.
Adaptive reasoning is always on. You control depth with an effort setting, not with temperature or top_p.
Anthropic still recommends Opus 5.5 as the default for ordinary production work. Fable 5.2 is for the hardest, longest jobs.
What is Claude Fable 5.2?
Anthropic positions Fable above Opus 5.5 in its own hierarchy, and reserves it for unusually difficult reasoning and long horizon agent work. The model takes text and images as input and returns text, with a 1 million token context window and up to 128,000 tokens of output. Its knowledge cutoff is June 2026. It is hosted only, on the Anthropic API, AWS, Google Cloud and Microsoft Azure, and there are no open weights. The API model ID is claude-fable-5-2.
The headline change is adaptive reasoning that never switches off. Earlier reasoning models reset their chain of thought between turns. Fable 5.2 keeps its reasoning state across a conversation, so it can hold a mental model of a large codebase through dozens of tool calls. Developers set the depth with an effort parameter, from low to maximum, and the model decides how much thinking a task deserves. You cannot disable thinking, and Anthropic tells developers to leave temperature, top_p and top_k alone rather than trying to steer sampling the old way.
Launched alongside it, Claude Mythos 5.2 is the same underlying model with fewer cybersecurity and biology safeguards. It is limited to verified organisations through Anthropic's Cyber Verification Program and Life Sciences Verification Program. When Fable 5.2 blocks a request on those grounds, the user gets an answer from Opus 4.8 or Opus 5 instead, and Anthropic reports about 55 percent fewer blocks than Fable 5.1 produced.
In prerelease testing, Anthropic ran 1,000 Fable 5.2 agents that formalised the proof of Fermat's Last Theorem in Lean in 30 hours. Opus 5.5 reached 26 percent completion in 18 hours with the same setup. The same testing run solved two open problems on black holes and moved a production service from Python to Rust. These are vendor reported results, not independent replications, but they show what the model is built for: work measured in hours, not minutes.
How much does Fable 5.2 cost?
Standard pricing is $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for Fable 5.1. That is a 20 percent cut on the headline rate. An optional Fast mode costs $16 in and $80 out per million tokens and produces output up to 2.5 times faster, aimed at interactive coding sessions where waiting is the bottleneck. Even in standard mode, Anthropic says output runs up to 30 percent faster than Fable 5.1.
The per token price is only half the bill. Reasoning tokens count as output tokens, and Fable 5.2 thinks hard by default, at high effort. A long agent session that loads a whole repository into the 1 million token window and then reasons through a migration can cost real money before a single line of finished code appears. Price the job, not the token:
# Rough cost of one agentic session on Fable 5.2
input_tokens = 250_000 # a large repo loaded into context
output_tokens = 40_000 # reasoning plus finished code
cost_usd = (input_tokens / 1_000_000) * 8 + (output_tokens / 1_000_000) * 40
print(f"Session cost: ${cost_usd:.2f}") # $3.60
One practical consequence: keep the effort setting at high rather than maximum until you have measured a real task. Maximum effort buys the headline benchmark scores, but it also buys the biggest reasoning bill.
How to call Fable 5.2 from Python
The call itself is a standard Anthropic Messages API request. Install the SDK with pip install anthropic and set ANTHROPIC_API_KEY, then:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-fable-5-2",
max_tokens=8192,
messages=[
{"role": "user", "content": "Refactor this module to remove the duplicate database calls."}
],
)
print(response.content[0].text)
Three details catch developers out. First, do not pass temperature, top_p or top_k. Anthropic explicitly tells developers to omit them. Second, forcing tool selection with tool_choice set to any or tool returns a 400 error on this model, so leave tool choice unset and let the model decide when to call tools. Third, Fable 5.2 carries a 30 day data retention requirement unless Anthropic grants an exception, which matters if you send proprietary code through the API.
What the benchmarks do and do not prove
Anthropic's own launch table is strong. On FrontierCode 2.0, an agentic coding test, Fable 5.2 scores 49.1 percent at maximum effort, against 45.5 percent for Opus 5.5 and 32.4 percent for Fable 5.1. On FrontierSWE v2, real software engineering problems in existing codebases, it scores 69.9 percent, up from 56.3 percent for Fable 5.1 and ahead of Opus 5.5 at 62.3 percent. The gains are broad: AutomationBench rises from 31.4 to 51.4 percent, chart reading on Chartography from 44.8 to 73.4 percent, hardware design on BenchCAD 2.1 from 44.4 to 83.5 percent, and robotics on RoboDojo Sim from 27.6 to 64.9 percent.
Independent scores point the same way. Artificial Analysis puts Fable 5.2 first on its Intelligence Index at 64.6, ahead of Gemini 4 Carbon at 60.0. Vals AI, an independent evaluation platform, scores it at 71.31 percent, first among 36 models tested. When vendor benchmarks and independent benchmarks agree on direction, the signal is worth taking seriously.
What the benchmarks do not prove is value for money. A developer test shared widely on social media ran seven identical builds through both models. Fable 5.2 cost $39.29 in total against $16.37 for Opus 5.5, about 2.4 times more, because it spends far more reasoning tokens per task. The builds looked richer on Fable, but on one task Opus was the only model that actually solved the problem. Cheaper per token does not mean cheaper per finished job, and a higher benchmark score does not mean a better result on your codebase. Measure one real task end to end before you switch a production workflow.
Should you switch from Opus 5.5?
Anthropic's own guidance is clear: Opus 5.5 stays the default for ordinary production workloads, and Fable 5.2 is for the unusually difficult ones. We agree with that framing, and we would draw the line like this.
Reach for Fable 5.2 when the work runs for hours, when it spans a whole codebase, or when it ends in a finished artefact such as a migrated service, a research document or a hardware design. Long running agent sessions, large migrations and multi step research are its home ground. Reach for Fast mode when you are pairing with it interactively and latency is costing you focus.
Stay on Opus 5.5 for everyday coding, chat, short tasks and anything with a tight budget. A practical hybrid is to let Opus do the building and call Fable 5.2 as a reviewer on the hardest parts, which keeps the bill near Opus levels while buying Fable level scrutiny where it counts.
What we would do with it
Pick one long job you have already measured, a migration, a refactor or a research task, and run it on Fable 5.2 at high effort. Compare cost per finished task, not cost per token, and check the output against the same acceptance tests you used last time. If the result is better and the bill is acceptable, move that class of job over and keep Opus 5.5 as the default everywhere else. That is the whole decision: one measured job, one honest comparison, then a rule you can reuse.
Originally published on LogicStack. Run the code examples right in your browser with our free interactive Python and SQL playgrounds — no setup, no sign-up.
Top comments (0)