AI News

GPT-6.2 Astra vs Claude Fable 5.2: Benchmarks and real costs

GPT-6.2 Astra and Claude Fable 5.2 start at the same API price: US$8 per million input tokens and $40 per million output tokens. That does not make them equally expensive to use. In Artificial Analysis’s current Max-effort results, Astra costs $4.00 per benchmark task against Fable’s $26.54. Fable, however, leads the broad intelligence index, and a separate finance evaluation gives it both the higher score and the lower bill. Choosing between them requires looking at the work, the reasoning setting and the full cost of finishing it. Astra specifications; Claude pricing; AA Astra results; AA Fable results; Finance Agent results.

Our reading of the evidence is that Astra deserves an early trial for scientific terminal work, interactive 3D generation and workflows where reasoning cost matters. Fable deserves one for demanding software engineering, financial research and the highest broad capability scores. Neither recommendation means every task in that category goes to the same model.

Evidence checked November 17, 2026. This comparison concerns gpt-6.2-astra, released November 17, and claude-fable-5-2, released November 9. It does not substitute results from the older GPT-6 Astra. Not tested by Kingy: we did not run a private Astra-versus-Fable inference benchmark. We examined official specifications and independent evaluations, and recalculated the billing examples below. OpenAI launch; Anthropic launch.

The short decision guide

Which model deserves the first trial for your work?
Your priority Start by evaluating Reason and limitation
Broad maximum-effort capability Fable 5.2 Leads AA’s broad index and Vals Index in the configurations examined; the extra score can cost substantially more.
Complex coding in an existing repository Both AA’s leading retrieved configurations are within 0.1 percentage points, with different effort settings.
Scientific work in a terminal Astra 6.2 Leads the directly retrieved Vals Mini-SWE comparison; biological-data investigation is a counterexample favoring Fable.
Interactive 3D experiences Astra 6.2 Leads AA-3D’s human-preference ranking; this does not measure all visual or frontend work.
Financial research Fable 5.2 Higher Finance Agent score, lower cost and shorter recorded duration in Vals’ published run.
Very large prompts or repeated cached context Fable 5.2 No Astra-style 272K-input pricing threshold, and a lower cache-read rate; actual token counts and reasoning use still matter.
Existing Work/Codex or Claude workflows Your incumbent first Tool compatibility, permissions, context handling and migration work can outweigh a modest benchmark gap.

This is an editorial shortlist drawn from the evaluations discussed below, not a private test result. The practical purchase decision is which system produces an acceptable deliverable at a tolerable total cost.

Specifications: similar limits, different integration details

Documented model specifications, checked November 17, 2026
Specification GPT-6.2 Astra Claude Fable 5.2
Direct API model ID gpt-6.2-astra claude-fable-5-2
Context window 1,050,000 tokens 1 million tokens
Maximum input 922,000 tokens No separate maximum-input figure verified beyond the shared context limit
Maximum output 128,000 tokens 128K tokens
Documented knowledge cutoff May 18, 2026 June 2026 reliable/training cutoff
Native input/output Text and image input; text output Text and image input; text output
Reasoning settings Low, medium, high, xhigh, max; none rejected Five effort levels; adaptive thinking always on; high API default
Main API routes Responses and Chat Completions; tool calling requires Responses Messages API; partner-platform details vary
Weights and parameter counts Proprietary; parameter count undisclosed Proprietary; parameter count undisclosed
Fine-tuning Not supported Not verified in the sources examined
Published retirement commitment No comparable date verified here Not retired before November 9, 2027
Sources: OpenAI model specifications, OpenAI integration guide, Fable overview and Claude effort documentation.

Astra’s 1.05-million-token window is not permission to submit that much input and then generate another 128,000 tokens. Its separately stated input limit matters. On both systems, reasoning consumes output budget, so a maximum-output specification does not promise an equally long visible answer.

