GPT-6 Astra vs Claude Fable 5.1: Complete Comparison and Report on Features, Pricing, Benchmarks, Context Window, and Access

4 minutes ago
33 min read

OpenAI released GPT-6 Astra on September 3, 2026. Anthropic made Claude Fable 5.1 generally available on September 1, 2026. Both list at $10 per million input tokens and $50 per million output tokens, both run a context window near one million tokens, and both cap output at 128,000 tokens.

Below the headline rate card they diverge on cache pricing, long-context billing, latency, safeguard architecture, and data retention terms: here we cover each of those, starting with what a general reader needs and moving into the technical detail an engineering or procurement team needs before committing to either model.

··········

RELEASE TIMELINE AND MODEL IDENTITY.

Official names, model identifiers, and sibling models.

........

Attribute	GPT-6 Astra	Claude Fable 5.1
Release date	September 3, 2026	September 1, 2026
Predecessor	GPT-5.6 Sol	Claude Fable 5
API model ID	gpt-6-astra	claude-fable-5-1
Amazon Bedrock ID	gpt-6-astra	anthropic.claude-fable-5-1
Restricted sibling	None disclosed	Claude Mythos 5.1
Higher tier variant	GPT-6 Astra Pro (ChatGPT only)	None
Retirement commitment	Not published	Not before September 1, 2027

........

Claude Mythos 5.1 runs the same weights as Fable 5.1 with more permissive safeguards. Access runs through the Cyber Verification Program and the Life Sciences Verification Program, both built with the US government and currently limited to a set of US organizations. Anthropic has published no separate pricing for it.

The safeguard gap is measurable: Mythos 5.1 scores 60.9% on Terminal-Bench 4.0 against Fable 5.1's 55.8%, because Fable routes some risky tasks to Claude Opus 4.8.

OpenAI names GPT-6 Astra Pro for ChatGPT Pro, Business, and Enterprise, but publishes no separate API model ID, price, or specification for it. Plus receives Astra, not Astra Pro. Anthropic has reclassified Claude Fable 5 as a legacy model, still served at $10/$50 with $1.00 cache reads.

··········

AVAILABILITY, ROLLOUT STAGES, AND ACCESS TIERS.

Surfaces serving each model, and what is gated.

........

Channel	GPT-6 Astra	Claude Fable 5.1
First-party API	Staged rollout	Available at launch
Amazon	Bedrock	Bedrock, Claude Platform on AWS
Google	Not listed	Google Cloud
Microsoft	Azure	Microsoft Foundry
Agent surface	Codex	Claude Code, Claude Cowork
Initial gating	Trusted Access Program organizations	None
Enterprise default	Off, admin enables per workspace	Available, never the default

........

Astra's rollout began with a limited set of organizations, then expanded to ChatGPT Plus, Pro, Business, and Enterprise over several days. Enterprise access is off at launch until an administrator enables it per workspace.

Anthropic's documentation directs teams to start on Claude Opus 5 and move to Fable 5.1 only when evaluations on Opus 5 at higher effort fall short. Claude Code requires v2.1.255 or later to run Fable 5.1, selected with /model fable, claude --model fable, or ANTHROPIC_MODEL=fable.

··········

SUBSCRIPTION ACCESS FOR CHATGPT AND CLAUDE USERS.

Plan-level access and the usage penalties attached to it.

........

Plan	ChatGPT	Claude
Free	$0, ad-supported, no Astra	Fable listed, capped
Entry paid	Go $8/month, no Astra	Pro $17/month annual, $20 monthly
Standard	Plus $20/month, Astra without the Pro variant	Max from $100/month
Power	Pro $100 and $200/month, Astra Pro	Max upper tier
Team	Business $20/seat annual, $25 monthly, 2-seat minimum	Team
Organization	Enterprise, custom, admin-enabled	Enterprise

........

On Claude consumer plans, Fable usage counts against roughly 50% of weekly limits, consuming the allowance about twice as fast as other models. It is never the default on any plan, and in Claude Code it may bill to usage credits instead of included limits depending on plan and seat tier.

ChatGPT Business Premium seats, launched August 2026, cost $100 per seat annually or $125 monthly, give 5x Standard usage, and remove the five-hour usage limit. Free and Go tiers carry ads following OpenAI's February 2026 rollout; Plus and above do not.

··········

API PRICING AND RATE STRUCTURE.

Full rate cards including cache tiers and processing modes.

........

Rate per 1M tokens	GPT-6 Astra	Claude Fable 5.1
Input	$10	$10
Output	$50	$50
Cached input read	$1.00	$0.25
Cache write	$12.50	$12.50 (5 min), $20 (1 hour)
Batch	50% of applicable rate	$5 input, $25 output
Fast mode	2x price, up to 2.5x speed	Not available
Blended (Artificial Analysis)	$7.70	$7.17

........

Astra cache reads cost four times Fable 5.1's. Anthropic prices cache hits on Fable 5.1 and Mythos 5.1 at 0.025x base input, against the 0.1x multiplier every other Claude model uses, and estimates the effect at roughly 25% lower cost on typical token-billed workloads and up to about 45% on highly agentic ones.

A worked case: a coding agent with a 200,000-token cached prefix over a 40-turn session, using the 1-hour cache, costs $15.80 on Fable 5 and $9.80 on Fable 5.1, a 38% reduction produced entirely by the cache-read line. The minimum cacheable prompt is 512 tokens; below that the discount does not apply and Fable 5.1 costs exactly what Fable 5 cost.

Astra Fast mode is unavailable with EU data residency, and Batch and Flex cost half the applicable rate. For internal comparison: GPT-5.6 Sol runs promotional rates of $4 input, $0.40 cached, $20 output through at least November 21, while Claude Opus 5 is $5/$25, Sonnet 5 $2/$10, and Haiku 4.5 $1/$5.

··········

CONTEXT WINDOW AND OUTPUT LIMITS.

Window sizes, input ceilings, and the long-context billing threshold.

........

Limit	GPT-6 Astra	Claude Fable 5.1
Context window	1,050,000 tokens	1,000,000 tokens
Maximum input	922,000 tokens	Not separately published
Maximum output	128,000 tokens	128,000 tokens
Knowledge cutoff	April 30, 2026	June 2026
Long-context premium	Above 272,000 input tokens	None
Extended output beta	Not available	Not available (Opus 5 and Sonnet 5 support 300K batch output)

........

Once an Astra request crosses 272,000 input tokens, OpenAI charges double the input and cache rates and 1.5x the output rate for the entire request, not only the tokens above the threshold. At standard rates that produces $20 per million uncached input and $75 per million output.

Fable 5.1 bills the full million-token window at standard per-token rates, so a 900,000-token request costs the same per token as a 9,000-token one. Astra's published knowledge cutoff of April 30, 2026 is not the same as its training-data cutoff, which OpenAI has not disclosed; Anthropic lists both dates for Fable 5.1 as June 2026.

··········

TOKENIZER DIFFERENCES AND EFFECTIVE COST PER TASK.

