Sakana Fugu: One Model API to Orchestrate All the Others

There's a new way to think about frontier AI performance: don't build a bigger model, build a smarter coordinator.

Sakana Fugu, released today by Sakana AI, is the first production model built on this premise. It's a multi-agent orchestration system that presents itself as a single foundation model — you call one API endpoint, and internally Fugu decides whether to answer directly or assemble a team of specialized models to handle it. The complexity never reaches your code.

And the benchmarks are hard to dismiss — on paper. Fugu Ultra matches Anthropic's Fable 5 and Mythos Preview across Sakana's published engineering, scientific, and reasoning tables — while neither of those models is even in its agent pool. They can't be. They're subject to export controls.

Update (June 23, 2026): Within 24 hours of launch, independent testers — led by Ethan Mollick, who runs some of the community's most-watched creative-coding experiments — reported a sharp gap between benchmark claims and real use. Shader and interactive-scene tests took 30 minutes on Fugu Ultra-high. Output was "fine" but did not match Fable in practice. See Real-world testing below.

Update — July 21, 2026: Sakana has expanded the lineup with Fugu-Cyber, a gated cyber-defense endpoint reporting 86.9% on CyberGym and 72.1% on CTI-REALM. Read the Fugu-Cyber benchmark, pricing, verification-harness, and access analysis →

That last part is still the point for sovereignty — but the performance story is now more complicated than launch-day headlines suggested.

One thing to get clear before going further: Fugu is not a frontier model. It's a model orchestrator. It doesn't replace Opus, GPT-5.5, or Gemini — it coordinates them. Fugu is the conductor; the frontier models in its pool are the orchestra. Without those underlying models, there's nothing to orchestrate. What Fugu brings is the intelligence layer that decides which model handles which part of a task, routes dynamically, and synthesizes the outputs into one coherent answer. If you're already paying for API access to multiple providers, Fugu is the glue that makes the collective smarter than any individual piece.

Why Orchestration, Why Now

For the past few years, progress in AI meant one thing: bigger models, more compute, more data. It worked. But it also created a concentration problem that is no longer theoretical.

Anthropic's Fable 5 and Mythos models — today's most capable frontier models — recently had export controls imposed on them. Organizations that built critical infrastructure on those APIs found their access could shift or disappear overnight due to regulatory boundaries and foreign policy decisions.

Sakana's answer isn't a new mega-model. It's a system designed so that no single provider is a point of failure.

"Collective intelligence serves as the practical hedge against this concentration of power." — Sakana AI

Fugu's agent pool is explicitly swappable. If a provider restricts access, Fugu routes around the disruption. As new models arrive — including Sakana's own — they fold into the pool and pass the gains to users automatically.

What Fugu Actually Is

Fugu is itself a language model. Not a wrapper or a router built with if/else logic — a trained orchestrator that has learned:

• When to delegate vs. solve directly
• How to break complex tasks into agent subtasks
• How agents should communicate with each other
• How to combine their outputs into a single, reliable answer

This is built on two ICLR 2026 papers from Sakana AI: TRINITY (an evolved LLM coordinator) and Conductor (learning to orchestrate agents in natural language). The academic grounding matters — this isn't prompt engineering dressed up as a product.

From the outside, you call one model. On the inside, a coordinated system of experts does the work.

Fugu vs. Fugu Ultra

Both models share the same OpenAI-compatible API.

The Benchmark Numbers

Fugu Ultra goes head-to-head with today's frontier models across coding, reasoning, scientific, and agentic benchmarks. The comparison is against Opus 4.8 (Anthropic's best publicly accessible model), Gemini 3.1 Pro, and GPT-5.5 — not Fable 5 or Mythos, which are under export controls and not in Fugu's pool.

Key results at a glance:

Fugu Ultra leads or ties on 8 of 10 benchmarks. The standard Fugu model leads on SciCode and Long Context Reasoning — suggesting the lighter model is better calibrated for document-heavy tasks where over-coordination adds noise.

Fugu Ultra vs Fable 5: Benchmarks vs Real Use

This is the headline Sakana is leading with — and it needs careful unpacking.

Sakana explicitly claims Fugu Ultra "stands shoulder-to-shoulder" with Fable 5 and Mythos Preview on published benchmark tables. Importantly, neither model is in Fugu's agent pool — they're under export controls and not publicly accessible. Fugu achieves its scores by orchestrating models that are accessible, then synthesizing their outputs.

On paper, the implication is clear: you don't need access to Fable 5 to get Fable 5-level results.

In practice, early testers disagree.

Real-world testing: Mollick's Harbor bench (June 23, 2026)

Ethan Mollick (@emollick) — the Wharton professor whose Fable 5 shader experiments became an informal community benchmark — spent launch weekend on Sakana Fugu Ultra-high. His verdict, posted June 22–23:

"I have been trying Sakana Fugu Ultra-high and, first, it is incredibly slow: my typical coding tests (shaders, interactive scenes) take 30 minutes to run. And the results are... fine. It does not match Fable in real use."