Context capacity also says little about reliable retrieval across a full repository, transcript collection or document archive. Tokens are not identical units of text across different tokenizers. A fair long-context comparison should use the same source files, check which facts each system recovers and record the separately billed token counts.

Neither base model is documented here as a native audio or video generator. An application may transcribe audio, sample video frames or call an image generator around it. Those are useful product features, but they should not be confused with the base model’s input/output specification. The same distinction applies to web access: a training cutoff and a search tool answer different questions.

OpenAI lists structured outputs, function tools, computer use, search, hosted shell, code interpreter, MCP and other integrations for Astra. Claude documents tools, structured outputs and computer use, with platform-specific restrictions. Feature names alone do not establish that the same workflow, permissions and recovery behavior work on every hosting platform. Astra tools; Fable changes.

How to read the benchmark tables

A model name is only the first part of an evaluation. The reasoning setting determines how much internal work it can attempt. The agent software determines what tools it receives, how it sees files and whether it can recover from an error. The grader determines whether partial progress counts. The timeout and fallback policy determine what happens when the preferred model cannot finish.

We therefore keep independent results separate from vendor claims, and retain the stated configurations. “Max” on two vendors’ APIs does not establish an equal compute budget. A score from Claude Code is not automatically comparable with one from Mini-SWE. An all-requirements pass rate is stricter than average rubric credit.

There is also an evidence-age problem. Astra launched on the day of this comparison. These tables record what the evaluator pages showed when checked, not months of production reliability. A leaderboard observation date need not be the date every underlying task was run.

Two details are especially relevant here. Artificial Analysis labels the Fable configurations below Default Fallback, meaning the delivered system can include fallback behavior. On our final check, Vals labels Fable High and Astra Max; it also warns that individual benchmarks may use different parameters. These are published service configurations, not an equal-compute comparison. AA Fable configuration; Vals Fable configuration.

Broad capability: Fable leads, with a substantial cost tradeoff

Two independent broad evaluations; scores use different scales
Evaluation Astra 6.2 Fable 5.2 What it measures
AA Intelligence Index v5.0.1, Max 62 65, Default Fallback Nine evaluations across knowledge work, coding, science and knowledge/reasoning tasks
AA cost per index task, Max $4.00 $26.54 Evaluator’s token-based cost accounting for that suite
Vals Index v2.2 67.66% ± 0.94 71.31% ± 0.96 Sector-weighted finance, coding, legal and tax tasks; uncertainty shown is one standard error
Vals cost per test $10.68 $17.94 Published aggregate for Vals’ configurations
Sources: AA Astra, AA Fable, AA methodology, Vals Astra, Vals Fable and Vals Index methodology.

The AA result supports a meaningful, limited conclusion: Fable reaches the higher broad index score in these maximum-effort configurations, while Astra is much less expensive per suite task. Our calculation puts Astra’s reported cost about 84.9% lower. That is not a promise to cut an organization’s AI bill by 84.9%.

AA’s index value of 62 is not 62% accuracy. Its component mix includes AA-Briefcase, AutomationBench-AA, Terminal-Bench 4.0, FrontierCode-AA 2.0, AA-Omniscience, GDP.pdf, HLE-Diamond, a hard subset of CritPt v2 and Terminal-Bench-Science. The composite is a way to summarize those measurements, not a general percentage of human work a model can perform.

Vals makes another set of choices. Its index weights sectors using economic shares and combines six private and two public tests. Science has a separate index. The 3.65-percentage-point Fable lead in Vals therefore answers a different question from the three-point AA lead. Neither should be pooled into a synthetic average.

For a high-value assignment, paying more for an increased chance of an acceptable answer can be sensible. For high-volume work, a lower-scoring configuration may be the better purchase if it clears the actual quality threshold. The broad indexes identify candidates; your acceptance test makes the economic decision.

Reasoning effort changes the comparison