Why identical per-token prices do not produce identical bills.

Fable 5.1 uses the tokenizer introduced with Claude Opus 4.7, which produces roughly 30% more tokens for the same text than the pre-4.7 tokenizer. Cost comparisons against Claude Sonnet 4.6 or older models are not like-for-like. Roughly 555,000 English words fit in 1M tokens on the current Claude tokenizer.

Three factors decide which model bills less on a given workload:

Cache-hit share. Astra's $1.00 cache read is four times Fable 5.1's $0.25, so agent loops re-reading a large prefix favor Fable 5.1.
Input length distribution. Requests above 272,000 input tokens move an entire Astra request into the higher rate lane, which Anthropic does not charge for at all.
Output volume. OpenAI reports Astra using roughly 65% fewer output tokens than Claude Opus 5 on Agents' Last Exam, which cuts the $50 output line.

Anthropic has not published whether reasoning tokens bill at the output rate on Fable 5.1, which is unresolved for a model where thinking is always on.

··········

REASONING EFFORT CONTROLS AND COST LEVERS.

Effort levels, defaults per surface, and their measured effect.

........

Control	GPT-6 Astra	Claude Fable 5.1
Levels	low, medium, high, xhigh, max	Low, Medium, High
none setting	Not available	Not available
API default	low	high
Agent surface default	Not published	High in Claude Code
Consumer default	Not published	Medium on Claude.ai and Cowork
Mid-conversation change	configuration_update over WebSocket	Per-message effort beta

........

Anthropic reports Fable 5.1 at Low or Medium effort matching or beating Fable 5 at maximum effort, at roughly a quarter of the per-task cost on the science benchmark, which turns the effort dial into a cost control.

Astra's mid-turn steering adds instructions over a WebSocket without discarding completed work, and changes reasoning effort mid-conversation while preserving the prompt prefix. Fable 5.1's per-message effort beta changes effort partway through a conversation without invalidating the prompt cache.

··········

LATENCY AND THROUGHPUT PROFILES.

Measured speed and what it excludes.

........

Measure	GPT-6 Astra	Claude Fable 5.1
Output throughput	Not published	About 66 tokens per second
Time to first token	Not published	About 285 seconds (median across models: 3.35s)
Vendor latency rating	Not published	Slower, the slowest in the Claude lineup
OSWorld 2.0 task time	About 40 minutes (Sol: about 75)	Not published
Codex harness speed	1.9x Sol on Mind2Web	Not applicable

........

Fable 5.1's time to first token is measured by Artificial Analysis at roughly 285 seconds against a 3.35-second median across evaluated models. Adaptive thinking is always on and defaults to high effort on the API, so the model reasons for minutes before emitting output on hard prompts.

Astra's OSWorld figure of 40 minutes per task against Sol's 75 depends on the harness as well as the model, and the 1.9x Mind2Web speed claim combines Astra with an updated Codex harness rather than the model alone.

··········

BENCHMARK METHODOLOGY AND DATA PROVENANCE.

How the published numbers were produced.

Both launch tables are vendor-reported. OpenAI takes each model's best score at any reasoning effort, so the figures describe capability ceilings and not equal-budget comparisons. Research environments and production ChatGPT use different system prompts, tools, and inference settings.

Specific provenance issues, each disclosed by the party that ran the test:

ARC-AGI-3: Astra's 99.9% used a Responses API harness preserving reasoning state. ARC Prize's independent runs on the standard stateless harness produced 17% to 63% depending on reasoning tier, and a comprehensive run costs tens of thousands of dollars.
FrontierMath: Epoch AI, which maintains the benchmark, has disclosed that OpenAI funded its development and holds exclusive access to part of the problem set.
ScreenSpot-Pro and ExploitGym: OpenAI substituted the less-restricted Mythos configuration for Fable in its comparison rows.
ExploitBench and ExploitGym: run with production safeguards removed to measure raw capability, and ExploitGym ran without its six-hour limit.
Terminal-Bench-Science: Anthropic reports a standard error of 3.5 to 4.5 points per model.
Anthropic's own table: tasks blocked by safeguards scored zero, with cyber work completed by Opus 4.8 and biology work by Opus 5, which lowers rather than inflates the reported Fable figures.
OpenAI's prose reports 57.9% on Terminal-Bench 4.0 while its table reports 57.7%.

Anthropic published no SWE-bench Verified, GPQA Diamond, ARC-AGI, or tau-bench figures for Fable 5.1. The two vendors also contradict each other on Humanity's Last Exam with tools: OpenAI's appendix lists 65% for Sol and 63.8% for Fable 5.1, while Anthropic reports 65.0% for Fable 5.1 and publishes no Sol figure.

··········

REASONING AND KNOWLEDGE BENCHMARKS.

Academic and general-capability scores.

........

Benchmark	GPT-6 Astra	Claude Fable 5.1
Artificial Analysis Intelligence Index	61.2	65.7
FrontierMath Tier 4 v2	97.6%	87.8%
GPQA Diamond	96.0%	93.7%
Humanity's Last Exam, with tools	57.2%	65.0% (Anthropic) / 63.8% (OpenAI)
Humanity's Last Exam, no tools	Not published	60.9%
GDPval-AA v2 (Elo)	Not published	1853

........

Astra leads on competition mathematics and graduate-level science questions, while Fable 5.1 leads on the composite Artificial Analysis index and on tool-augmented reasoning. Artificial Analysis places Fable 5.1 first out of 196 models on its Intelligence Index at 66, against 63.1 for Opus 5 and 62.1 for Fable 5. On GDPval-AA v2, Fable 5.1's 1853 Elo sits above Opus 5's 1824 and Fable 5's 1723.

··········

AGENTIC CODING AND TERMINAL BENCHMARKS.

Multi-step engineering and command-line work.

........

Benchmark	GPT-6 Astra	Claude Fable 5.1
Terminal-Bench 4.0	57.7%	55.8% (Mythos 5.1: 60.9%)
Terminal-Bench-Science 0.1	64.6%	52.6%
CursorBench 3.2.0	Not published	73.4%
FrontierCode Extended	64.5%	Not published (Fable 5: 64.9%)
FrontierCode 1.1 Main	53.3%	Not published (Fable 5: 53.5%)
DeepSWE v1.1	74.1%	Not published (Fable 5: 69.9%)
AA Coding Agent Index	67	Not published (Fable 5: 68.1)
SRE-Bench pass@1	88.0%	Not published

........

Terminal-Bench-Science 0.1 produced the largest single jump in either release: Fable 5.1 reaches 52.6% against 24.7% for Fable 5, 29.0% for Opus 5, and 22.4% for GPT-5.6 Sol. Astra's 64.6% on the same benchmark exceeds all of them.

Astra trails Fable 5, the previous generation, on FrontierCode Extended at 64.5% against 64.9%, on FrontierCode 1.1 Main at 53.3% against 53.5%, and on the Artificial Analysis Coding Agent Index at 67 against 68.1. SRE-Bench, which measures reverse-engineering binaries without source, gives Astra 88.0% pass@1 and 99.2% pass@4 against Sol's 55.9%.

