Claude Fable 5.2 vs GPT-6.1 Sol vs Opus 5.5: Our Tests

All three models passed the 22 checks in our Python bug-fix task and built an animated city page that met the prompt. GPT-6.1 Sol cost the least in both runs. Opus 5.5 fixed the Python file fastest. Fable 5.2 added more visual detail to the city, but that request cost $1.05, against $0.52 for Opus and $0.08 for Sol.
At high effort, Fable has the highest Artificial Analysis Intelligence Index score of the three. Its standard input and output rates are twice Opus’s and four times Sol’s.
API tests and source checks: November 10, 2026. Our coding check used two tasks, one run per model per task and high reasoning effort. Those effort labels are provider settings, not equal compute budgets.
Fable 5.2, Sol and Opus at a glance
| Model | Standard input / output per 1M | Context | Where to start |
|---|---|---|---|
| Claude Fable 5.2 | $8 / $40 | 1M tokens | Test it on requests your cheaper model fails |
| GPT-6.1 Sol | $2 / $10 | 1.05M tokens | Lowest-cost candidate in our two coding runs |
| Claude Opus 5.5 | $4 / $20 | 1M tokens | Anthropic’s recommended starting point for most coding and knowledge work |
The price column covers ordinary uncached input and output. Cached input and long-context pricing differ. All three are available through AI/ML API with one account and API key.
Our coding tests: results, time and cost
Each model received the same prompt for each task through AI/ML API. We made one run per task, with reasoning_effort="high". The times and charges below are the API results reported for those requests. This small check does not measure general reliability or typical production cost.
| Task | Model | Result | Time | API cost |
|---|---|---|---|---|
| Python bug fix | Fable 5.2 | 22/22 tests passed | 26 s | $0.11 |
| Python bug fix | GPT-6.1 Sol | 22/22 tests passed | 39 s | $0.02 |
| Python bug fix | Opus 5.5 | 22/22 tests passed | 17 s | $0.04 |
| Animated city page | Fable 5.2 | Prompt requirements met | 247 s | $1.05 |
| Animated city page | GPT-6.1 Sol | Prompt requirements met | 121 s | $0.08 |
| Animated city page | Opus 5.5 | Prompt requirements met | 230 s | $0.52 |
Python: all three passed the supplied checks
The Python file contained three small functions. Bugs included treating a day as 12 hours, failing to parse durations such as 1.5h, accepting invalid input and merging intervals incorrectly. Each model passed all 22 supplied tests. Opus completed this request fastest, while Sol cost the least.
Animated city: extra detail cost more
The second task asked for a self-contained HTML page with a canvas animation and a working day/night button:
Write a single self-contained HTML file (no external libraries, no network requests) that shows an animated night city on a canvas that fills the window. It needs a skyline of buildings with lit windows that slowly turn on and off, a road with at least five cars driving in both directions with headlights on, a moon, and a button in the top-left corner that switches the scene between night and day. Return only the HTML in one code block.All three pages met the requested features, including the day/night switch. Fable drew three rows of buildings and four lanes of traffic; Sol used two lanes with evenly spaced cars. Opus also produced a working scene.
For this request, Fable cost about twice as much as Opus and 13 times as much as Sol.
API pricing: token rates and task cost
| Per 1M tokens | Fable 5.2 | GPT-6.1 Sol | Opus 5.5 |
|---|---|---|---|
| Uncached input | $8 | $2 | $4 |
| Cached input | $0.20 | $0.10 | $0.20 |
| Output, including thinking | $40 | $10 | $20 |
Sources: current AI/ML API pages for Fable 5.2, GPT-6.1 Sol and Opus 5.5. Cached-input discounts apply to eligible reused input. Cache writes and special long-context tiers are separate from the ordinary rates shown here; check the selected model’s billing rules before estimating a large workload.
The 2× and 4× comparisons apply to standard uncached input and output, not every billed token. Fable and Opus have the same listed cached-input rate. A model can also use a different number of reasoning tokens or requests to finish a task, so its total cost does not follow the input/output ratio alone.
Anthropic gives a counterexample in its FrontierCode comparison: Fable 5.2 at high effort scored 45.3%, close to Opus 5.5 at max effort at 45.5%, for roughly half the cost per task. That is a provider benchmark result at different effort settings, separate from our API check.
Benchmarks: external scores and their limits
Artificial Analysis: compare explicit effort settings
At high effort, Artificial Analysis reports an Intelligence Index score of 62 for Fable, 52 for Opus and 50 for Sol. Its comparison pages also report the following workload cost and time metrics:
| Model | Intelligence Index | AA Cost per Task | AA Time per Task |
|---|---|---|---|
| Claude Fable 5.2 | 62 | $9.08 | 17.4 min |
| GPT-6.1 Sol | 50 | $0.59 | 6.5 min |
| Claude Opus 5.5 | 52 | $3.46 | 9.5 min |
Sources: Fable vs Sol and Fable vs Opus, checked November 10. Cost per Task and Time per Task are Artificial Analysis metrics for its evaluation workload. They are not our AI/ML API charges or a forecast for a particular application request. Equal effort names do not imply equal compute.