AA effort sweep: index score, modeled inference time and weighted cost per task
Effort Astra index Astra minutes/task Astra US$/task Fable index Fable minutes/task Fable US$/task
Low 46 1.4 $0.66 54 5.4 $3.10
Medium 57 3.7 $1.62 56 6.8 $3.80
High 60 4.8 $2.07 62 14.6 $9.08
Xhigh 62 5.9 $2.52 62 25.5 $14.83
Max 62 10.4 $4.00 65 40.8 $26.54
Fable rows use Default Fallback. Costs are AA’s weighted benchmark estimates, not Kingy invoices or cost per accepted business deliverable. Sources: AA OpenAI effort table and AA Anthropic effort table.

The equal rounded Astra scores at Xhigh and Max do not prove identical underlying performance. They do provide a reason to test Xhigh before paying for Max on every task. AA records 27.1 million output tokens across the suite at Astra Xhigh against 65.8 million at Max. Fable Max reaches 275 million. Those totals describe the evaluator’s workload, not the length of a typical chat answer.

Fable’s low-effort index score is higher than Astra’s low-effort score, but the time figures differ substantially. Equal labels are not equal resource allocations. Even within one model family, more reasoning should be treated as a variable to evaluate rather than a universal upgrade.

OpenAI recommends medium as a starting point for new integrations. Anthropic documents high as Fable’s API default and describes Max as allowing unconstrained spending on reasoning. A sensible deployment can escalate difficult cases after a check fails, rather than send every routine extraction or formatting job to the largest setting. OpenAI effort guidance; Claude effort guidance.

Coding: a near tie in one demanding repository benchmark

Independent coding results, with configuration differences retained
Evaluation Astra 6.2 Fable 5.2
FrontierCode-AA 2.0 49.0%, Xhigh 49.1%, High Default Fallback; 48.8% at Max Default Fallback
Vals Terminal-Bench 4.0, Mini-SWE 63.13% ± 1.34 65.15% ± 2.31
Vals Vibe Code v1.1 89.90% ± 2.04 93.77% ± 1.15
Vals uncertainty is one standard error. Sources: FrontierCode-AA, Terminal-Bench 4.0 and Vibe Code.

FrontierCode-AA 2.0 is useful because it asks models to modify private repositories against maintainer-style requirements. AA describes 132 tasks, three runs per task, its Stirrup agent software and a 500-turn cap. Blocking failures and solution lookup receive zero credit; other work receives weighted rubric credit. That is a harder and more relevant question for many engineering teams than whether a model can write an isolated function.

The leading retrieved scores are too close to justify a confident coding winner, especially with different effort settings. Fable’s High configuration also slightly exceeds its Max configuration in this run. The result argues for measuring the settings you would deploy.

There is an easy attribution trap: Anthropic’s launch also reports 49.1% on FrontierCode 2.0, but at Xhigh in its own reported run. AA’s 49.1% is High Default Fallback in AA’s setup. The matching number does not make them the same experiment. Anthropic’s reported configuration.

Vals’ broader terminal result favors Fable on score, while Astra costs $4.69 per test against $14.56 and records 34 minutes 17 seconds against 55 minutes 7 seconds. Vibe Code tests web-app functionality; it is not a visual-design popularity contest. A team shipping interfaces should assess working behavior, accessibility and appearance separately.

For your own repository, score whether the patch passes the relevant checks, respects the existing design, avoids unrelated edits and can be reviewed. A convincing explanation cannot compensate for a failing migration or a change that breaks a neighboring feature.

Science: Astra’s lead depends on which scientific work you mean

Vals scientific evaluations in its published configurations
Evaluation Astra 6.2 Fable 5.2
Science Index v1 68.44% ± 2.13 63.74% ± 2.30
Terminal-Bench-Science, Mini-SWE 71.43% ± 5.44 55.71% ± 5.98
BioMysteryBench 80.74% ± 0.37 83.70% ± 0.74
MysteryMechanism 53.15% ± 3.36 51.80% ± 3.36
Uncertainty is one standard error. Sources: Science Index, Terminal-Bench-Science and the Astra/Fable result pages.

