Sakana Fugu Review: How the Fugu Ultra Orchestration Model Really Compares (2026)

Sakana Fugu is a multi-agent orchestration model — one OpenAI-compatible API that coordinates a pool of frontier LLMs behind the scenes and behaves, from your side, like a single foundation model. Sakana AI shipped it on June 22, 2026, pitched as frontier-grade results without export-control or vendor lock-in risk. This Sakana Fugu review covers what it actually is, how the orchestration works, what the benchmarks really say, what it costs, and whether it's worth your time yet.

Quick summary (TL;DR) - What it is: a learned orchestrator — an LLM trained to coordinate other LLMs behind one API. Not a single model, not a dumb if/else router. - Two variants: fugu (balanced, faster, opt-out friendly) and fugu-ultra-20260615 (max quality, deeper pool, slower). - Headline benchmark: 73.7 on SWE-Bench Pro — strong, but Claude Fable 5 scores 80.0 and isn't even in Fugu's pool, so the "matches Fable 5" line needs an asterisk. - Pricing: $20–$200/mo subscriptions, or pay-as-you-go Fugu Ultra at $5 in / $30 out per 1M tokens (2026). - Verdict: genuinely good at hard, multi-step work — but slow, pricey, a black box, and EU-blocked at launch. Try it for research and deep code review; wait if you need low-latency UX.

What Is Sakana Fugu?

Sakana Fugu is a multi-agent orchestration model from Sakana AI: a single OpenAI-compatible API that coordinates a pool of frontier LLMs behind the scenes and behaves like one foundation model. It's not a single model and not a hand-coded router — it's a learned orchestrator, an LLM trained to decide, delegate, verify, and synthesize per request.

That category is the question burning up Hacker News: is Fugu one giant model, a router, or a wrapper? None of those, exactly. Fugu is itself an LLM, trained to decide per request whether to answer directly or delegate to specialists, then verify and combine the results — unlike a hand-coded if/else router (which forwards your prompt by fixed rules) or a single foundation model (which does all its thinking inside one set of weights).

Think of it like a general contractor: you describe the job at one front desk, and it figures out which specialists to pull in, in what order, and how to check their work. You just get the outcome.

Sakana AI, the Tokyo lab co-founded by David Ha, leans on nature-themed naming (fugu is the pufferfish). The release is only two days old as of this writing, so treat reception as still forming — early reactions are mixed.

How Sakana Fugu's Orchestration Actually Works

Sakana Fugu works by making an intelligent, per-request decision: for each prompt, the learned orchestrator decides whether to answer directly or delegate to specialist models, then routes the work, verifies the results, and synthesizes one answer — instead of following a static playbook. Three pieces make that possible.

Learned Orchestration, Not Hand-Coded Routing

The orchestrator is a trained model, not a config file — and that's the whole point. A learned orchestrator adapts to the actual difficulty of your prompt: a simple question gets a cheap, direct answer; a gnarly multi-step problem gets routed through several specialists and a verification pass. That flexibility drives quality up — and makes cost and latency unpredictable.

Dynamic Routing, Provider-Swapping, and Recursive Self-Calls

This is where the multi-agent orchestration model label earns its keep. Fugu routes dynamically, swaps around restricted or unavailable providers, and can even call itself recursively to break a hard problem into sub-problems — that recursion is what buys genuine multi-step reasoning instead of a single shot.

There's an honest catch: the pool is swappable for Sakana, not for you. You can't pick which model answered or audit the routing — more on why that's a governance problem below.

The Research Behind It: Trinity and Conductor (ICLR 2026)

Everyone name-drops the two ICLR 2026 papers; almost nobody explains them. The dev-friendly version:

Trinity is an evolved coordinator that assigns Thinker, Worker, and Verifier roles across turns: a thinking model plans, a worker model executes, and a verifier checks the result, with the coordinator deciding who does what.

Conductor is an RL-trained system that discovered its own coordination strategies in plain natural language instead of relying on hand-designed workflows. Nobody scripted the playbook — the model figured out how to direct other models on its own, which is what makes Fugu feel less like a script and more like a project manager.

Fugu vs Fugu Ultra: Which One Do You Need?

The difference between Fugu and Fugu Ultra is the speed-versus-quality tradeoff: fugu is the balanced, lower-latency option with a leaner pool that lets you opt agents out, while fugu-ultra-20260615 maximizes quality with a deeper, fixed pool for hard multi-step work but runs slower. Both ship a 1M-token context window.