··········

COMPUTER USE AND TOOL EXECUTION.

Desktop operation, UI grounding, and agentic task completion.

........

Benchmark	GPT-6 Astra	Claude Fable 5.1
OSWorld 2.0 partial	72.6%	77.9%
OSWorld 2.0 strict	Not published	41.7%
ScreenSpot-Pro	92.7%	Not published (Fable 5: 87.3%)
Agents' Last Exam	59.3%	Not published
AutomationBench	41.4%	31.4%
BenchCAD geometric overlap	95.9%	Not published

........

The OSWorld comparison between these two models is not valid. Anthropic scored Fable 5.1 on the benchmark authors' August 2026 task release, which is not comparable to previously published OSWorld 2.0 results, and both Fable models took zeros on tasks where safeguards intervened.

Astra's ScreenSpot-Pro row uses the Mythos configuration for the Claude comparison rather than Fable. On Agents' Last Exam, Astra uses roughly 65% fewer output tokens than Opus 5 while scoring 59.3% against Opus 5's 55.5%.

··········

LONG-CONTEXT RETRIEVAL RELIABILITY.

Where the million-token window holds.

........

Band	GPT-6 Astra	GPT-5.6 Sol
MRCR v2 8-needle, 256K to 512K	100%	91.5%
MRCR v2 8-needle, 512K to 1M	96.3%	73.8%

........

Anthropic published no MRCR figures for Fable 5.1, so no direct comparison exists on retrieval reliability at depth. Astra's 96.3% in the 512K to 1M band is the only published evidence that either model's advertised window holds up under multi-needle retrieval, and it sits against a 272,000-token billing threshold that doubles input cost for any request using it.

··········

CONTEXT PERSISTENCE AND SESSION CONTINUITY MECHANISMS.

How each model handles a full context window and mid-task changes.

Astra replaces repeated summarization in Codex with searchable notes preserved across context windows. Earlier windows stay searchable, so a requirement or test result from an earlier message remains retrievable even when the note did not capture it. The feature is enabled in config.toml and OpenAI states it will become the default for Astra.

Astra also accepts mid-task steering without discarding original constraints, where earlier models treated a steering message as a new goal.

Fable 5.1 binds thinking blocks to the producing model. It reads earlier models' thinking blocks; no earlier model reads its own. A router that switches models mid-conversation drops those blocks silently, and they are not billed and do not count toward input_tokens.

Modifying anything before a Fable 5.1 thinking block, whether the system prompt, the tools array, or an earlier message, invalidates every thinking block after it and errors on the next request. This is enforced for accounts created on or after August 31, 2026, so conversations must be treated as append-only.

··········

AUTONOMOUS RUN DURATION AND FAILURE RECOVERY.

Documented long-horizon behavior, all vendor-supplied.

Anthropic's early-access partners reported the following runs:

Ramp: a single unattended 38-hour machine learning run that diagnosed an earlier result as a label artifact, corrected it, launched 6 parallel experiments overnight, and returned with a result and next steps.
MongoDB: a prototype built in roughly 3 days, where the model researched services code and documentation, produced a design, then ran unattended for hours with verification loops.
Millennium: a roughly one-in-a-million crash unexplained for 4 to 5 years, traced by disassembling an external vendor library and matching it against the core dump.

Fable 5.1 also trained a neural network producing a new elevation map covering a third of Venus from NASA Magellan radar imagery, resolving features at 2 to 3 kilometers instead of 10 to 20, with heights up to 25% more accurate, released on Zenodo under Creative Commons. The protein binder and GPU kernel results in Anthropic's announcement came from Mythos 5.1, not Fable 5.1.

OpenAI's comparable demonstration is narrower: GPT-5.6 Sol built a personal career website autonomously in 13 minutes 15 seconds, while Astra paused after 20 seconds to ask what career the user was moving into. In Codex, Astra asks asynchronously, continuing work that does not depend on the reply.

Anthropic states its automated behavioral audit has limited visibility into very long-context and multi-agent settings, which is the regime a 38-hour run occupies.

··········

MULTIMODAL INPUT AND TOOL SUPPORT.

Accepted modalities and available tools.

........

Capability	GPT-6 Astra	Claude Fable 5.1
Text input	Yes	Yes
Image input	Yes	Yes
File input	Not specified	Yes
Output	Text	Text
Native image, video, audio generation	Not supported	Not supported
Hosted tools	Web search, code interpreter, hosted shell, apply-patch, computer use, MCP	Web search and platform tools
Fine-tuning	Not supported	Not applicable
Embeddings	Not supported	Not applicable
Realtime and Assistants	Not supported	Not applicable

........

Astra ships with a hosted shell, apply-patch, and computer use alongside web search and code interpreter, with MCP support. Tool calling requires the Responses API, since Chat Completions does not support it.

··········

API MIGRATION REQUIREMENTS AND PARAMETER CHANGES.

Breaking changes on both sides.

GPT-6 Astra:

Remove temperature, top_p, and top_logprobs. Chat Completions also removes logprobs.
Moving from GPT-5.5 or earlier, replace prompt_cache_retention with prompt_cache_options.ttl set to 30m.
Use Responses, not Chat Completions, for tool calling.
Asynchronous tool calling is new: the model issues a tool call, continues reasoning on independent work, and consumes the result later under the original call_id.

Claude Fable 5.1:

tool_choice of type any or tool returns a 400 invalid_request_error. Only auto and none remain, and the same validation applies to the token-counting endpoint.
Replacements: keep tool_choice auto with strict set to true, move the schema to structured outputs, or instruct the model in the prompt.
Thinking blocks bind to the producing model and to the conversation prefix.
New betas: per-message effort, turn-scoped system messages with clear_at set to next_user_message, and readable progress updates with thinking.display set to updates.

Behavior changes on Fable 5.1 requiring no code change but affecting evaluations: fewer parallel tool calls per turn, fewer progress updates, more answers from memory at low effort instead of searching, denser prose with less formatting, more likely to reproduce source passages without marking them as quotations, and more likely to rewrite a whole file when a targeted edit would suffice.

New Anthropic API accounts can no longer edit prior context while preserving the transcript of earlier thinking, an anti-distillation measure Anthropic states will apply to all accounts with future releases.

··········

SAFETY CLASSIFICATIONS AND CAPABILITY GATING.

Preparedness ratings, gating programs, and operational friction.

........

Dimension	GPT-6 Astra	Claude Fable 5.1
Cybersecurity	Critical	Vulnerability discovery permitted, exploit development blocked
Biological and chemical	High	Not separately published
AI self-improvement	Below High	Not published
Gating program	Daybreak, Trusted Access	CVP and LSVP via Mythos 5.1
Blocked work routing	Task stops on API	Redirected to Opus models
Monitoring	Universal on tool use	Prompt-injection hardened

........

