GPT-6 Astra vs. Claude Fable 5.1: the full technical comparison
Context windows, reasoning-effort controls, tool surfaces, benchmark scores, cache pricing, and safety architecture — cross-checked against official docs, model registries, and independent evaluators, with the numbers that don't agree flagged rather than smoothed over.
GPT-6 Astra
1.05M-token context, five reasoning-effort tiers, async tool calls, mid-turn steering, and the first OpenAI model to cross the "Critical" cybersecurity threshold — which is why the rollout is staged and monitored.
Claude Fable 5.1
1M-token context, always-on adaptive thinking with an effort parameter, a 75%-cheaper cache-read price built for long agent sessions, and a "Covered Model" safety tier with a route-to-Opus policy for dual-use cyber work.
Most launch-week coverage of these two models settled for the marketing slides. This piece goes one layer deeper: the actual API parameters, the benchmark numbers Anthropic and OpenAI put in their system cards rather than their blog posts, and the places where independent evaluators and third-party registries disagree with the headline claims — including one benchmark figure that's been misattributed across a dozen "what's new" posts this week.
Spec sheet at a glance
Confirmed against OpenRouter, LiteLLM, and each vendor's own docs
| Spec | GPT-6 Astra | Claude Fable 5.1 |
|---|---|---|
| Context window | 1,050,000 tokens (≈922K input + 128K output) | 1,000,000 tokens (incl. 128K max output) |
| Knowledge cutoff | April 30, 2026 | Not separately published; inherits Fable 5's training cutoff |
| Input modalities | Text, image; files via tools | Text, image, file/PDF |
| Reasoning control | reasoning_effort: low / medium / high / xhigh / max | Always-on adaptive thinking with an effort parameter |
| Mid-session effort change | configuration_update (standard mode only) | Effort parameter set per request |
| Tool surface | Web/file search, code interpreter, shell, computer use, MCP, async tools | Standard tool use + computer use; exploit-generation routes to Opus |
| Input pricing | Tiered by effort; 2x input / 1.5x output above 272K tokens | $10 / M tokens |
| Output pricing | Tiered by effort | $50 / M tokens |
| Cached input pricing | Not uniformly published | $0.25 / M tokens (–75% vs. Fable 5) |
| p95 time-to-first-token | Not publicly benchmarked yet | ~22.5 seconds (independent tracker, Anthropic endpoint) |
| Safety tier | First model at OpenAI's "Critical" cyber threshold | "Covered Model" + Enterprise Frontier Safeguards |
| Restricted sibling | — | Claude Mythos 5.1 (trusted access only) |
| Model string | gpt-6-astra | claude-fable-5-1 |
Figures compiled from OpenAI's model guidance, OpenRouter, LiteLLM's day-0 support notes, Anthropic's Fable 5.1 system card, and llm-stats.com. Pricing tiers reflect what each vendor had published as of Sept 11, 2026.
GPT-6 Astra: architecture & API
OpenAI · limited preview Sept 3, general availability Sept 4, 2026
Astra is a generalist agent model, and its API surface reflects that: it's designed to hold a full working session — spec, codebase summary, tool definitions, conversation history — inside one context window, then act on it across many tool calls without losing the thread.
Context window and reasoning effort
The advertised 1.05M-token window splits into roughly 922K input tokens and a 128K output cap. Reasoning depth is controlled with reasoning_effort, which accepts low, medium, high, and xhigh on Chat Completions, plus a max tier on the Responses API; none and minimal are rejected outright, and temperature can't be set while reasoning is active. A new configuration_update item lets a developer raise or lower effort mid-conversation — useful for spending "max" only on the one hard turn in an otherwise routine session — without invalidating the prompt cache built up so far. That update is only accepted in standard, single-agent mode; Astra's "pro" and tournament configurations reject it.
Agentic tool surface
Through Codex, Astra exposes web search, file search, image generation, a code interpreter, a hosted shell, patch application, computer use, MCP servers, and tool search, with no reduction in tool coverage versus GPT-5.6 Sol. Two additions stand out for long sessions: asynchronous tool calls, where the model keeps reasoning or works a separate part of the task while a tool executes rather than blocking; and mid-turn steering over a WebSocket connection, which lets a person change requirements partway through a run while preserving whatever work is already finished. An experimental context-notes system also lets Astra search earlier context windows for requirements or test results that didn't make it into its running summary, reducing the information loss that comes from repeated compaction on long sessions.
Computer-use performance
On the OSWorld computer-use simulation, OpenAI reports Astra finishing tasks in roughly 40 minutes versus 75 for GPT-5.6 Sol — about 47% faster — and a 1.9x speedup on Mind2Web inside the updated Codex harness. In Codex-specific coding evaluations, Astra used roughly a third of the tokens Sol needed for comparable results; at maximum reasoning effort its cost per task landed close to Sol's while its score came in about two points higher. On one independent coding-agent benchmark cited by third-party analysts, Astra's result sat near Opus 5 and Fable 5 — behind Fable 5.1, which posted a noticeably higher score on that specific test, a reminder that no single benchmark tells the whole story.
Alignment and monitorability
Astra is the first OpenAI model to cross the company's "Critical" cybersecurity threshold under its Preparedness Framework: with the right access, it can independently discover and exploit previously unknown vulnerabilities in well-protected systems, largely without step-by-step human guidance. That triggered a staged rollout starting with vetted cybersecurity-program participants, plus stricter isolation, checkpoint encryption, full monitoring of reasoning traces, and an adjustable, more conservative refusal boundary for users flagged as higher-risk. OpenAI also disclosed something less flattering in its own system card: internal tests found Astra's written reasoning harder to monitor than Sol's, which the company attributes to Astra needing fewer written steps and exercising more control over its own reasoning on simpler tasks. It still struggles to fully hide the reasoning behind complex tasks, but OpenAI flags the trend as a real research priority rather than a solved problem — a rare bit of self-criticism worth taking at face value.
Claude Fable 5.1: architecture & API
Anthropic · generally available since roughly Sept 1, 2026
Fable 5.1 keeps Fable 5's structure — 1M-token context, 128K max output, the same base input/output pricing — and changes what actually decides the bill on long agentic runs: cache-read cost. It also swaps opt-in "extended thinking" for always-on adaptive thinking, governed by a single effort parameter that trades latency for depth on every request rather than requiring a separate toggle.
Benchmark results — and a correction
Anthropic's own system card leads with the agentic and tool-using evals, not the raw coding leaderboard: Terminal-Bench-Science more than doubles, from 24.7% on Fable 5 to 52.6% on Fable 5.1; Terminal-Bench 4.0 coding rises from 42.0% to 55.8%; and AutomationBench, which grades multi-step agentic pipelines, nearly doubles from 17.1% to 31.4%. Cybersecurity-safeguard false positives drop 60%, and biology-filter false positives drop 85% — a meaningful change for legitimate researchers who'd otherwise spend their time arguing with a classifier instead of doing the work.
A correction worth making
A specific claim — "Fable 5.1 scores 95.0% on SWE-bench Verified" — has been repeated across a large share of launch-week coverage. That figure belongs to Fable 5's June 2026 launch, not Fable 5.1's September update. Anthropic's Fable 5.1 announcement doesn't headline a SWE-bench Verified score at all; the software-engineering figure that does appear in the system card is SWE-bench Pro, in the neighborhood of 80–81%, which is a modest gain over Fable 5 rather than the dramatic jump some coverage implied.
Independent evaluation is more consistent: Vals AI ranked Fable 5.1 first on its own Vals Index at 67.87%, just ahead of Opus 5 (67.21%) and Fable 5 (66.04%), and recorded a first-of-its-kind perfect 100% on ProofBench v1.1, a formal mathematical-proof benchmark. Treat any single self-reported number with some caution; treat convergent results across independent testers as the stronger signal.
Safety architecture: Covered Model status and EFS
Anthropic designated Fable 5.1 a "Covered Model," a tier that comes with stricter data retention, safety review, and access policies wherever it's deployed. For enterprise buyers, the newer piece is Enterprise Frontier Safeguards (EFS), built with AWS, which is meant to let eligible customers run zero data retention while keeping safety monitoring intact inside infrastructure they control; it's rolling out in phases starting later this fall rather than being available everywhere at launch. Every output the model produces carries a statistical text watermark, on every platform that offers the model. On dual-use cyber work specifically, Fable 5.1 is scoped to defensive vulnerability discovery — actual exploit generation and some other dual-use cybersecurity tasks are routed to Opus-tier models instead, a narrower design than giving the flagship model blanket access to offensive capability.
Mythos 5.1 and the cyber/bio split
Claude Mythos 5.1 runs on the same weights as Fable 5.1 but keeps its full cybersecurity and biology capability intact rather than safeguarded down for general release. It's not sold broadly — access runs through Anthropic's trusted-access programs, including a new Life Sciences Verification Program aimed at giving vetted biology researchers the unsafeguarded version of the model's research capabilities without opening that door to everyone.
Benchmark comparison
Same table, both vendors' own numbers, flagged where sources disagree
| Benchmark | GPT-6 Astra | Claude Fable 5.1 |
|---|---|---|
| FrontierMath Tier 4 | 98% | Not headlined in launch materials |
| ARC-AGI-3 | 99.9% | Not headlined in launch materials |
| ExploitBench | 100% | N/A — dual-use exploit tasks route to Opus |
| SWE-bench Pro | Not published | ~80–81% (system card) † |
| Terminal-Bench 4.0 (coding) | Not published | 55.8% (from 42.0% on Fable 5) |
| Terminal-Bench-Science | Not published | 52.6% (from 24.7% on Fable 5) |
| AutomationBench | Not published | 31.4% (from 17.1% on Fable 5) |
| OSWorld (computer use) | ~40 min avg. task (–47% vs. Sol) | Not headlined in launch materials |
| Vals AI independent index | Not yet listed at time of writing | 67.87%, ranked #1 of tested models |
† Widely circulated figures crediting Fable 5.1 with 95.0% on SWE-bench Verified reflect Fable 5's June 2026 scores, misattributed in a large share of launch-week coverage. Each vendor leads its own launch materials with the benchmarks that best showcase its focus — Astra with saturating reasoning benchmarks, Fable 5.1 with agentic and tool-using ones — so this table intentionally leaves cells blank rather than filling gaps with numbers the vendor didn't publish.
Calling the reasoning controls
Illustrative request shapes — check current docs before shipping
GPT-6 Astra — Responses API
# set effort per-request, raise it mid-session # with configuration_update (standard mode only) response = client.responses.create( model="gpt-6-astra", reasoning={"effort": "high"}, input=[ {"role": "user", "content": "Refactor the auth module..."} ], tools=[computer_use_tool, mcp_tool], )
Claude Fable 5.1 — Messages API
# adaptive thinking is always on; # effort trades latency for depth response = client.messages.create( model="claude-fable-5-1", max_tokens=4096, thinking={"effort": "high"}, messages=[ {"role": "user", "content": "Refactor the auth module..."} ], )
Parameter names are illustrative of each vendor's documented pattern as of Sept 2026 and simplified for readability — confirm exact field names against current API docs before writing production code, since fast-moving launches like these sometimes ship follow-up parameter changes in the first weeks.
Cost modeling: long agentic sessions
Where the cache-pricing change actually shows up
Fable 5.1's headline economic change is cache-read pricing, and it's worth running an actual number. Take an agent session that reuses a 200K-token context — a mid-sized repo plus tool definitions — across 50 tool-calling turns, with a 90% cache-hit rate on repeated reads. At Fable 5's $1.00-per-million cache-read price, that repeated context alone cost roughly $9 over the session. At Fable 5.1's $0.25-per-million rate, the same pattern costs about $2.25 — Anthropic's own estimate of "up to ~45% cheaper for highly agentic workloads" tracks with sessions shaped like this one, where most of the token volume is re-read context rather than fresh generation.
Astra doesn't have an equivalent flat number to plug into the same math: its pricing is tiered by reasoning effort rather than published as a single input/output rate, with the clearest published data point being the 2x input / 1.5x output surcharge once a request crosses 272K input tokens. The more useful comparison for Astra is the cost-per-task figure from OpenAI's own Codex evaluations — at maximum effort, roughly on par with GPT-5.6 Sol's cost per task while using about a third of the tokens — which suggests Astra's savings come more from token efficiency per turn than from a cache-pricing overhaul.
Who should use which
Matched to the technical differences above, not just the marketing
Reach for Astra when the target is a UI, not just a codebase
Tasks spread across apps without clean APIs — form-filling, CRM updates, reconciling a spreadsheet against a browser tab — are exactly what the OSWorld and Mind2Web numbers are measuring. Async tool calls and mid-turn steering matter most when a human is watching a long agentic run and needs to redirect it without starting over. The staged, cyber-vetted rollout is worth planning around if you need access on day one.
Reach for Fable 5.1 when the target is a large, unsupervised codebase
The always-on adaptive thinking and multi-day autonomous session design fit large refactors, dense-document analysis, and agent pipelines you'd rather review at the end than babysit step by step. If your workload is cache-heavy — a big repo or knowledge base read repeatedly across many turns — the $0.25/M cache-read price is the number that will actually move your bill, more than the headline benchmark chart will.
Strip away the launch-week framing and the real split is architectural: Astra optimizes for acting on the world outside a codebase — a browser, a CRM, a desktop — while Fable 5.1 optimizes for disappearing into one codebase or document set for days at a time. The safety story tracks the same split. Astra's Critical cybersecurity threshold is the cost of building a model that can act like an operator; Fable 5.1's Covered Model status and cyber-task routing to Opus is the cost of building one that can be trusted running unattended for longer stretches. Neither company's benchmark chart is lying, exactly — they're just each measuring the thing they optimized for.
— The Context Window model desk
Frequently asked questions
What is GPT-6 Astra's context window?
1,050,000 tokens total — roughly 922,000 input tokens plus a 128,000-token maximum output. Requests above 272,000 input tokens move to OpenAI's long-context pricing tier: 2x the input rate and 1.5x the output rate.
What is Claude Fable 5.1's context window?
1,000,000 tokens, including a 128,000-token maximum output, with text, image, and file/PDF input support.
Is GPT-6 Astra or Claude Fable 5.1 better for coding?
It's workload-dependent. Fable 5.1 is purpose-built for long, autonomous coding sessions and shows its largest gains on agentic benchmarks like AutomationBench and Terminal-Bench 4.0. Astra is a generalist and pulls ahead on tasks that leave the codebase entirely, like browser and computer use. On task-matched coding-agent evaluations cited by independent analysts, the two trade wins by benchmark rather than one model sweeping the board.
What is Claude Mythos 5.1?
The same underlying model as Claude Fable 5.1, with its full cybersecurity and biology capability retained instead of safeguarded down. Access is restricted to vetted organizations through Anthropic's trusted-access programs, including a Life Sciences Verification Program for biology researchers.
How much does Claude Fable 5.1 cost?
$10 per million input tokens and $50 per million output tokens, with cached input at $0.25 per million tokens — a 75% cut from Fable 5's cache-read price, aimed squarely at reducing the cost of long, cache-heavy agentic sessions.
Did GPT-6 Astra reach OpenAI's "Critical" cybersecurity threshold?
Yes — it's the first OpenAI model to do so under the company's Preparedness Framework, meaning it can independently discover and exploit previously unknown vulnerabilities in well-defended systems. OpenAI responded with a staged rollout, stricter isolation, checkpoint encryption, and monitoring of the model's reasoning traces.