Rule of thumb: reach for fugu when you want responsiveness and compliance control, and escalate to Fugu Ultra only when the problem is genuinely hard and quality beats speed. For how a single 1M-context model compares head-to-head, how a single 1M-context model like GLM 5.2 performs is a useful sibling reference.

Sakana Fugu Benchmarks (And the Fable 5 Catch)

The Sakana Fugu benchmarks look impressive on paper. But before you trust a single number, read this label twice: every figure below is Sakana-reported, not independently verified. These are orchestration-system scores, not single-LLM scores — don't read them as a clean, like-for-like comparison.

The Benchmark Table

Sakana's headline is that Fugu Ultra leads 10 of 11 benchmarks against Opus 4.8, Gemini 3.1 Pro, and GPT-5.5 — the lone loss being MRCRv2, where GPT-5.5 edges it out. The coding numbers (TerminalBench 2.1 at 82.1, LiveCodeBench at 93.2) are real, published claims that get a CTO's attention. For the single-model counterpoint, where Claude Opus 4.8 still leads is worth a look.

Why "Matches Fable 5" Needs an Asterisk

Here's the catch almost every breathless headline skips — and it's the single most important thing in this review. Sakana says Fugu Ultra "matches Fable 5." But Fable 5 was export-controlled — Anthropic pulled public access on June 12, 2026 — and it is not in Fugu's pool. So "parity" is parity-by-claim, not head-to-head.

Worse for the marketing line: where Sakana did publish direct numbers, Fable 5 wins 3 of 4. On SWE-Bench Pro it's 80.0 versus Fugu Ultra's 73.7 — not a rounding error. The honest read is that Fugu Ultra is excellent, but it isn't beating the model it's compared to; it's approximating the absence of one. For the backstory on why Claude Fable 5 and Mythos 5 got pulled, that export-control context is exactly why Sakana leans on the "no lock-in" pitch. So read any "Sakana Fugu vs Fable 5" or "vs GPT-5.5" win as Sakana-reported, against a model that isn't in the pool, and still losing the published head-to-heads.

Sakana Fugu Pricing & Plans

Sakana Fugu pricing comes in two flavors. Subscriptions run $20/mo (Standard), $100/mo (Pro), and $200/mo (Max). Prefer pay-as-you-go? Fugu Ultra is $5 per 1M input tokens and $30 per 1M output, with higher rates above a 272K-token context. You manage it all at console.sakana.ai.

Now the part the pricing page won't tell you. Because Fugu orchestrates — calling, verifying, and synthesizing across models — it burns tokens fast. Early users on Hacker News report the $200/mo Max plan covers under ~3 hours a week of heavy use, and one person blew a five-hour quota on a single prompt. Sakana Fugu cost scales with how much orchestration each request triggers, so budget for variability, not a fixed line item.

How to Use the Sakana Fugu API

Here's the genuinely pleasant part: the Sakana Fugu API is OpenAI-compatible, so there's no SDK migration. To use the Sakana Fugu API:

1. Get an API key at console.sakana.ai and pick a subscription or pay-as-you-go plan.
2. Point your existing OpenAI client at the Fugu endpoint by swapping the base_url.
3. Set the model id: fugu for everyday work or fugu-ultra-20260615 for max quality.
4. Add a generous timeout — Ultra can take minutes on hard multi-step tasks.
5. Call chat.completions.create exactly as you already do, and read the result.

Here's the copy-paste version, with the one gotcha that'll bite you in the comments:

from openai import OpenAI

# Point your existing OpenAI client at Fugu — this is the only line that changes.
# NOTE: the base_url below is illustrative — confirm the exact endpoint at console.sakana.ai
client = OpenAI(
    api_key="YOUR_SAKANA_API_KEY",
    base_url="https://api.sakana.ai/v1",  # illustrative; verify at console.sakana.ai
)

# Everyday / faster: the balanced orchestrator
fast = client.chat.completions.create(
    model="fugu",
    messages=[{"role": "user", "content": "Refactor this function and explain the tradeoffs."}],
)
print(fast.choices[0].message.content)