Effort matters to the comparison. Sol at max scores 55, between Fable at low (54) and medium (56). Opus at max scores 59, below Fable at high (62).
Anthropic: six benchmark results against Opus
The following rows come from Anthropic’s launch table. They use each model’s highest available effort unless marked otherwise. They were not measured in our coding test.
| Benchmark | What it measures | Fable 5.2 | Opus 5.5 |
|---|---|---|---|
| FrontierCode 2.0 | Changes maintainers would merge | 49.1% (xhigh) | 45.5% |
| FrontierSWE v2 | Agentic coding | 69.9% | 62.3% |
| AutomationBench | Business workflows | 51.4% | 42.5% |
| WANDR, relaxed score | Large data-collection tasks | 82.1% | 72.3% |
| OSWorld 2.1 | Computer use, offline set | 89.3% | 87.2% |
| Humanity’s Last Exam, with tools | Expert reasoning across subjects | 74.2% | 67.7% |
Fable leads on these six rows. Opus remains ahead on the AA-Briefcase Elo rating in Anthropic’s table: 1800 against 1785. That rating is a different measure from the rubric score reported alongside it.
Fable 5.2 vs GPT-6.1 Sol: when to pay more
Sol is the cheaper candidate to try first when your requests fit the standard pricing tier. It cost the least in both of our coding runs, and its standard input/output rates are a quarter of Fable’s. Fable scored higher in the external comparisons above, but our two tasks did not reveal a pass-rate advantage.
Try Fable on a request where Sol fails your actual acceptance checks. Compare the cost of reaching an accepted result, including retries, rather than assuming either model will be more economical from its token rate alone.
Fable 5.2 vs Opus 5.5: when to move up
Anthropic recommends starting with Opus 5.5 for most coding and knowledge tasks, then moving to another model as the task requires. Our small check supports testing Opus as a lower-cost starting point: it met both prompts and had the fastest Python fix, while Fable added city detail at a higher charge.
Fable is worth evaluating when Opus still misses the required result at an appropriate effort setting. The FrontierCode example shows that Fable can sometimes achieve comparable benchmark performance at lower total task cost despite its higher token rate. Your own task and acceptance criteria determine whether that trade-off holds.
What changed in Claude Fable 5.2?
Fable 5.2 is Anthropic’s publicly available model for demanding reasoning and long-running agent work, succeeding Fable 5.1. It takes text and images, has a 1M-token context window and supports up to 128K output tokens. Its adaptive thinking exposes low, medium, high, xhigh and max effort levels. See the model page and API documentation for route-specific settings.
Anthropic reports output generation up to 30% faster than Fable 5.1 and lower token prices. On Remote Labor Index, Fable 5.2 scored 41.3% at high effort, compared with Fable 5.1’s 17.9% at its highest available effort. The different settings are part of that comparison.

