66 to 61: Fable 5.1 beats OpenAI Astra on the broad score that matters

Artificial Analysis has placed Fable 5.1 ahead of OpenAI Astra with a 66-to-61 score in broad testing. This marks a lead for Fable 5.1 in intelligence, while Astra's strengths lie in faster token emission. The pricing metrics further highlight Fable's advantage in cache read costs. Astra, however, maintains a narrow edge in specific agent tasks like computer use and async tool calls.

TL;DR

• Fable 5.1 scores 66, Astra scores 61 in broad testing.
• Fable leads in intelligence and cache read costs.
• Astra excels in token emission speed and specific tasks.
• Astra's context window is 1.05M tokens, Fable's is 1M.

The 66-to-61 split is the fact pattern behind this launch

Independent broad testing puts Fable 5.1 ahead overall right now: Artificial Analysis has it higher on intelligence, while Astra’s launch case rests on narrower wins in generation speed rather than the top-line score. According to Artificial Analysis, the practical split is broad quality for Fable, faster token emission for Astra, and lower time-to-first-response for Fable, which is why the launch argument turns on a 66-to-61 style overall gap rather than a clean sweep by either side.

The pricing sheet is where the launch math stops being a tie. Standard input and output rates match line for line, but cache reads do not: Fable is one quarter of Astra on that meter, which matters for agent loops that keep reusing long prefixes, retrieved context, or prior tool traces.

The other breakpoint is 272K tokens. Once Astra input crosses that threshold, the whole request is billed at 2x input and 1.5x output, so long-context jobs stop behaving like simple per-million comparisons and start behaving like a tier jump applied to the entire turn rather than just the overflow.

Matched eval routing

For a clean A/B, keep the prompt, tool policy, temperature, and max output fixed, then swap only the model identifier.

eval:
  prompt_file: prompts/repo_fix.txt
  temperature: 0
  max_output_tokens: 4096
  runs:
    - provider: anthropic
      model: fable-5.1
    - provider: openai
      model: gpt-6-astra-max

That is the mechanism behind the split practitioners will actually feel in production:

Astra does have one concrete spec edge on paper: its context window is listed at 1.05 million tokens versus roughly 1 million for Fable, while both support image input. That difference is real but narrow, and it does not erase the broad-score lead or the billing penalty Astra triggers on oversized requests.

On the current independent broad score, Fable 5.1 is ahead of OpenAI Astra.

Why this comparison lands harder than the usual model launch

This comparison bites because the disagreement is visible in plain sight: vendor-style headline wins sit next to an independent broad index that still puts Fable 5.1 ahead. According to MindStudio, on September 3, 2026, Fable 5.1 leads the Coding Agent Index with a score of 70 to Astra’s 67.

That is not a contradiction once you look at what each side is selecting and how it is being run. Astra’s published strength profile is concentrated on computer use, difficult end-to-end coding, async tool calls, and mid-turn steering, which are agent behaviors that benefit from a task harness built around tool use, terminal interaction, and long action chains.

The evidence says Astra wins the demos it was built for, while Fable still leads the broader independent index.

The split shows up most clearly in the specialist boards Astra does win. Astra leads several direct comparisons, including Terminal-Bench 4.0 and DeepSWE, alongside gains on computer-use, math, scientific, automation, and cybersecurity benchmarks.

Those are real wins, and they matter for practitioners shipping agents that live in a shell, operate tools asynchronously, or need tight steering mid-trajectory. They do not overturn the broader ranking because a broad index and a specialist benchmark are measuring different failure surfaces: one rewards general reliability across mixed coding-agent tasks, while the other rewards a narrower architecture-task fit.

Where the benchmark fight actually is

• Broad index: independent aggregate ranking still has Fable 5.1 ahead on the Coding Agent Index.
• Specialist agent tasks: Astra leads Terminal-Bench 4.0 and DeepSWE, plus several computer-use and automation comparisons.
• Headline claim with a harness problem: Astra’s 99.9% on ARC-AGI-3 is part of the launch case, but the evidence set itself frames the surrounding coding picture as mixed against Fable 5.1 and Opus 5, which makes that number a comparability issue, not a universal win.

That last point is why this launch lands harder than the usual chest-thumping around a new model. A single top-line score like 99.9% ARC-AGI-3 invites a “best model” reading, but once the harness changes, the result stops being portable across other leaderboards and starts being local to that setup.

For practitioners, the mechanism is the story. If your eval harness looks like terminal sessions, long tool loops, and intervention during execution, Astra’s strengths are exposed directly.

If your benchmark aggregates mixed coding-agent tasks into one index, Fable’s lead remains the cleaner read of broad performance.

Who should switch now, and who should stay put

The clean split is workload shape, not brand preference: if your stack depends on prompt caching or routinely pushes giant retrieval packs, Fable 5.1 is the safer current choice because both models list the same standard input and output prices, but Fable’s cache-read price is one quarter of Astra’s. According to the published price comparison, Fable 5.1 cache reads cost $0.25 per million tokens while Astra charges $1.00.

If your requests cross 272K tokens, Astra becomes the exposed path because it bills the whole request at 2x input and 1.5x output once input exceeds that threshold.