He pointed to his Harbor Town gallery entry as the example: ai-harbor-town-gallery.netlify.app/#sakura-ultra-high

Why the Harbor bench matters

Mollick's shader tests are not arbitrary. Creative demos — procedural shaders, Three.js scenes, interactive physics — are hard to fake: output either renders correctly or it doesn't. Mollick has used the same class of prompts across Fable 5, GPT-5.5, and now Fugu, making cross-model comparison unusually fair.

When he says Fugu "does not match Fable in real use," he is comparing against the same drowned-gothic-city / "make it better" workflow that Fable cleared in its first 72 hours. Benchmark tables don't capture that gap.

Other early reactions (June 22–23)

Mollick's follow-up to a reply that Fugu is "a combination of LLMs":

"That would beat frontier LLMs, which it does not."

If multi-agent orchestration truly compounded frontier models, you'd expect super-linear quality. Early creative-coding tests suggest coordination overhead and latency eat the theoretical gain — at least on interactive visual tasks.

Benchmarks vs Harbor: the pattern

This is the same benchmark vs real-use split we saw across the Fable 5 launch cycle: leaderboard numbers move markets; shader galleries move practitioners.

For teams blocked from Fable/Mythos by export controls, Fugu remains architecturally interesting — but June 23 testing suggests you should not assume benchmark parity transfers to creative coding or latency-sensitive work.

What Beta Users Built

Close to 500 early users put Fugu through real, demanding workflows during the beta. Three use cases stood out:

Code Review

"For code review, Fugu Ultra is significantly better than GPT-5.5. It gives comprehensive answers and finds the bugs others miss. Where other tools flag about three issues, Fugu surfaced more than twenty. It's become the model I run all my reviews through." — Software Engineer

Long-Session Agent Products

"Raw output quality is on par with top frontier models, but Fugu showed unusually strong persona stability across long sessions, holding its identity where other models drift. For agent products, that may matter more than raw benchmark scores." — Executive at Enterprise Platform Company

Security Assessment

"Given one scoped instruction, Fugu drove a full security assessment end-to-end — recon, XSS/SQLi checks, auth review, and a clean report with evidence and retest steps — staying inside scope and avoiding destructive actions." — Cyber Security Engineer

The pattern across beta feedback is consistent: Fugu's value compounds on long, multi-step tasks. A single prompt doesn't reveal it. A 20-step research workflow does.

The Architecture Advantage

Traditional multi-agent systems require you to build the orchestration layer: pick models, define handoffs, write routing logic, handle failures. That complexity lives in your code.

Fugu internalizes it. The orchestration is trained, not hardcoded. This means:

• No integration overhead — one API call, one endpoint
• Dynamic routing — Fugu decides which specialist handles which subtask at runtime
• Failure resilience — if an agent in the pool becomes unavailable, Fugu adapts
• Automatic improvement — as better models enter the pool, performance improves without any change to your code

For developers, this is the equivalent of moving from managing your own servers to using a managed cloud service — except the managed layer is intelligence routing, not infrastructure routing.

Pricing and the Real Cost Math

Sakana Fugu has a subscription tier (around $20/month) for everyday use and a higher-tier plan for heavier workloads, plus pay-as-you-go for enterprise. Both Fugu and Fugu Ultra are on the same API — switching between them is a model parameter change.

That sounds reasonable on paper. The HN reaction on launch day was less charitable: "You pay $200/month to Anthropic, $200/month to OpenAI, $200/month to Cursor, $200/month to Google, and seeing that it didn't come to a nice round $1024/month, you pay $200/month to Sakana to coordinate it all."

The joke lands because it sounds like stacking yet another subscription. But the framing is wrong — and understanding why matters.

Fugu replaces your direct API subscriptions, it doesn't add to them. You pay Sakana one bill; Sakana pays Anthropic, OpenAI, and Google. The underlying API costs are absorbed into the subscription. You're not paying $200 to Sakana on top of paying $200 to each model provider — you're replacing those provider relationships with one managed layer.

Whether that's a good deal depends on a number factor.

The Token Fanout Problem

Multi-agent orchestration has a cost that's easy to miss in a flat subscription framing: every request fans out to multiple models.

When Fugu Ultra handles a complex task, it doesn't call one model. It typically:

1. Runs the orchestrator model to plan the approach (tokens consumed)
2. Fans out subtasks to 3–5 specialist models in parallel (3–5× tokens consumed)
3. Synthesizes outputs in a final consolidation pass (more tokens)

A single Fugu Ultra request can consume 4–6× the tokens of a direct single-model call for the same task. Sakana bundles all of this into the subscription pricing — but it's exactly why usage limits on cheaper tiers hit faster than you'd expect. Early users reported the $20 tier running out in under 5 hours of active use; direct Opus API access at comparable quality costs less per equivalent task.

The case for Fugu isn't cheaper tokens. It's cheaper results — the orchestrated output often requires fewer follow-up prompts, fewer iteration cycles, and fewer debugging rounds. That's a harder value to put in a table, which is why the sticker price comparison always looks unfavorable on first read.

The Margin Problem Every Aggregator Has