Astra is the first model OpenAI has rated Critical for cybersecurity capability. The rating describes measured capability, not production behavior: the shipping system refuses advanced exploit generation and places tool use under universal monitoring. In ChatGPT or Codex a user may be asked to review an action; on the API a triggered task stops outright.

Alignment figures from OpenAI, all internal: 2.4% on its computer-use safety benchmark where lower is better, against 22.0% for Sol, 9.5% for Fable 5.1, and 11.5% for Opus 5. Misaligned-outcome rate without a confirmation policy is 3.4% against Sol's 18.8%. Across a simulation of more than 54,000 Codex tasks, roughly half as many higher-severity misalignment flags as Sol. On an impossible cyber task without production safeguards, 0% unauthorized-target behavior against 48% for Sol.

OpenAI also documents a regression: chain-of-thought monitorability is lower than Sol's under adversarial testing, and UK AISI found Astra could evade monitoring under adversarial prompting. OpenAI spent at least 200,000 A100-equivalent GPU-hours on one measured portion of red teaming.

On Fable 5.1, penetration testing, exploit generation, binary-based vulnerability scanning, and life sciences R&D redirect to Opus models. Anthropic reports the newest cyber safeguards blocking 60% fewer false positives and roughly 60% fewer interventions per session in Claude Code, and biology safeguards firing 85% less often on benign elementary questions. Anthropic measured agentic safety on Mythos 5.1 and reports it as the hardest model it has released to break on an external prompt injection benchmark.

··········

DATA RETENTION, COMPLIANCE, AND ENTERPRISE TERMS.

Retention terms, regional constraints, and regulatory obligations.

........

Term	GPT-6 Astra	Claude Fable 5.1
Zero data retention	Available for eligible API customers	Not available unless expressly authorized
Standard retention	Not published	30 days
Covered Model status	Not applicable	Yes
EU data residency	Supported, excludes Fast mode	Not published
Output watermarking	Not published	Yes, models released after August 2, 2026
Forthcoming	Not published	Enterprise Frontier Safeguards, phased from fall 2026

........

Fable 5.1 and Mythos 5.1 carry 30-day data retention and are not available under zero data retention unless Anthropic expressly authorizes it. Both are Covered Models.

Enterprise Frontier Safeguards stores customer data on the customer's own cloud infrastructure with human review performed by the customer by default. Anthropic built it with more than 100 customers and its cloud partners, and it arrives in phases covering Claude Code, Claude Enterprise, the Claude Platform, Amazon Bedrock, Google's Agent Platform, and Microsoft Foundry.

Anthropic watermarks output from models released after August 2, 2026 under the EU AI Act Code of Practice on Transparency of AI-Generated Content, with a detection API in private preview. Astra's zero data retention applies to eligible API customers, a qualification OpenAI does not define publicly.

··········

WORKLOAD ALLOCATION CRITERIA.

Where each model bills less and completes more.

Astra fits computer use, reverse engineering, scientific terminal work, and retrieval across hundreds of thousands of tokens, with the constraint that any request above 272,000 input tokens doubles input cost and raises output cost 50% for the whole request.

Fable 5.1 fits cache-heavy agent loops, where the $0.25 cache read produces the 25% to 45% saving Anthropic documents and the worked 200,000-token example reproduces at 38%. It does not fit anything with a human waiting, given a 285-second time to first token.

Neither model is a default. OpenAI's own launch table shows Astra trailing on the Artificial Analysis Intelligence Index, the Coding Agent Index, FrontierCode Extended, and Humanity's Last Exam with tools, and GPT-5.6 Sol remains at $4/$0.40/$20 through at least November 21. Anthropic's documentation directs teams to Opus 5 at $5/$25 and moderate latency unless evaluations at higher effort fall short.

A useful evaluation records completed-task success, elapsed time, uncached and cached input, output tokens, tool-call cost, retries, safety-stop rate, and human-review time across at least two reasoning efforts on each model. The model with the higher token rate can cost less per solved task, and safety stops on Astra terminate API tasks outright, which belongs in the cost model alongside accuracy.

··········

RATE LIMITS, THROUGHPUT CEILINGS, AND PRODUCTION CAPACITY.

The nominal token price says little about how much traffic each model can actually sustain under production load.

OpenAI and Anthropic use materially different capacity models.

Astra exposes a combined tokens-per-minute ceiling alongside requests per minute and a separate Batch queue allowance.

Fable separates requests, uncached input throughput, and output throughput, then makes prompt caching part of the rate-limit equation itself.

........

Limit	GPT-6 Astra	Claude Fable 5.1
Entry production tier	Tier 1	Start
Requests per minute	500	1,000
Input/token throughput	500,000 TPM combined	500,000 uncached ITPM
Output throughput	Included in TPM	100,000 OTPM
Highest published standard tier	Tier 5	Custom above standard tiers
Highest published Astra TPM	40,000,000	Custom
Highest published Astra RPM	15,000	Custom
Batch queue at entry tier	1.5M tokens	200,000 batch requests in processing queue
Largest published Astra Batch queue	15B tokens	Custom
Cached input counted against normal input limit	Combined TPM framework	No, for Fable cache reads
Fable bucket shared with predecessor	—	Yes, Fable 5.1 and Fable 5 share the Fable pool

........

Astra scales sharply by usage tier.

Tier 2 increases capacity to 5,000 RPM and 1M TPM.

Tier 3 retains 5,000 RPM but moves to 2M TPM and increases its Batch queue from 3M to 100M tokens.

Tier 4 provides 10,000 RPM and 4M TPM.

Tier 5 reaches 15,000 RPM, 40M TPM, and a 15-billion-token Batch queue.

Claude's standard Start tier gives the combined Fable 5.x pool 1,000 RPM, 500,000 uncached input tokens per minute, and 100,000 generated output tokens per minute.

Anthropic uses a token-bucket limiter, so capacity replenishes continuously instead of resetting at discrete minute boundaries, and short traffic spikes can therefore hit a limit even when the one-minute average appears acceptable.

The cache behavior changes the practical comparison substantially.

For Fable 5.1, cache_read_input_tokens do not consume ITPM.

Only new uncached input and cache writes count.

Anthropic gives a concrete example in which a nominal 2M ITPM allowance can effectively process 10M total input tokens per minute at an 80% cache-hit rate because 8M of those tokens are cache reads.

This means an agent repeatedly reading a 200,000-token repository, policy manual, or document corpus can have an effective Claude throughput many times higher than its headline ITPM number suggests.

The capacity comparison therefore has to be performed on the actual workload.

For short independent requests with limited prefix reuse, the published limits are reasonably representative.

For long-running agents dominated by a stable cached prefix, Fable 5.1's capacity model becomes much more favorable than a direct 500K-versus-500K comparison suggests.

Neither vendor's published rate limit is an SLA or guaranteed minimum capacity.

Anthropic explicitly characterizes its limits as maximum allowed usage, and OpenAI similarly defines Astra's values as usage-tier limits rather than guaranteed throughput.