# Max quality / slower: the deep, fixed-pool orchestrator
# GOTCHA: Ultra is slow. Set generous timeouts and DO NOT put it on a sub-second UX path.
deep = client.chat.completions.create(
    model="fugu-ultra-20260615",
    messages=[{"role": "user", "content": "Reproduce the results from this paper and flag any gaps."}],
    timeout=600,  # seconds — Ultra can take minutes on hard multi-step work
)
print(deep.choices[0].message.content)

That's it — same SDK, same chat.completions.create call, just the model id changes. One rule to tattoo on your hand: Ultra is slow. Give it real timeouts and keep it off any path where a user's staring at a spinner.

The Honest Limitations: Latency, Cost & Black-Box Routing

This is the section the day-one news briefs gloss over, and the one that decides whether Fugu survives contact with production. Being candid:

• Sakana Fugu latency is the headline problem. Ethan Mollick called it "incredibly slow," with coding tasks stretching toward 30 minutes; Hamel Husain described it as "a bit jagged" (both early-tester reports — treat as evolving). Expect 3–8s and up on complex responses, plus tail latency you can't control. For long-running workloads, how agents handle long-running tasks is worth reading first.
• Cost is unpredictable. The $200/mo plan can evaporate in under three hours a week of heavy use — orchestration is expensive by design.
• Routing is a black box. You can't see which model answered, audit the path, or swap the pool — a real governance gap for any team that needs traceability.
• No open source, no self-hosting. Fugu is closed — no published weights, no running it yourself. If transparency or on-prem deployment is a hard requirement, it's a non-starter.
• EU/EEA unavailable at launch. Due to GDPR considerations, Fugu isn't available in the EU/EEA on release, blocking teams across the EU plus EEA countries like Norway.
• Ultra's fixed pool. Fugu Ultra gives you no opt-out, so only the standard fugu tier suits compliance teams that must exclude providers. In early testing a ThreeJS task reportedly came back "notably worse than GPT-5.5" — capability is still jagged.

Sakana Fugu vs Single Models vs Agent Frameworks vs OpenRouter

Here's the decision you're actually facing, and it's not "Fugu vs Fable 5." It's: should I orchestrate at all — and if so, do I buy Fugu or build it myself?

One clarification on a common Sakana Fugu vs OpenRouter mix-up: OpenRouter Fusion synthesizes replies after the fact, querying models and blending the answers. Fugu decides up front which models to call and in what order. Both are "multi-model," but the control flow is opposite.

If "build it myself" is on the table, you've got good options. The agent frameworks you could self-orchestrate with cover the orchestration layer, and the build-it-yourself coding-agent breakdown shows what a DIY stack looks like. The tradeoff is simple: building gives you transparency, control, and predictable cost; buying Fugu gives you a research-grade orchestrator with zero infra work — and a black box.

When Should You Use Sakana Fugu (and When Not To)?

Is Sakana Fugu worth it? It depends on your workload: quality-over-speed problems are where it shines, and latency- or cost-sensitive ones are where it stumbles. Use this quick fit test.

Good fit:

• Hard, multi-step research where you need the best possible answer, not the fastest.
• Deep code review — early testers say it catches more bugs than GPT-5.5, a genuine edge.
• Security and cybersecurity assessment, where multiple models cross-check each other.
• Paper reproduction, patent analysis, and literature investigation where thoroughness wins.

Bad fit:

• Anything on a low-latency UX path — the orchestration overhead alone rules it out.
• Auditable, single-vendor governance, especially with Ultra's fixed pool.
• Cost-sensitive, high-volume workloads where quota burn would wreck your unit economics.

Land in the "bad fit" column? You're probably better off self-orchestrating with a routing layer you control. For code-heavy teams, the coding agents that actually catch bugs get you closer to the deep-code-review use case without the black box.

How Techsy Approaches Multi-Model Architecture

Orchestration versus self-built routing is squarely an architecture decision, and it's one we help teams make. Our default: start with a single strong model plus a thin, observable routing layer you control — so you can see which provider answered and swap it when needed — and reach for a managed orchestrator only when the workload is genuinely hard, multi-step, and quality-over-latency. To be fair, Fugu can be the right call for a small team with no infra appetite that needs research-grade quality and is fine trading transparency for convenience. Choose deliberately, not by default.

Weighing a managed orchestrator like Fugu against a routing layer you build and control? Get a free architecture consultation →

Frequently Asked Questions

What is Sakana Fugu?

Sakana Fugu is a multi-agent orchestration model from Sakana AI: one OpenAI-compatible API that coordinates a pool of frontier LLMs and behaves like a single model. It's not one model and not a simple router — it's a learned orchestrator trained to decide, delegate, verify, and synthesize per request.