• Platform engineers running cache-heavy retrieval: stay on Fable 5.1 when your serving path reuses large system prompts, retrieved corpora, or conversation state through cache reads, because standard token prices are equal and cache-read prices are not.
• RAG teams with long context assembly: prefer Fable 5.1 if your pipeline sometimes stuffs enough chunks, tools, and prior turns to cross 272K tokens on Astra, because the billing step-up applies to the whole request rather than only the overflow.
• Agent builders doing computer use: favor Astra when the product depends on direct computer-use behavior, because Astra explicitly emphasizes computer use.
• Teams orchestrating async tool calls: favor Astra if your agent runtime issues nonblocking tools and needs the model to manage that pattern natively, because Astra explicitly emphasizes async tool calls.
• Builders who need mid-turn steering: favor Astra when the controller edits the plan while the turn is still live, because Astra explicitly emphasizes mid-turn steering.
• Coding-agent teams optimizing for benchmarked coding performance: stay on Fable 5.1 if your main KPI is coding-agent quality today, because Fable 5.1 leads the Artificial Analysis Coding Agent Index with a score of 70.
• Evaluation owners deciding by measurement, not marketing: test both on EvoLink now, because both models can be measured there today.

The architecture implication is straightforward. In a cache-heavy retrieval stack, the expensive mistake is choosing the model with the higher cache-read line item when the rest of the tariff is flat; every repeated preamble, policy block, schema, and retrieved context replay widens that gap.

In long-context pipelines, Astra’s threshold changes routing logic. If your orchestrator cannot keep assembled prompts below 272K tokens, add a workload-class gate before model selection, trim retrieval depth, or split the job into stages so the expensive multiplier does not hit the entire request.

routing:
  - match: workload == "cache_heavy_rag"
    model: fable-5.1
  - match: workload == "long_context" && prompt_tokens > 272000
    model: fable-5.1
  - match: workload == "computer_use" || workload == "async_tools" || workload == "mid_turn_steering"
    model: astra
  - match: workload == "coding_agent"
    model: fable-5.1

What this means for you

For platform engineers, the bill risk is concentrated in two places: repeated cache reads and any request builder that can drift past 272K tokens on Astra. For agent builders, Astra is the direct fit for computer use, async tool calls, and mid-turn steering; wire it behind a workload router instead of making it the default for every path. For application teams, equal standard token pricing means the decision is not about base rates; it is about whether your architecture replays context often or crosses Astra’s threshold.

The next dates are the only ones that can move the verdict

The calendar is short, and only a narrow class of new evidence can change the call. According to the evidence set, both models are already measurable on EvoLink, so the remaining dispute is not access but whether later third-party runs reverse the current pattern under the same harness and workload shape.

• 2026-09-01 — Fable 5.1 released, establishing the first launch point for any like-for-like post-release measurement window [unverified].
• 2026-09-03 — Astra released, which fixes the first date on which both systems were simultaneously available for direct independent testing [unverified].
• 2026-09-04 — the benchmark-analysis record was updated, adding the first post-launch read that belongs in the evidence set rather than in pre-release marketing [unverified].
• 2026-09-05 — the benchmark-analysis record was updated again, making this the latest dated checkpoint already in the file [unverified].

Those four dates matter because nothing before dual availability decides the verdict, and nothing after the last recorded analysis matters unless it changes the same categories on the same basis.

What would actually move it

Three things, and only three things, can overturn the current read:

• Independent broad-score reversal — a third-party suite has to flip the aggregate result across a wide basket, not a single cherry-picked task [unverified].
• Coding-index reversal — a later coding-focused index has to reverse the standing under matched prompts, scoring rules, and failure handling [unverified].
• Production cost results under matched evals — real workload measurements have to show a different cost outcome once prompt length, output length, retries, tool calls, and cache behavior are held constant [unverified].

Price sheet parity by itself does not settle that last point. The listed API rates are the same at $10 input and $50 output per million tokens, so any later cost reversal has to come from workload behavior rather than sticker price.

The mechanism is straightforward.

If an evaluator runs both models through the same harness on EvoLink, pins the same task set, and reports a broad-score flip, the verdict changes on performance. If the broad score stays put but the coding index flips under the same controls, the verdict changes for code-heavy buyers [unverified].

If neither score family reverses, cost becomes the only live route. That requires matched production traces rather than list pricing, because the nominal rates are equal and Astra’s 1.05-million-token context edge over Fable’s 1 million does not say what a real agent loop will spend under retries, long-context retrieval, or tool-mediated coding runs.

That is who is exposed next: vendors making benchmark claims without independent reruns, and buyers extrapolating production cost from posted token prices alone. Until one of those three evidence types flips, the file does not support a different verdict [unverified].

Verdict: Fable 5.1 is ahead overall, Astra is narrower and real

The call is simple: Fable 5.1 is the better default model today because it leads the broad independent score, leads the coding-agent index, and avoids Astra’s ugly cost traps on cache reads and over-272K prompts. Astra is not the market leader here; it is the specialist pick for computer use, async tools, and mid-turn steering.

That is enough to settle the buying decision.

If you are setting one default across mixed workloads, pick Fable. If you are routing a narrow agent stack built around the behaviors Astra was tuned for, use Astra there and nowhere else by default.

Q: Which model should be the default choice right now? A: Fable 5.1 should be the default. It is ahead on broad independent quality and coding-agent performance without Astra’s pricing penalties.

Q: Where does Astra actually win? A: Astra wins in narrower agent cases: computer use, async tool calls, mid-turn steering, and faster token emission. Those are real strengths, but they do not beat Fable overall.

Q: Why does cost favor Fable if list prices match? A: Cache reads are 4x cheaper on Fable, and Astra gets much more expensive once inputs pass 272K tokens. That changes real production math fast.

Q: What would change this verdict? A: A broad independent score reversal or a coding-index reversal under the same harness. Until that happens, Fable 5.1 stays ahead.

Sources

• 1. [GPT-6 Astra (max) vs Claude Fable 5.1 (Adaptive Reasoning, Max Effort, Default Fallback): Model Comparison | Artificial Analysis]( https://artificialanalysis.ai/models/comparisons/gpt-6-astra-vs-claude-fable-5-1)