The launch post also reports a 30-hour formalization of Fermat’s Last Theorem by roughly 1,000 agents, and a separate eight-day prototype operating-system experiment involving over 1,000 subagents. These are Anthropic’s orchestrated experiments, not outcomes promised by a single API call. Experiment details.
Two behavior changes matter when moving old prompts: instructions such as “answer directly without deliberating” no longer suppress thinking at medium effort and above, and the model can stop a long task with a list of unfinished work, particularly at low or medium effort. Set effort explicitly and check the finished result.
Anthropic observed about 55% fewer safety-classifier blocks than with Fable 5.1 in early testing across Claude.ai, Claude Code and Cowork. This describes those app tests, not an API acceptance rate. Safety and behavior notes.
Separate demonstrations of longer tasks
The following demos are separate from the two single-request coding tasks above. They use different workloads and do not establish a controlled cost or quality ranking.
Cars voxel scene: Fable vs Sol
The separate Piston Cup demo reports $108.87 for Fable 5.2 and $13.02 for GPT-6.1 Sol. The video illustrates the generated scenes; the two-task table above does not include these costs or runs.
Glass pool: a creator’s Fable vs Opus comparison
Mr Tactical’s comparison reports 90 minutes and $57.87 for Fable, versus 68 minutes and $14.39 for Opus. He preferred Fable’s sunset and night scenes. That is the creator’s visual assessment and a separate workflow, not another run of our city prompt.
How to use the Fable 5.2 API
Create an AI/ML API account, fund your balance and create a key on the API keys page. You can first compare Fable 5.2 and Opus 5.5 in Playground using the same prompt.
For Python, install the openai package and set your key in the AIMLAPI_KEY environment variable. The example uses the OpenAI-compatible chat endpoint:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.aimlapi.com/v1",
api_key=os.environ["AIMLAPI_KEY"],
)
response = client.chat.completions.create(
model="anthropic/claude-fable-5-2",
reasoning_effort="high",
max_tokens=32000,
messages=[{
"role": "user",
"content": "Find and fix the bugs in this function: ...",
}],
)
print(response.choices[0].message.content)
print(response.usage)
To compare the other models, use anthropic/claude-opus-5-5 or openai/gpt-6.1-sol and keep the prompt and explicit effort setting unchanged. Record the usage alongside the result. The output limit also covers reasoning, so the visible answer may be shorter than 32,000 tokens. Fable request settings.
Frequently asked questions
Are Fable 5.2 and Mythos 5.2 the same model?
Anthropic describes them as the same underlying model at the same base price. Fable has cybersecurity and biology safeguards that allow public availability. Mythos access is limited to vetted organizations in Anthropic’s verification programs. This guide covers the Fable route offered by AI/ML API. Anthropic’s explanation.
When was Claude Fable 5.2 released?
Anthropic released it on November 9, 2026. AI/ML API lists the model as anthropic/claude-fable-5-2, with the same release date. Fable 5.1 remains available for comparison.
Is Claude Fable 5.2 free?
No. API usage is billed. The two Fable requests in our coding check cost $1.16 together: $0.11 for the Python fix and $1.05 for the city page. Other prompts and effort settings can produce different charges.
What is the best lower-cost alternative?
Opus 5.5 is Anthropic’s suggested starting point for most coding and knowledge work, with half Fable’s standard input/output rates. Sol has the lowest standard rates of these three and the lowest charges in our two runs. Test the candidate on your own requirements; neither result establishes a universal winner.
Is Fable 5.2 better than Fable 5.1?
It improves on the published FrontierSWE v2 result, 69.9% versus 56.3%, and the Remote Labor Index comparison above. Those results support evaluating the newer model, but they do not guarantee an improvement on every request. Published comparison.
Choose a model on your own acceptance checks
Start with Sol or Opus when they meet your requirements. Save prompts that fail, try those with Fable and compare the complete cost of an accepted result. Use the same task checks across models, and record effort, output limits, retries and API charges so the comparison answers your application’s question.