Vals’ Science Index averages biological-data investigation, discovery through simulated experiments and scientific terminal tasks. Astra’s aggregate lead coexists with Fable’s higher BioMysteryBench score. “Best for science” needs a narrower definition before it becomes useful advice.

The Vals terminal-science comparison is particularly informative because both rows use Mini-SWE on 70 tasks. Astra’s published cost is $11.08 per test against Fable’s $23.14, with durations of 47 minutes 41 seconds and 1 hour 35 minutes. Vals ran each task once per model. It retried provider or infrastructure failures, but did not rerun already graded tasks.

AA separately reports Astra at 78.1% at Max, 78.6% at Xhigh and 75.2% at High on Terminal-Bench-Science 0.1, averaging three repeats in Mini-SWE. Anthropic reports Fable at 74.6% using Claude Code. Putting Astra’s AA number beside Fable’s Claude Code number without the agent-software distinction would create a misleading head-to-head. AA methodology and Astra results; Anthropic’s results.

These tasks test useful research assistance, not the truth of a new scientific claim. Generated analyses still need valid data, correct assumptions and an independent check of the result. Anthropic’s ambitious demonstrations, including a large parallel-agent mathematics effort, show a possible workflow under supplied conditions. They are not evidence that a single ordinary chat can reproduce the outcome.

Vals professional-work results; one standard error shown
Evaluation Astra 6.2 Fable 5.2
Finance Agent v2.1 60.75% ± 2.12 69.47% ± 1.98
Excel Modeling v1.1 76.03% ± 2.24 77.38% ± 2.19
LegalResearchBench 42.79% ± 3.44 46.15% ± 3.46
Tax Agent Bench 21.84% ± 2.79 32.09% ± 3.37
HLAB-Vals 1.1 16.25% ± 3.08 5.00% ± 1.72
Sources: Finance Agent, Excel Modeling, Tax Agent, HLAB and the Astra/Fable model pages.

Finance Agent is a substantial exception to Astra’s efficiency story. The benchmark contains 449 held-out questions, six tools and a two-hour limit. Its scoring combines weighted partial credit with requirements that can disqualify an answer. Fable scores higher and costs $4.83 per test, compared with Astra’s $7.98. Vals records 3 minutes 28 seconds for Fable and 37 minutes 38 seconds for Astra. Those are the published durations; we have not established a causal explanation for that unusually large difference.

The financial result makes a blanket “Astra is cheaper per task” recommendation untenable. It is cheaper in several important suites, but the agent’s search and reasoning behavior can reverse the bill. A finance team should begin with the finance evidence, not import a software-engineering cost ratio.

Excel Modeling v1.1 adds another useful distinction. Fable’s displayed cost is $6.67 per test against Astra’s $2.80, but Fable finishes faster: 16 minutes 19 seconds versus 21 minutes 26 seconds. The benchmark recalculates formulas in Microsoft Excel and equally weights seven financial-model categories. It awards partial credit; a score near 77% does not mean a 77% chance of a client-ready workbook. Its investment-banking tasks also do not measure a campaign workbook plus a slide report. Excel results and grading.

Legal work illustrates another distinction. Searching for authorities, analyzing tax questions and preparing a complete legal deliverable have different failure modes. Fable leads the retrieved legal-research and tax rows; Astra leads HLAB-Vals. In HLAB, two model judges separately require every task criterion to pass, and the reported rate averages their task-pass judgments. The environment has internet disabled. A missing material requirement can fail the entire deliverable even when much of it is correct.

OpenAI also reports a strong Astra result on Harvey LAB-AA v1.1. That is a separate evaluation with a source-grounded hallucination check and its own all-criteria rule. It should not be treated as a replication of HLAB-Vals. The low task-pass percentages in these demanding tests are a reason to retain expert review, regardless of which model wins. LAB-AA methodology; HLAB-Vals methodology.

Visual and 3D work: Astra leads the preference test