There's a structural economics problem Sakana shares with any model aggregator worth understanding.

When Anthropic charges $20/month for Claude Pro, their inference margin is roughly 70–80%. They make money on every token at scale. When Sakana charges for Fugu, they pay Anthropic, OpenAI, and Google full API rates — then add their own orchestration margin on top. You're paying the underlying model costs plus a layer.

This isn't a criticism of Sakana's model — it's just the reality of being an aggregator. The implication: Fugu's cost proposition only makes sense if the quality delta is real and happens on tasks you actually run. The beta feedback suggests it is, but only on high-value, multi-step work (code review, research automation, security assessment). For simpler tasks, you're paying Fugu Ultra prices for work a smaller model handles fine.

As a few people on HN noted, the math on individual usage can look similar to running near-free DeepSeek V4 on OpenRouter — which gets you good-enough quality at 1/10th the cost if your workload isn't demanding depth. Token prices are racing toward zero on the commodity end of the market. Fugu's bet is that deep orchestration quality doesn't commoditize at the same rate as raw tokens.

Who Should Actually Use This

Honest breakdown, use-case by use-case:

The $20 tier is an honest entry point to test whether Fugu's quality is real on your workloads before committing to a higher tier. The 5-hour-ish usage limit is tight — Steinberger exhausted his entire quota on one Three.js prompt. Run your own Harbor-equivalent test (shader, interactive scene, or multi-step agent task) before trusting benchmark tables.

Alternatives Worth Knowing

If Fugu doesn't fit after real-world testing, the multi-model orchestration space is getting crowded fast:

• Direct Fable 5 / Opus 4.8 — if you have access, Mollick's tests suggest Fable still wins on creative coding. See when Fable 5 may return if you're blocked.
• GPT-5.5 — Steinberger's Three.js test needed zero follow-ups vs Fugu's 7–8 Codex rounds
• OpenRouter Fusion — calls N models, synthesizes with a final LLM. Open, cheap, transparent. Less intelligent routing than Fugu's trained orchestrator, but the gap is closing.
• Databricks Omnigent — similar meta-harness architecture, targeting enterprise data workflows.
• Roll your own — with OpenRouter plus a small orchestration harness, you can replicate much of what Fugu does if you have the engineering time. Sakana published two ICLR 2026 papers on how they built the routing model; the research is public.

What Comes Next

Sakana has flagged their roadmap priorities:

1. Expanding the agent pool — including open-weight models and Sakana's own upcoming models
2. Stronger long-running coordination — deeper support for multi-day agentic tasks
3. User control — more granular configuration of how Fugu orchestrates on your behalf

The architecture compounds naturally: every new capable model that enters the open ecosystem potentially enters Fugu's pool. Unlike a monolithic model that requires an expensive retraining cycle to improve, Fugu improves incrementally as the broader ecosystem does.

The Bigger Picture

The AI industry in 2026 has a geopolitical problem. Frontier capability is increasingly concentrated in a handful of US-based providers subject to export controls, regulatory changes, and policy shifts that can happen faster than engineering teams can adapt.

Sakana Fugu is the first production system explicitly designed around this constraint. It doesn't try to out-scale the frontier labs. It learns to coordinate them — and route around them when access disappears.

Whether that's enough to hold its position as Fable 5 evolves remains to be seen — and June 23 real-world testing suggests the gap on creative coding may be wider than benchmark slides imply. The architecture is still sound in theory: collective intelligence is more resilient than any single model. Whether Fugu Ultra delivers that collective advantage at acceptable latency and cost is now an open question practitioners are answering in public — starting with Mollick's Harbor gallery and Steinberger's fablepool demos.

Practical takeaway: treat Sakana's Fable-parity claims as a hypothesis. Run your own shader, agent, or research workflow before switching. Benchmarks rank models; Harbor benches reveal whether you'd actually ship with them.

Related Reading on explainx.ai

Fugu vs Fable context:

• What people built with Claude Fable 5 in 72 hours — Mollick's shader benchmark Fugu is being compared against
• Fable 5 vs GPT-5.6 comparison — benchmark vs real-use patterns
• CoffeeBench — 90-day supply chain eval — long-horizon management benchmark from the same lab (June 26, 2026)
• US export controls on Fable 5 and Mythos — why Fugu's sovereignty pitch exists
• When will Fable 5 be available again? — access status for blocked teams

Orchestration and agents:

• Browse the full LLM directory — compare Fugu, Opus 4.8, GPT-5.5, and every other tracked model
• Explore AI agents — autonomous systems that pair naturally with orchestration APIs like Fugu
• AI skills registry — reusable workflows to layer on top of any model, including Fugu-backed deployments
• GLM 5.2 vs Fable 5 planning benchmark — more data on the frontier model landscape Fugu navigates
• Loop engineering for coding agents — verification patterns when orchestrated output needs follow-up fixes

Updated June 23, 2026 with Ethan Mollick's Harbor bench testing and community reactions. Benchmark scores reflect Sakana's June 22 release; real-world results may differ — verify on your workloads.