··········

PROMPT CACHE ARCHITECTURE, TTL, AND INVALIDATION.

Cache economics depend on what remains reusable after tools, instructions, documents, and conversation state change.

The two models have the same $12.50 price for the shortest cache write but radically different cache-read economics.

........

Cache property	GPT-6 Astra	Claude Fable 5.1
Base uncached input	$10 / MTok	$10 / MTok
Cache write	$12.50 / MTok	$12.50 / MTok for 5 min
Longer cache write	30-minute Astra TTL configuration	$20 / MTok for 1 hour
Cache read	$1.00 / MTok	$0.25 / MTok
Read multiplier vs base input	0.10x	0.025x
Minimum cacheable Fable prefix	—	512 tokens
Images/documents cacheable	Platform-dependent prompt cache	Yes
Tool definitions cacheable	Yes through stable prompt prefix	Yes
Tool results cacheable	Conversation-state dependent	Yes
Cache reads reduce Fable ITPM consumption	—	Yes

........

Astra introduces billed cache writes at 1.25 times its ordinary input rate.

Its migration guidance replaces the older retention mechanism with prompt_cache_options.ttl: "30m" and explicitly recommends preserving stable request prefixes when reasoning effort changes so the application does not unnecessarily destroy cache reuse.

Fable 5.1's five-minute cache write costs the same $12.50 per million tokens, but the subsequent hit falls to only $0.25 per million.

The one-hour cache costs $20 per million tokens to create.

Anthropic prices the Fable 5.1 cache hit at only 2.5% of normal input pricing, compared with the 10% multiplier used by most other Claude models.

The prompt hierarchy is also explicit.

Claude caches the prefix in this order:

· tool definitions;

· top-level system content;

· message history.

A change earlier in that hierarchy invalidates the affected section and everything that follows it.

Changing tool definitions can therefore destroy reuse of the system and message prefix.

Changing system content can invalidate subsequent message caching.

Editing an earlier message invalidates the cache from that point forward.

The set of cacheable Claude content is unusually broad.

Text messages, images, documents, tool definitions, tool calls, and tool results can all participate in prompt caching.

Fable 5.1 requires only 512 tokens before a prefix becomes eligible.

There is one important concurrency rule.

A newly written Claude cache entry becomes usable only once the first response has begun.

If several workers simultaneously submit the same uncached prefix, launching every request at once can cause several full-price cache writes instead of one write followed by cheap hits.

For parallel agent systems, the first request can therefore act as a cache warmer before fan-out.

At Fable 5.1 prices, a cached 200,000-token prefix costs $2.50 to create with the five-minute cache and only $0.05 to read afterward.

The same 200,000 tokens read from Astra's cache cost $0.20 per reuse.

At forty reuses, that is roughly $2.00 of Fable cache reads versus $8.00 of Astra cache reads before accounting for the initial write.

The difference is large enough that cache topology can matter more than the identical $10/$50 headline rate.

··········

STRUCTURED OUTPUTS, JSON SCHEMA, AND MACHINE-READABLE RELIABILITY.

Both models can produce schema-constrained output, but structural validity and factual correctness remain separate problems.

........

Capability	GPT-6 Astra	Claude Fable 5.1
Structured JSON	Yes	Yes
JSON Schema constrained output	Yes	Yes
Strict function/tool argument schema	Yes	Yes
Streaming structured output	Supported	Supported
Plain legacy JSON mode	Available through API framework	Structured outputs preferred
Schema guarantees factual correctness	No	No
Claude citations + strict JSON output together	—	Incompatible

........

Astra supports Structured Outputs through JSON Schema.

The API distinguishes this from older JSON-only modes: valid JSON only guarantees syntax, while Structured Outputs constrain the result to the supplied schema.

Custom Astra functions can also be declared with strict: true, constraining function arguments to the developer's schema.

Claude separates final-output validation from tool-input validation.

output_config.format constrains the final JSON response.

strict: true on a tool definition applies grammar-constrained sampling to the tool call, guaranteeing that the selected tool receives schema-valid parameters.

The distinction is operationally important.

A valid structure can still contain a wrong number.

A schema can enforce:

· invoice_total is numeric;

· currency belongs to an enum;

· every required field exists;

· arrays and nested objects have the expected structure.

It cannot guarantee:

· that invoice_total was calculated correctly;

· that the correct invoice was selected;

· that a recommendation is justified;

· that a URL or citation supports the associated claim.

A production evaluation should therefore record at least two rates:

schema compliance rate and semantic acceptance rate.

Claude has an additional incompatibility worth documenting.

Native citations interleave citation blocks with text, while strict JSON output requires grammar-constrained structured output.

Anthropic therefore rejects a request that combines citations with output_config.format.

A grounded application that needs both validated JSON and source traceability may need two stages: one grounded research stage with citations, followed by a separately validated transformation into a structured schema.

··········

TOOL SELECTION, FUNCTION CALLING, AND PARALLEL EXECUTION.

Correctly formatted tool arguments are only useful if the model selects the right tool and calls it at the right time.

Astra's Responses API exposes one of the broader tool surfaces in the current model market.

Its supported hosted and external mechanisms include web search, file search, image generation, code interpreter, hosted shell, apply patch, computer use, Skills, MCP, tool search, and custom function calling.

The Responses API can allow parallel tool calls.

Astra also introduces asynchronous function execution: an eligible custom tool can be marked asynchronous, the model can issue the call, continue work that does not depend on the result, and later incorporate the returned value through the original call identifier.

This matters when tool latency is heterogeneous.

A database query taking 20 seconds no longer has to freeze a parallel document analysis or unrelated code inspection.

The gain depends on whether the task graph contains genuinely independent work.

Fable 5.1 takes a stricter position on forced tool selection.

tool_choice: "auto" and none remain available, but the former forced-selection modes any and explicit tool are rejected with a 400 invalid_request_error.

Strict tool use still guarantees valid arguments when Fable chooses a function.

The application therefore has to distinguish four different questions:

· Did the model call a tool when one was needed?

· Did it choose the correct tool among similar candidates?

· Were the arguments schema-valid?

· Were the arguments semantically correct?

Only the third of those is solved by strict JSON-schema enforcement.

Tool-selection benchmarking should deliberately include overlapping functions.

A set containing search_customer, search_invoice, get_invoice, update_invoice, and issue_refund provides a more realistic test than a benchmark where only one obvious function exists.

··········

ERROR CLASSES, RETRIES, AND RECOVERABLE FAILURES.

Production reliability depends on what happens after the first request fails.

Claude exposes distinct classes for malformed input, access failures, unavailable resources, conflicts, payload limits, rate limiting, timeouts, internal errors, and overload conditions.

Of particular operational importance:

· 429 rate_limit_error can carry a retry-after value;

· traffic can also hit acceleration limits when load rises too abruptly;

· 504 timeout_error identifies a request that exceeded the processing window;

· 529 overloaded_error indicates temporary service-side saturation.

A monthly spend-cap failure deserves separate handling.

