# Claude Fable 5.2 vs GPT-6 Astra: When Each Costs Less per Task

> Fable 5.2 at medium nearly matches GPT-6 Astra at max for 39% less per task. On small tasks both passed, but Fable at high cost 1.74x what Astra did.

- URL: https://blog.laozhang.ai/en/posts/claude-fable-5-2-vs-gpt-6-astra
- Published: 2026-11-10
- Updated: 2026-11-10
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Model Comparisons
- Tags: Claude Fable 5.2, GPT-6 Astra, AI Model Comparison, API Pricing, Reasoning Effort, Coding Agents

---
Claude Fable 5.2, released on November 9, 2026, changes the comparison with GPT-6 Astra in two ways. Its list price is now 20% below Astra's, $8 / $40 per million input and output tokens against $10 / $50, and on Artificial Analysis's Intelligence Index v5.0.1, as of November 10, 2026, it scores higher at every effort level, 65 against 57 at `max`. Neither number is what a finished task costs, because Fable 5.2 counts more tokens for the same text and, at the same effort label, thinks much longer.

If you run `gpt-6-astra` at `high` or above for hard coding and agent work, make `claude-fable-5-2` at `medium` or `low` your next trial. On the same index, Fable at `medium` scores 56 for $3.80 and 8.3 minutes per task, one point under Astra at `max` for 39% less money and just over a third of the time. If Astra at `medium` or `low` already passes your work, keep it: on November 10, 2026, both models passed the same 11 small coding and reading tasks, each in its own vendor's agent CLI, but Fable 5.2 at `high` wrote 2.5 times the output tokens and cost 1.74 times as much at list prices, and it has no setting as cheap as Astra at `low`.

A few conditions decide before quality does. Fable 5.2 blocks high-risk cybersecurity work such as penetration testing and exploit generation, and most research-biology tasks. It also will not run without 30-day data retention and rejects forced tool calls, so those workloads stay on Astra. In the other direction, a prompt above 272K Astra tokens moves the whole Astra request to $20 / $75 per million, which makes Fable the cheaper model to feed very long inputs.

## What changed on November 9: Fable 5.2's price and score

Anthropic released Claude Fable 5.2 (`claude-fable-5-2`) on November 9, 2026, at a lower price than both Fable 5.1 and GPT-6 Astra, and with a higher Artificial Analysis score than Astra. Fable 5.1 listed at exactly Astra's price, so a comparison that calls the two models equally priced, or quotes an earlier Artificial Analysis version on which they tied, was written for Fable 5.1 and was right for its date. A "Fable 5.2 vs GPT-6 Astra" video or article dated before November 9 predates the model.