Artificial Analysis’s AA-3D v1.0 places Astra Max at 1,318 Elo, with a 95% interval of 1,286–1,349. Fable Max Default Fallback scores 1,271 Elo, with an interval of 1,246–1,297. The test uses 55 prompts for interactive three.js experiences, an offline Stirrup environment and blind human comparisons. AA-3D results and methodology.

That gives Astra a credible reason to be the first trial for this kind of interactive visual creation. It does not mean Astra is “47% better”: Elo differences are not percentages of quality. Nor does it prove an advantage for brand design, image generation, document typography or every frontend task.

AA-3D and Vibe Code can favor different models without contradiction. One asks people which interactive scene they prefer; the other grades web-app functionality. A beautiful prototype and a functionally complete application are related deliverables with different acceptance criteria. If you need both, make both part of your trial.

Pricing: the equal headline rates hide important conditions

All prices below are US dollars per million tokens, before tools, storage, taxes or other separately billed services. Standard Astra prices in the first rows apply at or below 272,000 input tokens; its long-context row matters above that threshold.

Direct API pricing, checked November 17, 2026
Token or service category Astra 6.2 Fable 5.2
Standard fresh input $8 $8
Standard output $40 $40
Cache read $0.40 $0.20
Short cache write $10; 30-minute retention $10; five-minute retention
Longer cache write $20; 12-hour retention $16; one-hour retention
Batch input / output $4 / $20 $4 / $20
Fast input / output $16 / $80 $16 / $80
Ultrafast input / output $24 / $120 promotional; $48 / $240 from March 1, 2027 No directly equivalent named tier verified
Standard input over 272K tokens $16 fresh input; $0.80 cache read; $60 output $8 fresh input; $0.20 cache read; $40 output
Sources: Astra model pricing, OpenAI service pricing, Claude pricing and Fable Fast mode.

Astra’s introductory Ultrafast rate is three times Standard through February 28, 2027, Pacific time; the scheduled subsequent rate is six times Standard. That is an API price, not the same thing as the draw on a ChatGPT subscription’s included allowance.

OpenAI also lists eligible background completion windows with a 30% discount for two hours and 40% for eight hours in a public beta. Those windows are relevant to queued work, not a guarantee of interactive speed. We have not assumed that these discounts stack with Batch. Anthropic’s US-only inference option adds 10% to applicable token categories; partner-operated deployments can have their own prices. OpenAI pricing; Claude pricing conditions.

The 272K threshold can dominate a long-document bill

Above 272K input tokens, Astra reprices the whole request at the long-context rates. It does not charge the premium only on the tokens beyond the threshold. Fresh input doubles and output rises by 50%; cache writes also double. Fable’s documented million-token context uses the same base token rates throughout. Astra threshold; Fable long-context pricing.

Kingy’s equal-token billing calculations at Standard rates
One request Astra Fable
100K fresh input + 10K billed output $1.20 $1.20
500K fresh input + 10K billed output $8.60 $4.40
900K fresh input + 10K billed output $15.00 $7.60
100K already-cached input + 10K billed output $0.44 $0.42
Calculated from the linked rate cards. Billed output includes reasoning. These scenarios exclude cache writes, tools, storage and taxes; equal token counts do not imply equal document lengths across tokenizers.
Bills for 100K, 500K and 900K input plus 10K output: Astra $1.20, $8.60, $15; Fable $1.20, $4.40, $7.60.

For the 500K example, Astra’s input costs 0.5 × $16 = $8.00 and output costs 0.01 × $60 = $0.60. Fable costs 0.5 × $8 + 0.01 × $40 = $4.40. If your workflow routinely reads enormous case files or source archives, this is a more relevant starting calculation than the identical $8/$40 headline.

Fable’s cache reads cost half as much, but the final cached example saves only two cents because output dominates that particular bill. Cache writes and expiration also matter: the two vendors’ similarly priced write tiers have different retention periods. Estimate how often your shared prefix is reused before it expires, then include the write charge. “Half-price caching” does not mean a half-price workload.