Anthropic can return a 429 when the organization exhausts its usage tier, but unlike an ordinary rate limit it carries no usable retry window because repeated requests will continue failing until the spend cap resets or is raised.

Workspace-configured spend limits can instead surface as a 400 invalid_request_error.

Treating every 429 identically would therefore produce pointless retries.

Streaming introduces another edge case.

An application can receive a successful HTTP connection and then encounter an error during the streamed response, so reliability cannot be inferred purely from the original HTTP status.

A mature agent needs error handling at the stream-event level as well as at request creation.

For Astra, the Responses API exposes explicit lifecycle states including queued, in_progress, completed, failed, cancelled, and incomplete.

The correct production metric is therefore broader than API uptime.

A useful run log records:

· initial-request failures;

· tool failures;

· rate-limit responses;

· overload responses;

· model-side incomplete responses;

· safety interruptions;

· automatic retries;

· manual retries;

· retries that successfully recover;

· retries that reproduce the same failure;

· duplicate external side effects caused by unsafe retry logic.

Neither vendor currently publishes a directly comparable Astra-versus-Fable 5.1 successful-recovery rate for realistic multi-tool workloads.

That remains an internal evaluation requirement.

··········

STREAMING, MID-TURN STEERING, AND TIME TO USEFUL OUTPUT.

First-token latency is insufficient for models that may reason for minutes or continue working while instructions change.

Both systems stream responses, but Astra adds an important long-running-agent primitive.

Over a Responses API WebSocket connection, a new instruction can be inserted while Astra is already working.

Completed work remains available and the model continues from the existing run rather than requiring the application to discard the task and reconstruct the entire prompt.

Astra can also receive a configuration_update that changes reasoning effort during a conversation without rewriting the original request prefix.

This preserves cache reuse while allowing difficult turns to use more reasoning and routine follow-ups to use less.

Fable 5.1 supports readable progress updates between tool calls through a beta thinking.display: "updates" capability.

Its default reasoning configuration is adaptive thinking at high effort, and Anthropic classifies its comparative latency as slower.

The latency benchmark should consequently record several timestamps rather than one:

· request accepted;

· first progress event;

· first user-useful content;

· first usable tool result;

· final answer;

· final accepted task completion.

A model that starts streaming at second two but requires three corrections can be slower in practice than a model that starts visibly responding at second twenty and finishes correctly.

For autonomous work, time to accepted result is the more useful latency metric.

··········

DETERMINISM, SNAPSHOTS, AND REPRODUCIBILITY.

Reproducibility now depends more on model pinning and repeated evaluation than on classical sampling controls.

Astra removes several controls traditionally used to manipulate output variance.

Its migration guidance requires developers to remove temperature, top_p, and top_logprobs; Chat Completions also loses logprobs for Astra.

OpenAI instead exposes model snapshots as the mechanism for locking a specific model version so that model behavior does not silently move with a changing alias.

Fable 5.1 likewise needs to be evaluated as a pinned model configuration rather than as a temperature-tuned conventional chatbot.

Its adaptive reasoning is always enabled, with effort acting as the principal depth control.

Reproducibility still does not mean identical bytes.

Real applications contain other moving components:

· search results change;

· external APIs return changing data;

· tool execution can be nondeterministic;

· safety classifiers can intervene differently at the margins;

· multi-agent scheduling can change task order;

· concurrent calls can finish in a different sequence.

For audit-sensitive deployments, the correct experiment is repeated identical execution under a frozen environment.

Record the same model version, same effort, same prompt, same documents, same tool definitions, same tool outputs where possible, and then run enough repetitions to measure:

· final-answer variance;

· numerical variance;

· selected-tool variance;

· number of tool calls;

· completion time;

· total token cost;

· decision disagreement rate.

A model can have an excellent average benchmark score while remaining undesirable for a workflow where one run in twenty makes a materially different decision.

··········

CONTEXT COMPOSITION AND REAL TOKEN ACCOUNTING.

A one-million-token window is not one million tokens of free user-document space.

The working context is shared by several classes of information.

A real agent may simultaneously carry:

· system and developer instructions;

· tool definitions;

· conversation history;

· documents;

· image representations;

· tool calls;

· tool results;

· reasoning state;

· summaries or compaction state;

· output already generated.

Claude exposes separate accounting for input_tokens, cache_creation_input_tokens, and cache_read_input_tokens.

Anthropic explicitly states that total input is the sum of those three fields.

The distinction matters because input_tokens alone can look tiny.

Anthropic's example of a cached 200,000-token document plus a new 50-token question reports approximately 50 uncached input tokens even though the model is working over 200,050 input tokens in total.

Astra similarly reports cached input separately and exposes reasoning-token details in response usage.

Its 1.05M advertised context therefore has to accommodate all of the state retained for the request, not only the user's source documents.

This creates a practical concept that is more useful than nominal context:

effective payload capacity.

Effective payload capacity is the amount of source material that remains after fixed prompt overhead, tool schemas, conversation state, safety/system instructions, reasoning-related state, and the required output reserve are taken into account.

Large tool catalogs can make this especially relevant.

A tool-oriented agent with hundreds of function definitions may sacrifice a meaningful amount of context before the first user document is read.

··········

LONG-OUTPUT RELIABILITY AND THE 128K CEILING.

Maximum output capacity does not prove that output remains coherent near the maximum.

Both Astra and Fable 5.1 expose a nominal maximum of 128,000 output tokens.

Fable 5.1 does not participate in Anthropic's current 300K Batch-output beta that is available for selected Opus and Sonnet models.

The missing metric is output quality as length approaches the ceiling.

Neither launch package establishes a directly comparable curve for:

· omission rate after 20K, 50K, 80K, or 100K generated tokens;

· repetition frequency;

· broken JSON or malformed structured output at extreme length;

· reference consistency across very long reports;

· duplicate sections;

· forgotten constraints;

· code compilation rate after generating very large multi-file artifacts;

· premature termination before the requested structure is complete.

A 128K limit should therefore be treated as an API ceiling.

It should not be interpreted as evidence that a single 120,000-token generation is the optimal way to produce a large report or software artifact.

For high-value long outputs, staged generation plus explicit validation remains a separate engineering decision.

··········

FILE STORAGE, INGESTION, AND DOCUMENT-SCALE LIMITS.

The largest uploadable file and the largest model-readable request are different constraints.

........

File-system property	OpenAI	Anthropic
Maximum individual uploaded file	512 MB	500 MB
Total API file storage	2.5 TB per project	1 TB per organization
Upload rate	1,000/min per authenticated user	Separate Files API limits
Batch input file	200 MB JSONL	Message Batch request limits apply separately
File remains until deletion/expiry	Yes	Yes
Large uploaded file guaranteed to fit model context	No	No

........

OpenAI permits individual Files API uploads up to 512 MB and up to 2.5 TB of stored files per project.

The Files endpoint itself supports up to 1,000 uploads per minute per authenticated user.