Anthropic positions Fable 5.2 "for demanding reasoning and long-horizon agentic work" on its [Claude Fable 5.2 model overview](https://platform.claude.com/docs/en/models/fable-5-2/overview). It reads text and images, has a 1M-token context window billed at one rate throughout, and writes up to 128K output tokens per request. Its adaptive thinking is always on and cannot be switched off, so the effort setting, `low` through `max`, is the only control over how deeply it thinks. Claude Mythos 5.2 is the same model with fewer cybersecurity and biology safeguards, open only to organizations verified by Anthropic. Fable 5.1 is now labelled legacy but is still served; if you are staying on it for now, [GPT-6 Astra vs Claude Fable 5.1: Same Price, 1.5x the Tokens](https://blog.laozhang.ai/en/posts/gpt-5-6-sol-vs-fable-5-vs-opus-4-8) covers that pairing.

Nothing changed on OpenAI's side. GPT-6 Astra (`gpt-6-astra`), released on September 3, 2026, is still OpenAI's top general model, and [OpenAI's API pricing page](https://developers.openai.com/api/docs/pricing) lists no GPT-6.2 as of November 10, 2026. "Astra 6" in searches is shorthand for GPT-6 Astra, not a separate model. According to OpenAI's model documentation as of October 26, 2026, Astra has a 1,050,000-token context window with 922,000 tokens of input, 128K output tokens, the same five effort levels from `low` to `max` (it accepts neither `none` nor `minimal`), and runs on the Responses, Chat Completions and Batch APIs, with function calling on Responses only.

## Which effort levels match: Fable 5.2 medium vs GPT-6 Astra max

Effort labels do not mean the same amount of work on the two models, so "both at `xhigh`" is not a fair match. Pair them by result instead. On Artificial Analysis's Intelligence Index v5.0.1, as of November 10, 2026, Fable 5.2 at `medium` lands one point under Astra at `max`, and Fable at `low` one point under Astra at `high` and `xhigh`, each for less money and less time per task. Compared label for label, Fable scores 4 to 11 points higher but costs 1.39 to 4.25 times as much.

| Model and effort | Intelligence Index v5.0.1 | Cost per index task | Minutes per task |
| --- | ---: | ---: | ---: |
| Fable 5.2 `max` | 65 | $26.54 | 44.1 |
| Fable 5.2 `xhigh` | 62 | $14.83 | 26.3 |
| Fable 5.2 `high` | 62 | $9.08 | 17.7 |
| GPT-6 Astra `max` | 57 | $6.24 | 22.6 |
| Fable 5.2 `medium` | 56 | $3.80 | 8.3 |
| GPT-6 Astra `xhigh` | 55 | $3.66 | 11.6 |
| GPT-6 Astra `high` | 55 | $3.24 | 9.9 |
| Fable 5.2 `low` | 54 | $3.10 | 6.5 |
| GPT-6 Astra `medium` | 52 | $2.73 | 6.9 |
| GPT-6 Astra `low` | 43 | $1.42 | 3.8 |

The rows come from [Artificial Analysis's GPT-6 Astra vs Claude Fable 5.2 release comparison](https://artificialanalysis.ai/models/releases/comparisons/gpt-6-astra-vs-claude-fable-5-2), which prices each model at its vendor's list price. The index combines many evaluations, so it ranks settings against each other rather than predicting your tasks, and Artificial Analysis revises its numbers without notice.

The "both at `xhigh`" match that circulated on launch day shows why labels mislead. Fable at `xhigh` scores 62 against Astra's 55, but costs $14.83 against $3.66 per task, 4.05 times as much. It also scores no higher than Fable at `high`, which costs 39% less and takes about two thirds of the time. On this index, `xhigh` buys nothing over `high` for Fable 5.2.

Read the table from the effort you use today. The percentages below are calculated from the rows above.

| You run Astra at | Try instead | What the index shows |
| --- | --- | --- |
| `low`, and it passes your checks | Stay on Astra `low` | Fable has no setting this cheap: its `low` scores 11 points higher but costs 2.18x per task |
| `medium` | Stay; test Fable `low` only where Astra misses | Fable `low` scores 2 points higher, costs 14% more, finishes about as fast |
| `high` or `xhigh` | Fable `low` | One point lower, 4–15% cheaper, 34–44% less time |
| `max` | Fable `medium` | One point lower, 39% cheaper, about 63% less time |
| `max`, and it still fails | Fable `high` | 5 points higher at 1.46x the cost and 0.78x the time; Fable `max` adds 3 more points at 4.25x Astra `max`'s cost |

![Each GPT-6 Astra effort level paired with the Claude Fable 5.2 setting that scores about the same, with cost and minutes per task](https://blog.laozhang.ai/posts/en/claude-fable-5-2-vs-gpt-6-astra/img/effort-pairing.webp)

Set Fable's effort explicitly, because the default depends on where you call it. Anthropic's [effort documentation](https://platform.claude.com/docs/en/build-with-claude/effort) gives `high` as the API default and `medium` as the default in Claude Code and the Claude apps; on the index, `high` costs 2.4 times `medium` per task. Anthropic's advice is to start at `high`, step down to `medium` or `low` where your evaluations hold, and keep `max` for measuring the ceiling because it "runs slower and costs more than at `xhigh`, often for only a small gain". OpenAI's documentation, as of October 26, 2026, does not state Astra's API default; in Codex, Astra runs at whatever your config sets.

If even Astra at `low` is more than your work needs, the cheaper step is inside each vendor's lineup: [GPT-6.1 Sol vs GPT-6 Astra vs GPT-6 Sol: When Astra Is Worth It](https://blog.laozhang.ai/en/posts/gpt-6-1-sol-vs-gpt-6-astra-vs-gpt-6-sol) on the OpenAI side, [Claude Sonnet 5.5 vs GPT-6 Astra: When the Cheaper Model Wins](https://blog.laozhang.ai/en/posts/claude-sonnet-5-5-vs-gpt-6-astra) across vendors, and [Claude Fable 5.1 vs Opus 5.5: Which Should You Use?](https://blog.laozhang.ai/en/posts/claude-fable-5-1-vs-opus-5-5) for the Claude model below Fable (written for 5.1).

## Same 11 tasks at high: equal pass rate, 2.5x the tokens on Fable 5.2

On small, fully specified tasks the two models gave equal results and very different token counts. On November 10, 2026, the same 11 tasks went to GPT-6 Astra in Codex CLI 0.166.0 and to Claude Fable 5.2 in Claude Code, two runs each, both at effort `high`, each on a subscription. All 44 graded answers passed, 11 of 11 in every run, and the runs took about the same time, but Fable 5.2 wrote 2.49 times the output tokens, and about half of the extra was thinking.

The tasks were a word problem, three small Python functions (merging intervals, parsing durations, counting top words), a five-bullet summary of a 6,723-word article, an expression evaluator, a CSV line parser, a digit-sum counting problem solved without running code, a semver range matcher, arithmetic from three notes buried in a long document, and a standard-library question that named two functions that do not exist. The code was graded by hidden tests and the rest by fixed rules, all written before any model answered.

| Mean per run, November 10, 2026 | Fable 5.2 (`high`, Claude Code) | GPT-6 Astra (`high`, Codex CLI) | Fable ÷ Astra |
| --- | ---: | ---: | ---: |
| Tasks passed | 11 of 11 | 11 of 11 | — |
| Output tokens | 24,052 | 9,645 | 2.49x |
| of which thinking or reasoning | 8,426 | 1,044 | 8.07x |
| Wall time | 221.8 s | 236.0 s | 0.94x |
| Output cost at list price | $0.96 | $0.48 | 2.00x |
| Context cost at list price | $1.19 | $0.75 | 1.58x |
| Total at list price | $2.15 | $1.24 | 1.74x |

![Bar chart of the November 10 test: both models passed 11 of 11, Fable 5.2 wrote 2.49x the output and 8.07x the thinking tokens, took 0.94x the time and cost 1.74x](https://blog.laozhang.ai/posts/en/claude-fable-5-2-vs-gpt-6-astra/img/nov-10-token-test.webp)

The cleanest comparisons in this table are pass counts, output tokens and wall time. Context cost compares harness plus model, because Codex carried about 16K tokens of its own context per call while Claude Code carried about 85–125K per session, and Codex reported no cache writes, which the OpenAI API would bill at $12.50 per million on a metered account. Both sides ran under subscriptions, so the dollar figures are list-price equivalents of the tokens used, not a bill.

What the test shows is how much more Fable 5.2 thinks at the same label on easy work: 8 times the thinking tokens for the same passing answers. What it cannot show is how the two compare on long, ambiguous or hard tasks, which neither model failed here, and Fable at `medium` or `low` was not run. The cheaper pairings in the previous section therefore rest on Artificial Analysis's index, not on this test, and two samples per model on one machine are a small base.

## Is Fable 5.2 really 20% cheaper than GPT-6 Astra? Per token, yes

Per token, yes: since November 9, 2026, Fable 5.2's input, output and short cache-write prices are 20% below GPT-6 Astra's, and its cache reads cost a fifth of Astra's. Per task, not necessarily. Fable counts the same text as more tokens and, at the same effort, writes more of them, so in the test above its output cost 2.0 times Astra's despite the lower rate.

| USD per 1M tokens, as of November 10, 2026 | Claude Fable 5.2 | GPT-6 Astra |
| --- | ---: | ---: |
| Input | $8 | $10 |
| Output | $40 | $50 |
| Cache read | $0.20 | $1.00 |
| Cache write, default lifetime | $10 (5 minutes) | $12.50 (30 minutes) |
| Cache write, long lifetime | $16 (1 hour) | $25 (12 hours) |
| Requests above 272K input tokens | Same rates | Whole request at $20 input, $75 output, $2 cache read |
| Batch | $4 / $20 | Half of Standard |

Fable's rates are from [Anthropic's pricing page](https://platform.claude.com/docs/en/about-claude/pricing); Astra's short-context rates from OpenAI's pricing page as of November 10, and its long-context and Batch rates as of October 26, 2026. For Astra's 272K step, cache tiers, Batch and Fast modes in detail, see [GPT-6 Astra API Pricing: $10/$50 per 1M Tokens, Caching Costs](https://blog.laozhang.ai/en/posts/gpt-6-astra-api-pricing).

### Same text, more tokens: Fable 5.2 input cost by language

The same prompt does not cost the same on both models, because Anthropic's tokenizer splits text into more tokens than OpenAI's. On October 26, 2026, the same passage was sent to both APIs and the usage fields compared: Claude Fable 5.1 counted 1.45 times as many tokens as GPT-6 Astra for English and up to 1.90 times for Korean. Anthropic states that Fable 5.2 uses the same tokenizer as its other current models, so these ratios carry over. Multiply each ratio by 0.8, the input price ratio, to get what the same uncached text costs on Fable 5.2 relative to Astra.

| Language | Claude tokens per Astra token | Same uncached input on Fable 5.2 vs Astra |
| --- | ---: | ---: |
| English | 1.45 | 1.16x |
| Chinese | 1.50 | 1.20x |
| Japanese | 1.23 | 0.98x |
| Korean | 1.90 | 1.52x |
| Russian | 1.56 | 1.25x |
| Spanish | 1.88 | 1.50x |

On Fable 5.1, which listed at Astra's price, the input cost ratio was the token ratio itself, 1.23x to 1.90x. Only for Japanese does the price cut make Fable 5.2's input cheaper than Astra's for the same text; for English it is still 16% dearer. Each ratio comes from one passage of 246–799 characters, and a full 6,723-word English article came out at 1.52, so treat the column as a range, not a constant. The same ratio shrinks Fable's context window in practice: for English, 1M Fable tokens hold roughly as much text as 690K Astra tokens (1M ÷ 1.45), less than Astra's 922K maximum input.

### Cached context and prompts above 272K tokens

Caching and very long prompts are where Fable 5.2 is cheapest. Agent loops re-read the same context many times, and Astra charges $1.00 per million cached tokens while the same English text on Fable is 1.45 times the tokens at $0.20, about $0.29 per million Astra-token equivalents, or 0.29 times Astra's charge. The first write goes the other way: Astra's default write is $12.50 per million, and Fable's 5-minute write is $10 × 1.45 = $14.50 per million Astra-token equivalents, 1.16 times as much.

The two vendors also cache differently by default. OpenAI caches Astra prompts of 1,024 tokens or more automatically and bills the write unless you opt out with `prompt_cache_options.mode: "explicit"`. Anthropic caches only where your request sets `cache_control`, so a Fable 5.2 integration without it pays full input price on every turn; [Claude Prompt Caching: How It Works, Costs, 512-Token Minimum](https://blog.laozhang.ai/en/posts/claude-prompt-caching) shows the setup.

Above 272K input tokens, counted in Astra's tokens, OpenAI bills the entire Astra request at the long-context rate, not just the excess. A single uncached English prompt of 300K Astra tokens costs 0.3 × $20 = $6.00 in input on Astra; on Fable the same text is about 435K tokens × $8 per million = $3.48, or 0.58 times. In Korean, at 1.90 tokens per Astra token, it is about 570K tokens and $4.56, or 0.76 times. Below the threshold, the language table above applies instead.

## Is GPT-6 Astra still better than Fable 5.2 at anything?

On the overall index, no: Fable 5.2 scores higher at every effort level. Astra still leads or ties on three of Artificial Analysis's component evaluations as of November 10, 2026, and it keeps the cheapest setting of the two. On GDP.pdf, Astra scores 30.4–32.2% at every effort against Fable's 21.4–26.8%. On CritPt v2's hard subset, Astra at `medium` through `max` (70.5–72.0%) beats Fable at `low` and `medium` (60.0% and 61.5%), the settings that match Astra on cost; Fable needs `high` (73.0%) to pull ahead. On Terminal-Bench 4.0, Astra at `xhigh` scores 59.6%, the same as Fable at `high` and `max`.

The CritPt result matters for the effort pairing. Fable `low` matching Astra `high` on the overall index does not hold on every kind of work, so if CritPt is the benchmark closest to your work, compare Fable at `high` with Astra at `medium` instead. Fable's largest leads are on AA-Omniscience 63–67 against 40–45, HLE-Diamond 80.2% against 63.8% at `max`, AutomationBench-AA 76.4% against 68.5% at `max`, and FrontierCode 2.0 at 49.1% for Fable `high` against 42.4% for Astra `max`.

[Anthropic's Fable 5.2 and Mythos 5.2 announcement](https://www.anthropic.com/claude-fable-and-mythos-5-2) adds a launch table against GPT-6 Astra, with each model at its highest available effort unless noted: FrontierSWE v2 69.9% against 65.5%, OSWorld 2.1 (offline set, partial) 89.3% against 79.5%, Remote Labor Index 41.3% at High against 20.8%, and Chartography, the closest row, 73.4% against 71.0%. Anthropic also says Fable 5.2 at High scores 45.3% on FrontierCode 2.0, "ahead of GPT-6 Astra's best score (42.8%) at about the same cost". These are vendor-reported numbers from one of the two parties, Fable leads on every row Anthropic chose to show, and OpenAI has published no table against Fable 5.2.

## Which is faster, Fable 5.2 or GPT-6 Astra? Three measures

Fable 5.2 streams output about twice as fast, but whether a task finishes sooner depends on how many tokens it writes. Artificial Analysis measures 87–103 output tokens per second for Fable 5.2 against 38–44 for Astra as of November 10, 2026, and at every equal-score pairing in the effort table, Fable needs less time per task than the Astra setting it replaces.

In the November 10 test the two effects cancelled out. Fable generated 2.5 times the tokens and finished in about the same wall time, 6% shorter than Astra, so faster streaming does not mean a faster answer when the model thinks longer at the same label. Anthropic's claim that Fable 5.2 generates output "up to 30% faster" compares it with Fable 5.1, not with Astra.

Both vendors sell speed as a separate tier. Fable 5.2's fast mode (`speed: "fast"` on the Messages API) promises up to 2.5 times the output speed at $16 / $80 per million tokens. Astra's Fast mode costs twice the Standard price, and Ultrafast, available on the Responses API only, six times.

## What rules out Fable 5.2 or GPT-6 Astra before quality matters

Each item below settles the choice for the workload it describes, whatever the scores say. The Fable 5.2 checks come from Anthropic's [Claude Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) and [What's new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2) as of November 10, 2026; the Astra checks from OpenAI's documentation as of October 26, 2026.

Fable 5.2 is out, or needs code changes, if:

- Your work involves high-risk cybersecurity or research biology. Fable 5.2's safety classifiers block high-risk cyber activities, including penetration testing, exploit generation and binary-based vulnerability work, as well as most research-biology tasks; on the API a blocked request returns HTTP 200 with `stop_reason: "refusal"`, and server-side fallback can retry it on Claude Opus 4.8 or Opus 5.
- Your organization runs under zero data retention. Fable 5.2 requires 30-day retention, and a request from a workspace without it returns a 400 `invalid_request_error` unless Anthropic has authorized an exception.
- Your code forces a tool call. A `tool_choice` of type `any` or `tool` returns a 400 error; only `auto` and `none` are accepted.
- Your code sets `temperature`, `top_p` or `top_k`, prefills the assistant turn, or disables thinking. Remove the sampling parameters; prefill and `thinking: {type: "disabled"}` return a 400 error.
- You plan to move Fable 5.1 traffic at its current volume. Fable 5.2 has its own rate limit, separate from the one Fable 5.1 and Fable 5 share.

GPT-6 Astra has fewer hard stops, and most of them are about cost. If your prompts regularly exceed 272K input tokens, every such request is billed at the long-context rate, so Fable 5.2 is the cheaper home for that work. If your tool-calling code runs on Chat Completions, it has to move to the Responses API first, because Astra supports function calling only there. Astra also accepts neither `none` nor `minimal` effort, so `low` is its floor, and OpenAI's data-residency endpoints add 10% to every rate.

## Which plan gives you Fable 5.2 or GPT-6 Astra

On Claude subscriptions, Fable 5.2 is available on every paid plan but not Free, as of November 10, 2026, according to Anthropic's help article on [Fable models on your Claude plan](https://support.claude.com/en/articles/15424964). On Max, Ultra and premium Team or Enterprise seats it is included, but at most 50% of the weekly limit can go to Fable models. On Pro and standard Team seats, Fable runs on pay-as-you-go usage credits, except during the launch week through November 16, 2026, 11:59 pm PT, when it is included up to 50% of the weekly limit. Fable is never the default model: choose it in the model picker, or with `/model fable` in Claude Code, where it then runs at `medium` unless you change the effort.

On ChatGPT plans, as of October 26, 2026, Free and Go get GPT-6 Luna, not Astra. Plus and standard Business seats get roughly 5–45 Astra local messages per 5 hours in Work and Codex, Pro has no 5-hour limit, and on Enterprise and Edu an owner has to enable Astra. Which plans can pick Astra in ordinary ChatGPT chats is not stated in OpenAI's help pages; third-party reports name Pro, Business and Enterprise.

## How to check Fable 5.2 vs GPT-6 Astra on your own tasks

Run your own tasks at paired settings, not at equal labels, and compare cost per accepted task. The index tells you which settings to pair; only your tasks tell you whether Fable's lower step holds up on your work and how many tokens each model writes for it.

1. Pick 10–20 tasks from real work and write the pass rule before reading any answer: tests that must pass, a checklist, or a reviewer's accept or reject.
2. Run Astra at the effort you use today and Fable 5.2 at the paired effort from the table above, for example Astra `high` against Fable `low`, or Astra `max` against Fable `medium`. Set Fable's effort in the request, because the API default is `high`. Use the same harness for both where you can, such as a direct API script; if you compare Codex with Claude Code, record that the harnesses differ.
3. From each response's usage data, log uncached input, cache reads, cache writes and output tokens (thinking and reasoning tokens are billed as output on both), plus wall time and pass or fail.
4. Price every request with the function below, sum the runs, failed attempts included, and divide by the number of accepted tasks.

```python
# USD per 1M tokens, list prices as of November 10, 2026
PRICES = {
    "claude-fable-5-2": {"input": 8.00, "cache_read": 0.20, "cache_write": 10.00, "output": 40.00},  # 5-minute write; 1-hour write is $16
    "gpt-6-astra": {"input": 10.00, "cache_read": 1.00, "cache_write": 12.50, "output": 50.00},  # 30-minute write; 12-hour write is $25
    # Use for any Astra request with more than 272K input tokens: the whole request is billed here
    "gpt-6-astra-over-272k": {"input": 20.00, "cache_read": 2.00, "cache_write": 25.00, "output": 75.00},
}

def cost(model, uncached, cache_read, cache_write, output):
    p = PRICES[model]
    return (uncached * p["input"] + cache_read * p["cache_read"]
            + cache_write * p["cache_write"] + output * p["output"]) / 1_000_000

# One Astra run from the November 10 test, summed over its requests at the standard rate:
print(round(cost("gpt-6-astra", 33_619, 439_552, 0, 9_902), 2))  # 1.27
```

OpenAI counts cached tokens inside the input total, so subtract them to get the uncached figure, as in the example: 473,171 input tokens, of which 439,552 were cached. The 272K check applies to each request, not to a session's total, so a run like this one, whose 473,171 input tokens were spread over many agent requests, stays on the standard rate. Keep Astra where Fable's cost per accepted task at the paired setting is higher and its pass count is not; move the work Astra only passes at `max`, or fails, to Fable 5.2.

If you call both models through a third-party gateway, check its model list before you plan the test, since a gateway may not serve the new model yet: on November 10, 2026, laozhang.ai's `GET /v1/models` listed `gpt-6-astra`, `claude-fable-5-1` and `claude-fable-5`, but not `claude-fable-5-2`. A second check about an hour later on the same day found `claude-fable-5-2` in that list.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-11-10.

- [Claude Fable 5.2 model overview](https://platform.claude.com/docs/en/models/fable-5-2/overview) (platform.claude.com)
- [OpenAI's API pricing page](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [Artificial Analysis's GPT-6 Astra vs Claude Fable 5.2 release comparison](https://artificialanalysis.ai/models/releases/comparisons/gpt-6-astra-vs-claude-fable-5-2) (artificialanalysis.ai)
- [effort documentation](https://platform.claude.com/docs/en/build-with-claude/effort) (platform.claude.com)
- [Anthropic's pricing page](https://platform.claude.com/docs/en/about-claude/pricing) (platform.claude.com)
- [Anthropic's Fable 5.2 and Mythos 5.2 announcement](https://www.anthropic.com/claude-fable-and-mythos-5-2) (anthropic.com)
- [Claude Fable 5.2 migration guide](https://platform.claude.com/docs/en/models/fable-5-2/migration-guide) (platform.claude.com)
- [What's new in Claude Fable 5.2](https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2) (platform.claude.com)
- [Fable models on your Claude plan](https://support.claude.com/en/articles/15424964) (support.claude.com)