Is Sakana Fugu a single model or a router?

Neither — and it's not a thin wrapper either. Sakana Fugu is a learned orchestrator: an LLM trained to coordinate other LLMs, so it's smarter than a hand-coded if/else router but isn't a single foundation model. The coordination policy is trained (via the Trinity and Conductor research), which is why it's more than a forward-the-prompt wrapper — and that distinction matters for output quality, cost, and how much you can audit.

What's the difference between Fugu and Fugu Ultra?

Fugu is the balanced, lower-latency option for everyday coding and chat, and it lets you opt agents out for compliance. Fugu Ultra targets maximum quality on hard multi-step work, uses a deeper but fixed pool (no opt-out), and runs slower. Model ids: fugu and fugu-ultra-20260615.

How much does Sakana Fugu cost?

Subscriptions run $20 (Standard), $100 (Pro), and $200 (Max) per month. Pay-as-you-go Fugu Ultra is $5 per 1M input tokens, $30 per 1M output, and $0.50 cached, with higher rates above 272K context. Heavy users report the $200 plan covers under ~3 hours a week (2026 pricing).

Is Sakana Fugu better than Claude Fable 5?

Not proven. Sakana says Fugu Ultra "matches" Fable 5, but Fable 5 was export-controlled and isn't even in Fugu's pool — so it's parity-by-claim, not head-to-head. Where Sakana did publish direct numbers, Fable 5 wins 3 of 4 (e.g., SWE-Bench Pro 80.0 vs 73.7).

Are Fugu's benchmarks independently verified?

No — every headline number is Sakana-reported, not confirmed by an outside lab. Independent third-party verification (goldiebench-style demos) is still emerging as of June 2026, two days after launch. Treat the scores as vendor claims, and remember they're orchestration-system results, not single-LLM scores — so they aren't a clean, like-for-like comparison against any one model.

How do I access the Sakana Fugu API?

Get a key at console.sakana.ai, then point your existing OpenAI client at the Fugu endpoint with a one-line base_url swap — the API is OpenAI-compatible, so there's no SDK migration. Use model="fugu" for everyday work or model="fugu-ultra-20260615" for max quality, and confirm the exact endpoint URL in your console before you ship, since it wasn't officially documented at launch.

Is Sakana Fugu available in the EU?

Not at launch. Fugu is unavailable in the EU/EEA on release due to GDPR considerations, which affects teams across the EU plus EEA countries like Norway and Iceland. Sakana hasn't published a firm timeline for EU access, so check console.sakana.ai for current regional availability before you build a rollout around it.

Why is Sakana Fugu so slow?

Because it orchestrates — calling, verifying, and synthesizing across multiple models per request adds real latency. Early testers reported "incredibly slow" runs and multi-minute coding tasks. Expect 3–8s and up on complex prompts plus tail latency you don't control, so keep it off low-latency UX paths.

Is Sakana Fugu open source?

No. Fugu is fully closed — there are no published weights, no self-hosting, and no way to inspect the routing. That's a deliberate product choice tied to its "no lock-in" pitch, not an oversight. If you need transparency or on-prem deployment, you'll want open-source orchestration or a self-built routing layer you control instead.

The Verdict: Is Sakana Fugu Worth It?

After all the numbers and caveats, the honest scorecard:

• The orchestration is genuinely strong for hard, multi-step work — deep code review and research are where it earns its keep.
• "Matches Fable 5" is parity-by-claim. Fable 5 isn't in the pool and wins the head-to-heads Sakana published. Read the marketing accordingly.
• Slow, pricey, and a black box. Real tradeoffs, not nitpicks — tail latency you can't predict, quota that burns fast, routing you can't see.
• No open weights, EU-unavailable at launch. If you need self-hosting, transparency, or European access, that's a hard stop today.
• Promising but not yet proven. It's two days old, the benchmarks are vendor-reported, and independent verification is pending. Exciting, but early.

So who should jump in? If you run research-grade or deep-code-review workloads and can stomach the cost and latency, Sakana Fugu is well worth a trial. If you need low-latency UX, predictable cost, or auditable governance, wait — or self-orchestrate with a layer you control. Either way, decide on your workload, not the headline.

Not sure whether to adopt Fugu, wait, or self-orchestrate for your workload? Talk to our team →