Batch input is a separate constraint: its JSONL file is capped at 200 MB.

Anthropic allows files up to 500 MB and 1 TB of organization-level stored file capacity.

Files belong to the workspace that uploaded them, cannot be modified in place, and persist until deletion or their configured expiry.

The upload ceiling should not be confused with context capacity.

A 500 MB stored document can still contain far more text than Fable's 1M-token window.

Likewise, a 512 MB OpenAI file does not imply that Astra can directly ingest the entire file contents into one 1.05M-token request.

Large-document systems therefore need retrieval, chunking, filtering, or file-search architecture.

The more meaningful enterprise test is:

How much relevant information can the agent reliably recover from a file collection without loading the whole collection into context?

That should be measured separately from simple file-upload support.

··········

SOURCE GROUNDING, CITATION TRACEABILITY, AND PROVENANCE.

A research agent should be judged on whether the evidence actually entails the claim it cites.

Fable 5.1 adds content-provenance capabilities to the model generation stack, while Anthropic's document citation system can return citations tied directly to supplied source documents.

OpenAI's Responses architecture similarly supports source-bearing workflows through web search and file search, with organization usage measurable separately for those tools.

The presence of a citation object does not finish the problem.

A complete grounding test requires several separate measurements:

· citation validity — does the referenced source exist?

· citation entailment — does the source actually support the statement?

· citation completeness — are externally verifiable factual claims cited where needed?

· source quality — did the model choose an authoritative source over a low-quality derivative?

· contradiction handling — did it detect when two sources disagree?

· temporal validity — is a current claim supported by information that is still current?

· quote fidelity — did the model preserve the meaning of the source rather than subtly altering it?

This is particularly important for comparisons such as this one.

Vendor documentation, vendor benchmark tables, third-party benchmarks, pricing pages, and independent latency measurements have different evidentiary status and should not be collapsed into one undifferentiated set of “sources.”

··········

CODE EDITING GRANULARITY AND REPOSITORY-SCALE BEHAVIOR.

Coding benchmarks do not reveal whether a model modifies the smallest safe surface or rewrites unnecessary parts of a repository.

Anthropic explicitly documents behavioral differences in Fable 5.1 around file editing, task completion, scope, test coverage, tool-call batching, long outputs, and subagent use.

That matters because repository work has costs that pass/fail benchmark scores can hide.

A model can solve an issue while still producing a poor engineering change if it:

· rewrites an entire file where a six-line patch was sufficient;

· changes formatting in unrelated code;

· replaces existing abstractions unnecessarily;

· introduces dependency changes without need;

· touches generated files;

· passes the targeted test while causing unrelated regressions;

· removes comments or domain-specific guardrails.

A repository-scale comparison should therefore record more than whether the tests pass.

Useful metrics include:

files touched, lines added, lines removed, unrelated-diff percentage, tests added, tests passed, regressions introduced, number of repair loops, and human review minutes.

For Astra, apply patch, hosted shell, tool search, code interpreter, and the broader Codex workflow give it a substantial editing and validation surface.

For Fable 5.1, long-horizon agentic coding is one of Anthropic's explicit target workloads.

The useful benchmark is therefore not “which model can code?”

It is which model produces the smallest correct maintainable change for the same issue and how much reviewer work remains afterward.

··········

MULTI-AGENT ORCHESTRATION AND DELEGATION EFFICIENCY.

More agents can increase parallelism, but they also duplicate context, tools, searches, and reasoning.

OpenAI explicitly includes multi-agent orchestration among Astra's supported current-generation agent capabilities.

Anthropic's platform separately exposes managed Agents, Sessions, Environments, Deployments, and related agent infrastructure in addition to the Messages API.

Neither vendor currently publishes a controlled Astra-versus-Fable 5.1 scaling curve showing task quality and total cost as the number of workers increases.

That missing measurement matters.

A four-agent architecture can fail economically even when it finishes sooner if each worker independently rereads the same 300,000-token corpus, performs duplicate web searches, and then requires an expensive synthesis step.

Multi-agent evaluation should therefore record:

· number of workers created;

· amount of work actually executed in parallel;

· duplicated searches;

· duplicated tool calls;

· duplicated prompt context;

· disagreements between workers;

· cost of the coordinating model;

· time spent merging results;

· final correctness;

· total task cost.

A useful derived metric is:

parallelization efficiency = reduction in accepted-task wall time / increase in fully loaded cost.

A large agent tree is valuable when tasks genuinely decompose.

It is wasteful when the model delegates work that depends heavily on shared sequential state.

··········

OBSERVABILITY, USAGE TELEMETRY, AND COST ATTRIBUTION.

Enterprise adoption becomes much easier when usage can be traced back to the project, model, tool, and workload that generated it.

........

Observability dimension	OpenAI	Anthropic
Model usage reporting	Yes	Yes
Project/workspace grouping	Project	Workspace
API-key grouping	Yes	Yes
Model grouping	Yes	Yes
Web-search usage separately measurable	Yes	Cost/usage reporting
File-search usage separately measurable	Yes	Tool-dependent reporting
Inference geography dimension	Project residency / geography	inference_geo
Batch usage distinguishable	Yes	Yes
Cost reporting	Organization APIs	Usage & Cost API
Rate-limit telemetry	Usage-tier/API controls	Detailed headers + Rate Limits API

........

OpenAI exposes organization usage endpoints for separate workload classes rather than providing only one aggregate token total.

Web-search calls can be grouped by project, user, API key, model, and search context level.

File-search calls can be grouped by project, user, API key, and vector store.

This allows an engineering team to distinguish “model tokens were expensive” from “the agent performed too many searches” or “one project is responsible for most retrieval traffic.”

Anthropic's Usage and Cost APIs can report dimensions including model and inference geography, with administrative reporting designed for organization-level cost attribution.

Claude also exposes detailed rate-limit response headers for request, input-token, output-token, and priority-capacity headroom.

Those headers include remaining capacity and reset timing, which can be fed directly into adaptive traffic control.

This telemetry makes more sophisticated internal metrics possible:

· cache-hit percentage by workload;

· cost per team;

· cost per successful workflow;

· average retry cost;

· model-mix savings;

· retrieval/tool spend as a share of total task cost;

· Batch versus interactive spending;

· cost attributable to residency requirements;

· spend generated by failed runs.

Without that layer, teams tend to optimize the visible $/MTok line while missing larger savings elsewhere in the workflow.

··········

BATCH PROCESSING AND OFFLINE INFERENCE ECONOMICS.

A workload that can wait should not automatically be priced using interactive inference.

........

Batch property	GPT-6 Astra	Claude Fable 5.1
Batch discount	50%	50%
Batch input price	$5 / MTok	$5 / MTok
Batch output price	$25 / MTok	$25 / MTok
Standard input	$10 / MTok	$10 / MTok
Standard output	$50 / MTok	$50 / MTok
Fable requests per Message Batch	—	Up to 100,000
Astra Tier 1 queue	1.5M tokens	—
Astra Tier 5 queue	15B tokens	—
OpenAI Batch input file	200 MB JSONL	—