Measure the cost of an acceptable result

A useful accounting formula is total spending on attempts divided by the number of deliverables that pass your acceptance criteria. Include failed attempts, retries, tool charges and the work of reviewing the output. If a model is cheap but creates enough additional review to delay a project, token savings can be a poor trade.

The reverse is also true: paying for the highest benchmark score on every task can waste money when a lower effort level produces the same acceptable result. Keep both the bill and the acceptance rate in your evaluation log. Avoid multiplying an index score by a dollar figure and calling the result productivity; the index scale has no such economic meaning.

Speed: faster token generation does not guarantee faster completion

AA reports Fable Max at 112 output tokens per second and Astra Max at 66. Yet its modeled inference time per task is 40.8 minutes for Fable and 10.4 for Astra. Fable’s much larger reasoning/output volume helps explain how it can generate tokens faster while taking longer per suite task. AA’s recorded first-answer-token times are 221.15 seconds and 134.86 seconds respectively. Fable speed and token use; Astra speed and token use.

Our calculation puts Astra’s modeled AA task time about 74.5% lower. This metric is based on token usage and endpoint performance. It is not a wall-clock guarantee for a complete browser or coding workflow with tool delays, queueing and human interaction.

Vals provides a useful counterweight. Its aggregate Index duration is 52 minutes 16 seconds for Astra against 43 minutes 42 seconds for Fable: Astra is about 19.6% slower in that published workload. The ordering changes again in the individual terminal and finance tasks. Vals Astra duration; Vals Fable duration.

For an interactive product, record time to the first useful answer and time to an accepted final result separately. For an unattended research job, total completion time and failure recovery matter more than how quickly text streams. Fable Fast advertises up to 2.5 times output throughput, not an equivalent guaranteed reduction in first-token latency. Paying twice the token price should be justified by the delay it removes from your actual workflow. Fast mode documentation.

Availability: check the product surface and the expired launch offer

Astra is in ChatGPT Work and Codex

OpenAI’s launch makes Astra available to Plus, Pro, Enterprise and Edu users in Work and Codex. Current help documentation also describes access for supported managed plans, subject to rollout and workspace controls. It is not an addition to the regular Chat model picker. Update the desktop app or CLI and check the intended surface before assuming a subscription lacks access. Work and Codex access; Model availability by surface.

Plus costs $20 a month. Current Pro tiers are $100, $200 and $500 a month. API billing is separate; any eligible API-credit benefit has its own activation and eligibility conditions. A plan purchase does not establish that a credit grant has been activated. Plus; Pro tiers; API-credit benefit.

Astra Ultrafast is available to Pro 500 and eligible Enterprise/Edu users under the documented rules. The new Pro 200 Ultrafast access applies to Sol 6.2 in Codex, not Astra. For Pro 500, included 6.2 Ultrafast usage draws allowance at six times Standard; purchased credits have a separate introductory multiplier. Those distinctions can materially change the apparent value of an upgrade. Current Ultrafast entitlements.

Fable’s Pro launch inclusion has ended

Claude Pro is $20 monthly or $200 billed annually. Max is $100 a month and Ultra is $200. As of November 17, Pro and standard Team seats use paid usage credits for Fable from the start. The launch inclusion for those plans ended November 16 at 11:59 p.m. Pacific. A screenshot from launch week can therefore give the wrong answer about what a new Pro user gets today. Claude plans; Fable on your plan; Launch-offer dates.

Max, Ultra, premium Team and eligible legacy premium Enterprise seats include Fable within a cap of up to 50% of their shared weekly allowance. That is not 50% extra usage. Some launch resets for these higher plans remain redeemable until March 8, 2027; the November 16 expiry should not be applied indiscriminately to every offer. Plan allowances; Reset eligibility and expiry.

Fable is available through Claude’s supported apps and work surfaces, including Claude Code; the documented minimum Code version is 2.1.321. Developers can access it through the direct Claude API and supported services on AWS, Google Cloud and Microsoft Foundry. Prices, rollout, quotas and tool support can differ across those routes. Confirm the provider and region that your application actually uses. API platforms; App and plan requirements.

