The article compares the suspended, high‑performance single‑model Claude Fable 5 with Sakana’s currently available multi‑agent orchestrator Fugu, highlighting Fable 5’s superior coding capability and token efficiency versus Fugu’s live availability, vendor‑risk mitigation, and stronger code‑review performance.
One is a single frontier model that's currently switched off. The other is a multi-agent system you can use right now. Comparing them fairly means starting with that asymmetry.
Before the benchmarks: these aren't the same kind of thing
It's tempting to line up "Fable 5 vs Fugu" like two phones on a spec sheet. They aren't.
Claude Fable 5 is a single, monolithic frontier model from Anthropic — its first general-access "Mythos-class" model, a tier above Opus 4.8. It launched June 9, 2026... and was suspended on June 12, 2026, when a US export-control directive forced Anthropic to pull public access to Fable 5 and Mythos 5. As of this writing, you cannot actually call Fable 5.
Sakana Fugu is the opposite shape: not a model but an orchestrator. It's a trained ~7B "conductor" LLM that takes your request and routes it across a pool of frontier models (Opus 4.8, GPT-5.5, Gemini 3.1 Pro), delegating, verifying, and synthesizing behind a single OpenAI-compatible API. It ships in two tiers — fugu (fast, balanced) and fugu-ultra-20260615 (deep pool, max quality) — and it's available today.
Here's the irony that frames everything below: Fable 5 isn't even in Fugu's pool, because the same export controls that took Fable offline keep it out. Sakana pitches Fugu explicitly as the hedge against exactly this kind of disruption — "frontier capability without the export-control risk." So this is less "which is better" and more "the best single model you can't use vs. the orchestration layer that routes around its absence."
One more health warning: every Fugu benchmark number is Sakana-reported, with no independent replication yet, and they're orchestration-system scores rather than clean single-model results. Treat them as vendor claims. Fable 5's numbers are Anthropic-reported. Read the whole table with that in mind.
The scorecard at a glance
| Dimension | Claude Fable 5 | Sakana Fugu (Ultra) |
|---|---|---|
| Type | Single frontier model (Mythos-class) | Multi-agent orchestrator over a model pool |
| Availability | Suspended (export controls, Jun 12 2026) | Live now, OpenAI-compatible API |
| SWE-Bench Pro | ~80% (Anthropic) | 73.7% (Sakana) |
| Code reasoning (FrontierCode Diamond) | 29.3% — SOTA | Not directly reported |
| Code review | Mixed in independent tests | Standout strength (per early users) |
| Context / output | 1M in / 128K out | 1M context |
| API price (in/out per 1M) | $10 / $50 | $5 / $30 (+$0.50 cached) |
| Token efficiency | Lean per task | Higher — orchestration fans out |
| Latency | Fast frontier model | Slow by design (multi-agent) |
Now the detail, dimension by dimension.
Model quality
On raw, single-model capability, Fable 5 was the strongest thing Anthropic had ever shipped: 95.0% on SWE-bench Verified, ~80% on SWE-bench Pro, a leading 1932 Elo on Artificial Analysis's GDPval-AA knowledge-work ranking, and #1 on Cognition's FrontierCode. Anthropic's framing was that the longer and more complex the task, the larger Fable's lead.
Fugu's claim is parity — "shoulder-to-shoulder with Fable 5 and Mythos Preview" — and on reasoning and science benchmarks (GPQA-Diamond 95.5%, where it leads its whole pool) that holds up. Sakana says Fugu Ultra beats every model in its own pool on 10 of 11 benchmarks. The honest asterisk: the one it loses is long-context recall (MRCRv2), and on the benchmark that matters most for software engineering — SWE-Bench Pro — Fable 5's ~80% clearly leads Fugu Ultra's 73.7%. "Parity" is true on science and reasoning, weaker on agentic coding.
Edge: Fable 5 on coding capability; genuine parity on reasoning/science — if Sakana's numbers hold up independently.
Code quality
Fable 5's signature is autonomous, long-horizon coding. Reviewers describe it reading an entire module structure (and the test suite) before touching a file, then writing code that fits the existing patterns. The headline anecdote: Stripe ran a codebase-wide migration across 50 million lines of Ruby in a single day — work estimated at two-plus months for a full team.
Fugu's code quality is really the quality of whichever models it orchestrates plus a verification pass. That's a strength on messy, multi-step work where a second model catches the first's mistakes, and Fugu (the fast tier) slots neatly into Codex for everyday coding. But you're not getting a Fable-class single mind — you're getting a coordinated committee of Opus/GPT/Gemini.
Edge: Fable 5 for single-pass, large-scale, coherent code generation.
Code interpretation
This is where Fable 5's 1M-token context and SOTA vision matter: it can rebuild a web app's source from screenshots alone, reason over rendered documents with no tools, and hold a large codebase in working memory while it reasons about it. Interpretation — understanding what existing code means before acting — is arguably its strongest practical trait.
Fugu interprets by delegation and synthesis, and its routing is a deliberate black box — you can't see which model read your code or audit the path. For comprehension-heavy work where you want one model to deeply internalize a codebase, the monolith has the natural advantage.
Edge: Fable 5.
Code reasoning
The sharpest number in Fable 5's launch is FrontierCode Diamond — a deliberately hard, unsaturated coding-reasoning set — where it scores 29.3% and solves nearly a third of problems that trip up every other frontier model (GPT-5.5 manages ~5-6%). That's a roughly 5x gap on exactly the kind of multi-step problem-solving that separates frontier models.
Fugu's reasoning story is its architecture: independent chains of reasoning from multiple models, compared and synthesized, which genuinely helps on long, branching, "figure out the plan" tasks. Its GPQA-Diamond and trading-optimization results are strong. But on a like-for-like code-reasoning benchmark, Fable's published lead is hard to match.
Edge: Fable 5 on benchmarked code reasoning; Fugu's orchestration shines on messy real-world multi-step loops.
Code review
The one dimension where the orchestrator arguably flips it. Early Fugu users are emphatic: Fugu Ultra is "significantly better than GPT-5.5" at review, surfacing 20+ issues where other tools flagged about three, and catching bugs across categories simultaneously — a natural fit for a system that runs several models plus a verifier over the same diff. Several testers said it became the model they route all reviews through.
Fable 5, by contrast, drew a mixed verdict on code review specifically in independent CodeRabbit evaluations — strong at autonomous building, less dominant at structured review. Multiple critical perspectives are exactly what review wants, and that's the orchestrator's home turf.
Edge: Fugu — the clearest win on its side of the ledger (with the caveat that this rests largely on user testimonials, not independent benchmarks).
Bug fixing
Worth splitting in two:
- Fixing bugs (find-the-broken-thing-and-patch-it, i.e. SWE-Bench Pro): Fable 5 leads, ~80% vs 73.7%. The benchmark literally measures investigate → patch → test → recover, and Fable's long-horizon persistence is built for it.
- Finding bugs (review-time detection): Fugu's multi-model sweep surfaces more issues, per those review testimonials.
So: reach for Fable to resolve a hard bug end-to-end; reach for Fugu to catch what a single pass missed.
Edge: split — Fable fixes, Fugu finds.
Token consumption
Fable 5 is priced at $10 / $50 per million input/output tokens ($5 / $25 on the Batch API), with a 1M-token context and 128K output. Notably, it's efficient: it tops FrontierCode even at medium effort, meaning strong results without burning maximum reasoning tokens.
Fugu Ultra's headline rate is cheaper — $5 / $30 per million ($0.50 cached), rising to $10 / $45 above 272K context. But the rate hides the real cost: orchestration fans your one request out to several models plus verification passes. In one hands-on test, ~60% of total tokens for a session ran behind the scenes in the orchestration layer — invisible on the surface, very visible on the bill. A single Ultra code-generation call pulled tens of thousands of background tokens on its own. Cheaper per token, more tokens per task.
Edge: Fable 5 on tokens-per-task efficiency; Fugu on sticker rate, but watch the orchestration overhead.
Total available tokens: per-5-hour and weekly limits
This is the messiest comparison, because the two expose limits completely differently.
Fugu has explicit rolling quotas in its console: a 5-hour quota and a weekly quota, gating its three subscription tiers — Standard ($20/mo, baseline), Pro ($100/mo, ~10x), and Max ($200/mo, ~20-30x depending on source). In one early test, a handful of light requests consumed 18% of the 5-hour quota and 6% of the weekly on Standard — and heavy users report the $200 Max plan can be exhausted by under ~3 hours of heavy use per week, because each "request" is really many model calls. Sakana publishes the tier multipliers but not the exact token numbers behind each window. Pay-as-you-go removes the caps entirely and just bills tokens.
Fable 5 has no published per-5-hour or weekly token caps of its own. It was offered through the Claude API (pure pay-per-token, no window cap) and through Claude subscription plans (which do use ~5-hour reset windows plus weekly limits) — but Anthropic never published Fable-specific token-per-window figures, and the model is suspended anyway. So for Fable, the honest answer is: on the API, you're limited by spend and rate limits, not a token allowance; on subscriptions, by Claude's general weekly/5-hour structure, not a Fable-only number.
Edge: not comparable. Fugu gives you concrete (if unlabeled) 5-hour and weekly windows; Fable gives you per-token API billing and, currently, no access at all.
The honest take
If Fable 5 were available, this would be a short post: it's the stronger model on nearly every benchmark that involves writing, reading, and fixing code, and it's more token-efficient per task. On pure capability, the monolith wins.
But it isn't available — and that's not a footnote, it's the entire reason Fugu has a market. A model you can't call has an effective benchmark score of zero. Fugu's real pitch isn't "we beat Fable 5" (on coding, it doesn't); it's "we keep working when your frontier model gets pulled out from under you, and we route around any single vendor." For code review specifically, it may even be the better daily driver right now.
The trade-offs you're actually buying with Fugu: latency (early testers clocked coding tasks stretching toward 30 minutes), unpredictable cost from orchestration fan-out, a black-box routing path you can't audit, and no self-hosting. The trade-offs with Fable: it's gated, it silently falls back to Opus 4.8 on security/biology-adjacent prompts, it carries mandatory 30-day data retention — and today, it's simply off.
Verdict
- Want the strongest single coding mind and can get access? Fable 5 — for long-horizon builds, large migrations, and end-to-end bug fixing.
- Need something that works today, hedges vendor risk, and reviews code aggressively? Fugu — especially Fugu Ultra for review and messy multi-step research.
- Care about auditability, latency, or self-hosting? Neither is ideal; an open orchestrator with per-model receipts may serve you better.
The deeper signal is the question both raise: is the frontier a bigger monolith, or a smarter conductor? Right now, export policy — not benchmarks — is making that choice for a lot of teams.
All Fable 5 figures are Anthropic-reported; all Fugu figures are Sakana-reported and not yet independently replicated. Benchmark scores depend heavily on harness, effort level, and prompt, and orchestration scores aren't a like-for-like comparison against a single model. Verify against your own workload before committing.