........

Both systems reduce standard Fable/Astra token prices by half for Batch processing.

This makes Batch the correct economic baseline for tasks such as:

· overnight document classification;

· extraction from large corpora;

· evaluation suites;

· dataset enrichment;

· bulk summarization;

· non-interactive code review;

· scheduled compliance checks;

· offline entity extraction.

Anthropic allows up to 100,000 individual requests inside one Message Batch, with separate queue constraints for outstanding batch requests.

Astra's Batch queue scales aggressively with usage tier, reaching 15 billion tokens at Tier 5.

The workload comparison therefore needs three lanes rather than one:

interactive Standard, latency-optimized processing, and offline Batch.

Comparing Fable Batch against Astra Standard, or the reverse, would obscure half of the economic difference before model quality is even considered.

··········

REGIONAL INFERENCE AND DATA-LOCATION COST.

Compliance constraints can change both price and available processing modes.

Claude 4.6-and-later models, including Fable 5.1, support an inference-geography distinction.

Global routing uses standard pricing.

US-only inference applies a 1.1x multiplier to input, output, cache-write, and cache-read prices on the first-party Claude API and Claude Platform on AWS.

That turns Fable's normal prices into approximately:

· $11 per million uncached input tokens;

· $55 per million output tokens;

· $13.75 per million five-minute cache-write tokens;

· $0.275 per million cache-read tokens.

The US geography does not create a separate rate-limit pool.

US and global Fable traffic draw from the same underlying rate limits.

OpenAI configures residency at the project layer, with project residency values including global, US storage and processing, EU storage and processing, and additional supported regional configurations.

For Astra, one particularly important operational limitation applies in Europe:

Fast and Priority processing are unavailable with EU data residency, so an EU-resident deployment cannot simply pay the Fast premium to recover the same latency profile.

The compliant price/performance comparison can therefore differ materially from the global public rate-card comparison.

An enterprise should evaluate the exact geography it is legally and contractually able to deploy.

··········

MODEL VERSIONING, RETIREMENT, AND CHANGE MANAGEMENT.

Model upgrades should be treated like production dependency upgrades rather than invisible backend changes.

Fable 5.1 currently carries an explicit lifecycle commitment.

It is Active and Anthropic states that retirement will occur no sooner than September 1, 2027.

Astra provides snapshot support for pinning a specific model release so that production behavior does not depend on an unpinned moving model reference.

The existence of a stable identifier does not eliminate the need for regression testing.

A model migration can change:

· reasoning depth;

· tool-selection tendencies;

· number of tool calls;

· cache behavior;

· formatting;

· safety intervention frequency;

· latency;

· coding style;

· source-selection behavior;

· token consumption.

A robust upgrade pipeline should therefore keep a frozen evaluation corpus containing representative production tasks.

Before changing the production model, rerun that corpus and compare:

task acceptance rate, latency, tokens, cache hit rate, tool calls, safety stops, human corrections, and total cost.

A model that scores higher on a new public benchmark can still be a regression for a particular production system.

··········

TOTAL COST PER SUCCESSFUL TASK.

The economically correct denominator is an accepted result, not one API invocation.

Astra and Fable 5.1 share the same $10/$50 headline Standard price, but their true task economics diverge immediately through caching, long-context pricing, residency, retries, tool usage, and completion reliability.

A practical model is:

Total task cost = fresh input + cache writes + cache reads + output + tools + searches + code execution + retries + duplicated agent work + human review + latency cost.

Then:

Cost per successful task = total cost across all attempts / number of accepted results.

Consider two hypothetical systems.

Model A costs $4.00 per attempt and produces an accepted result 95% of the time.

Its inference-only expected cost per accepted result is approximately:

$4.00 / 0.95 = $4.21.

Model B costs $3.50 per attempt but succeeds only 75% of the time.

Its corresponding cost becomes:

$3.50 / 0.75 = $4.67.

The supposedly cheaper model has become more expensive before adding reviewer time or retry latency.

Now add a human reviewer costing $60 per hour.

If Model A requires five minutes of correction per accepted task, review costs another $5.

If Model B requires twelve minutes, review costs another $12.

The difference in API spending becomes almost irrelevant.

Long-context economics make the same point.

Astra moves the entire request into higher pricing once input exceeds its 272,000-token threshold: input and cache rates double and output becomes 1.5 times the ordinary rate.

Fable 5.1 instead preserves standard per-token pricing across its published 1M window and can read cached context for only $0.25 per million tokens under global inference.

For a cache-heavy research or coding agent, that can dominate the economic result.

For a task where Astra uses fewer turns, fewer retries, or substantially fewer output tokens, the direction can reverse.

The only meaningful cost comparison is therefore workload-specific.

Recommended fields to collect for every evaluated task:

· accepted / rejected;

· wall-clock duration;

· fresh input tokens;

· cache-write tokens;

· cache-read tokens;

· output tokens;

· tool calls;

· paid searches or execution sessions;

· retries;

· safety stops;

· human correction minutes;

· final fully loaded cost.

The result is a model-selection study rather than a token-price comparison.

··········

WHAT THE PUBLIC BENCHMARKS STILL DO NOT MEASURE.

The largest remaining uncertainty sits in production behaviors that leaderboards rarely capture.

Published benchmark tables cover a surprisingly large range of reasoning, mathematics, coding, terminal work, computer operation, retrieval, and agentic tasks.

They still leave important questions unanswered.

There is currently no clean public Astra-versus-Fable 5.1 equal-budget benchmark establishing all of the following:

· schema-valid and semantically correct structured-output success across thousands of real schemas;

· correct-tool-selection rate when many overlapping functions exist;

· failure-recovery rate after malformed tool results, network timeouts, or overloaded external services;

· probability that a retry succeeds without duplicating side effects;

· repeated-run variance on the same frozen task;

· coherent performance after hundreds of tool calls;

· cache-hit rate in real conversations where tools and system context evolve;

· quality degradation as generated output approaches 128K tokens;

· repository regression rate after autonomous code changes;

· unnecessary-diff size during file editing;

· claim-level citation entailment accuracy;

· cost of contradictory multi-agent results;

· multi-agent scaling efficiency;

· accepted-task rate over hundreds of multi-hour autonomous runs;

· average human-review minutes required before production acceptance;

· fully loaded cost per accepted task.

These gaps should remain explicit rather than being filled with inferred superiority from unrelated benchmark scores.

The ideal enterprise evaluation freezes:

· model version;

· effort level;

· system instructions;

· tools;

· source documents;

· external-data snapshot;

· task definition;

· acceptance criteria.

Each model is then run repeatedly.

The evaluation records correctness, reproducibility, elapsed time, token classes, cache behavior, tool usage, retries, safety stops, human corrections, and fully loaded cost.

That is the point at which a frontier-model comparison becomes operational research rather than a leaderboard summary.

··········

·····

DATA STUDIOS

·····

[datastudios.org]