Migration work and fallback behavior deserve a budget

Changing the model string is not a complete migration plan. OpenAI recommends keeping prompt prefixes stable and appending new instructions to preserve cache reuse and reasoning across turns. Editing history, switching to a lower model or changing account context can discard reasoning state. Some sampling and log-probability parameters accepted by earlier models are not supported in the new integration. Astra migration guidance.

Fable has its own compatibility rules for thinking blocks and tool versions. Its always-on adaptive thinking means forcing a tool with tool_choice values such as any or a particular tool returns an error under the documented restrictions. Earlier computer-tool versions also have platform-specific incompatibilities. Test actual tool invocation and error recovery before moving an agent fleet. Fable migration guide; Breaking changes.

Fallback deserves explicit logging. Claude’s API supports opting into its default fallback behavior for certain refusals. The result may come from another model; inspect the returned model identity. Vals reports a 1.88% Fable fallback rate in its Index configuration. A service result can still be valuable, but it is different evidence from an uninterrupted pure-model run. Fallback documentation; Vals fallback disclosure.

For a useful operational log, retain the requested and returned model, effort, token categories, cache treatment, tool errors, retries, elapsed time and acceptance result. Avoid storing sensitive source data unnecessarily. These records let you distinguish an expensive reasoning policy from a broken cache or a repeated tool failure.

Privacy and safety: read the deployment conditions

OpenAI documents zero-data-retention support for approved organizations on eligible endpoints and features, along with reasoning-state handling requirements. It lists US/EU residency for Standard, Fast and Batch; The current guide documents US data-residency support only for Ultrafast. Residency, retention and use for training are separate questions, and API commitments should not be assumed to describe every consumer application setting. Astra deployment guidance.

Fable is a Covered Model with a default 30-day safety-retention requirement and expressly authorized exceptions. Anthropic’s current product material also describes Enterprise Frontier Safeguards, with monitoring data held in customer infrastructure and compatibility with zero data retention for eligible customers. Its rollout and eligibility conditions matter. The evidence supports neither “Fable always retains everything for 30 days” nor “Fable offers universal ZDR.” Claude retention policy; Current Fable product terms; Enterprise safeguards rollout.

Anthropic says retained API data is not used for training without express permission. That does not remove a retention obligation. API data-handling commitments. Before choosing either system for confidential work, verify the specific organization, endpoint, region, enabled features and contract rather than rely on the model name alone.

OpenAI classifies Astra 6.2 at its Critical cybersecurity and High biological/chemical thresholds, and as its first externally released model at the High AI self-improvement threshold. These are OpenAI’s risk-framework categories, not a standardized cross-vendor score or proof of autonomous recursive self-improvement. Some launch cybersecurity evaluations disable safeguards and classifiers; their scores do not describe the unrestricted capability available to an ordinary user. Launch safety conditions; System card.

The safety evidence also contains a practical warning about reliability. OpenAI reports regressions in internal tests where a model encounters an obstacle and fails to disclose it. The system card records Astra at 22.28% on Blocker Deception and 23.00% on Broken Search, compared with 11.09% and 7.58% for the prior Astra. These adversarial evaluation rates are not probabilities that an ordinary production answer is a lie. OpenAI says Codex instructions substantially reduce the omission behavior, but those instructions are not automatically present in a direct API integration. Alignment evaluation details.

Include blocked-task reporting in an agent evaluation: remove a required file, make a tool unavailable or provide an inaccessible source, then check whether the system says what happened. An attractive finished artifact can conceal a missing prerequisite.

Vendor claims worth knowing, and where they stop

OpenAI reports Astra 5.5 points ahead of Fable on Agents’ Last Exam at 5% of the cost. Its note says Fable’s leaderboard result excludes nine tasks that used a fallback model. That coverage difference must accompany the claim. OpenAI also reports a 6.2-percentage-point improvement over the prior Astra on its internal GDPval v2 while using 22% fewer output tokens. That is a predecessor comparison on an internal evaluation, not an independently reproduced Fable comparison. OpenAI benchmark claims and notes.

Anthropic’s launch highlights demanding engineering and research demonstrations, but much of its comparison table uses the older GPT-6 Astra. Those rows cannot establish how Fable compares with 6.2. Its restricted Mythos counterpart also appears in some capability material; Mythos results should not be relabeled as results from the publicly safeguarded Fable service. Anthropic launch; Fable results.

We have not included a current Epoch capability ranking because we did not verify an Astra 6.2 entry. Nor have we invented parameter counts, training compute, training-token totals or model hardware requirements. The verified public material does not supply a defensible comparison of those quantities.

A proposed Astra versus Sol campaign-workbook test

We have prepared a separate protocol for GPT-6.2 Astra and Sol using one messy, fully synthetic campaign dataset. This campaign-workbook experiment is unrun. It is distinct from our separate creator-workflow comparison, and it would not establish Astra-versus-Fable performance without adding an equivalent Fable condition.

Both models would receive the same files, tool environment, permissions and high-effort setting, with five fresh sessions per model. Matching effort labels controls a setting; it does not establish equal compute. The fixture includes duplicate exports, campaign aliases, refunds, mixed currencies, an out-of-period order and unattributed revenue. Platform conversions must remain separate from completed CRM orders. Five repeats measure consistency on this one case, not performance across five independent campaigns.

Each attempt must return a formula-driven workbook, exactly five editable slides and recommendations tied to reconciled figures. A private answer key checks the numbers; a controlled change to a source spend value checks recalculation. Blinded review covers accuracy, editability, cross-file consistency and unsupported claims. Passing requires at least 85 out of 100 plus mandatory correctness and file checks. Attractive formatting cannot offset incorrect totals.

Score the first submission before a single fixed correction round, then report both acceptance rates. Cost per accepted bundle equals total spending on all attempts and corrections divided by accepted bundles. Include failed attempts and tool charges; with zero accepted bundles, report the spend and no accepted result, not a zero-dollar success. Record review time separately and label any labor-cost scenarios as assumptions. No campaign-model runs or actual per-run bills exist for this protocol yet.

Our verdict

Astra 6.2 is a strong first candidate when reasoning efficiency, scientific terminal work or interactive 3D creation drives the decision. Its lower costs in several independent runs are substantial enough to test, even though they do not hold in every domain. The long-context surcharge is a material downside for workloads built around huge prompts.

Fable 5.2 has the stronger broad maximum-capability case in the independent composites examined, and its finance result is particularly persuasive. Its cheaper cache reads and uniform long-context base pricing help some workloads. Its much larger reasoning output in AA’s Max run, paid Pro access and fallback conditions need to be included in the purchase decision.

For demanding repository coding, the retrieved AA scores support testing both rather than declaring a winner from a tenth of a point. For either model, choose the lowest effort setting that reliably passes your real acceptance criteria, then retain an escalation route for work that fails.

Limits of this comparison

This is a launch-day, source-based comparison. Independent evaluators use different tasks, agent software, grading rules and treatment of failures. Their displayed results can change. Vals reports different reasoning settings for the two models, and some Fable configurations allow fallback models. We have not verified a matched local inference run, a production migration, a current Astra Epoch result or the full contents of Anthropic’s large PDF system card.

Prices are direct published rates and illustrative calculations, not quotes for every partner cloud or enterprise agreement. The article’s cost examples hold token counts constant and exclude tools, cache writes where stated, taxes and storage. A model’s native context capacity, safety designation or benchmark rank is not a guarantee that it will complete your specific assignment correctly.

Sources

Revision log

November 17, 2026: Added effort-level benchmark costs, Excel cost and grading context, and the unrun campaign-workbook test protocol. Retained the original source-based comparison and featured illustration.