Sakana Fugu AI: How It Works, Benchmarks & Pricing (2026 Guide)

Introduction

For the last few years, the AI industry has chased one idea above all others: build a bigger model. More parameters, more data, more compute. Sakana AI — the Tokyo research lab founded by one of the original authors of the Transformer paper — has quietly built its reputation on the opposite belief. Intelligence in nature does not come from one enormous brain. It emerges from many specialized parts working together.

On June 22, 2026, that philosophy shipped as a product: Sakana Fugu.

Fugu is unusual. It looks like a single AI model — you call one API, you get one answer. But behind that simple interface sits a learned orchestrator that decides, in real time, whether to answer your request itself or to assemble a team of frontier models (Claude, GPT-5.5, Gemini) and coordinate them like a conductor leading an orchestra. The complexity of multi-agent systems — routing, delegation, verification, synthesis — never reaches your code.

The result is a system that, in its Fugu Ultra configuration, stands shoulder-to-shoulder with — and on several benchmarks beats — the most powerful frontier models on the planet, without you needing direct access to any of them.

This guide is the definitive, plain-English explanation of what Sakana Fugu is, how it works under the hood, how it performs, what it costs, and how to start using it today. Whether you're a curious beginner, a developer evaluating it for production, a business weighing the ROI, a student trying to understand the research, or an agency deciding what to recommend to clients — this article was written for you.

1. What Is Sakana Fugu?

Sakana Fugu is a multi-agent orchestration system that is delivered as a single foundation model. That one sentence captures the entire product, but it deserves unpacking because it breaks the mental model most people have of "an AI model."

A normal large language model (LLM) is one neural network. You send it a prompt, it generates a response token by token, and that's the whole story. Fugu is different. Fugu is itself a language model — but it has been trained not primarily to write answers, but to make decisions about who should write the answer.

When a request arrives, Fugu does one of two things:

• Solves it directly, when the task is simple enough that delegation would just add latency and cost.
• Assembles and coordinates a team of expert "worker" models when the task is hard, multi-step, or benefits from specialization and cross-checking.

Crucially, all of this — model selection, delegation, verification, and synthesis — happens internally. From your application's point of view, you called one OpenAI-compatible endpoint and got back one clean response. You never see the orchestra; you only hear the music.

Fugu ships in two variants:

• Fugu — latency-optimized, for everyday and interactive workloads.
• Fugu Ultra — quality-optimized, for the hardest, most valuable multi-step problems.

💡 Expert Tip: The mental shortcut that makes Fugu "click" is this — most products make you build the multi-agent system. Fugu is the multi-agent system, pre-built and trained, hidden behind a single model name.

2. The Company Behind It: Who Is Sakana AI?

To trust a model, it helps to know who built it — and this is where Fugu's E-E-A-T credentials are unusually strong.

Sakana AI is a Tokyo-based AI research lab co-founded by:

• Llion Jones — one of the eight original authors of "Attention Is All You Need," the 2017 paper that introduced the Transformer architecture underpinning virtually every modern LLM, including the very models Fugu orchestrates.
• David Ha — former Research Director at Google Brain, known for influential work on world models, neuroevolution, and self-organizing systems.

The lab's name, "Sakana," is the Japanese word for fish, chosen deliberately. The company's guiding thesis is that the most capable and robust AI systems will not come from scaling one giant monolith, but from collective intelligence — many smaller, specialized models cooperating, much like a school of fish moving as one. Fugu is the clearest commercial expression of that thesis to date.

This pedigree matters for two reasons. First, the people building an orchestrator of Transformers literally helped invent the Transformer. Second, Fugu is not a marketing repackage — it is built directly on peer-reviewed research accepted to ICLR 2026 (more on that below).

✅ Recommendation: When evaluating any AI tool for production, check whether its claims trace back to published, reproducible research. Fugu's do — its technical report and underlying papers are public, which is a strong trust signal.

3. Why "Fugu"? The Philosophy of Collective Intelligence

The name is not random. Fugu is the Japanese pufferfish — a delicacy famous for requiring extraordinary expertise to prepare safely. It's an apt metaphor: enormous capability that demands skilled coordination to unlock without harm.

But the deeper idea is collective intelligence. In nature, a single fish has limited capability, yet a school of fish exhibits sophisticated emergent behavior — evading predators, finding food, navigating — that no individual could manage alone. Sakana AI argues AI should work the same way.

This philosophy produces a property that is easy to overlook but strategically huge: provider independence. Because Fugu's routing is learned rather than hard-coded, it can dynamically reroute work if any single provider restricts access, raises prices, or goes down. The system is not chained to one vendor. In an era of export controls and shifting model availability, that resilience is a feature, not an accident.

🚀 Pro Tip: Think of Fugu less as "a smarter model" and more as "an insurance policy against single-model dependency." If your business runs entirely on one provider's API and that provider changes terms tomorrow, you feel it instantly. Fugu abstracts that risk away.

4. How Sakana Fugu Works (Step by Step)

Let's walk through the life of a single request, from the moment it leaves your application to the moment the answer returns. This is where Fugu's "magic" becomes mechanical and understandable.

Step 1 — Your Request Arrives

You send a prompt to Fugu's OpenAI-compatible endpoint exactly as you would to any standard chat model. No special SDK, no agent framework, no orchestration code on your side.

Step 2 — Fugu Decides: Solve or Delegate

Fugu's orchestrator reads the request and makes its first key decision. For a simple question, it may answer directly. For a complex, multi-step, or specialized task, it decides to assemble a team.

Step 3 — Model Selection

If delegating, Fugu chooses which workers to activate from its pool. This selection is domain-adaptive — the technical report shows Fugu routes terminal/coding tasks heavily toward one model, hard science questions toward another, and balances math versus chemistry within the same benchmark. It learned these preferences from data, not from a human writing if-statements.

Step 4 — Role Assignment (Thinker, Worker, Verifier)

Drawing on its Trinity research, Fugu can assign models to distinct roles: a Thinker for conceptual analysis and planning, a Worker to execute the implementation, and a Verifier to validate the output and catch errors. This division of labor is why orchestrated answers are often more reliable than any single model acting alone.

Step 5 — Synthesis and Return

Finally, Fugu combines the verified contributions into one coherent answer and returns it. You get a single response — and, importantly, you are billed a single rate based on the top-tier model involved. Fees do not stack across the agents.

📌 Best Practice: Because Fugu handles delegation internally, resist the urge to build your own agent wrapper around it. Doing so duplicates orchestration logic Fugu already performs — and you'd pay in latency for no quality gain.

5. The Research Foundation: Trinity and Conductor

Fugu is not a black box bolted together for launch. It is the productized form of two papers accepted to ICLR 2026, one of the most selective venues in machine learning.

Trinity — An Evolved LLM Coordinator

Trinity explores evolutionary coordination across three roles — Thinker, Worker, and Verifier. Instead of a human designing the collaboration pattern, an evolutionary process discovers effective ways for these roles to cooperate across multiple turns. This is the conceptual backbone of the lighter-weight Fugu variant.

Conductor — Learning to Orchestrate in Natural Language

Conductor uses reinforcement learning to discover how agents should communicate and collaborate. A Conductor model designs agent-to-agent communication topologies and writes targeted, natural-language instructions for each worker LLM — effectively writing a custom playbook for every task. This is the engine behind Fugu Ultra.

The key insight shared by both: the coordination strategy itself can be learned and optimized, rather than hand-engineered. That's what separates Fugu from the dozens of DIY agent frameworks that ask developers to wire up the orchestration by hand.

6. Technical Architecture Deep Dive

This section is for the technically curious. Beginners can skip to Section 7 without losing the plot — but if you want to understand why Fugu is efficient, here it is.

How Fugu Routes Without Slowing You Down

A naive orchestrator would be slow: it would have to "think out loud" before deciding where to send your request. Fugu avoids this with a decision-only design. It uses a lightweight selection head that operates on the hidden states of a backbone model. The head outputs logits scoring each worker model in the pool, and the query is dispatched without expensive autoregressive decoding — Fugu computes a hidden state at an early token position, applies the selection head, and routes. That's why the report claims latency comparable to a direct call to a frontier model for the standard Fugu variant.

To train this efficiently, Sakana used singular-value fine-tuning of selected parameter matrices rather than full fine-tuning — a parameter-efficient approach that keeps training tractable.

How Fugu Was Trained

Fugu (two stages):

1. Supervised Fine-Tuning (SFT): Worker models are run multiple times on single-step verifiable tasks across coding, math, reasoning, and agentic domains. Their measured performance against ground truth is converted into soft target distributions (via temperature-scaled softmax), and Fugu is trained to match them by minimizing KL divergence.
2. Evolutionary Optimization: Using sep-CMA-ES, Fugu is then optimized end-to-end on real multi-turn coding trajectories, directly maximizing the terminal reward (task completed: 0 or 1).

Fugu Ultra (Conductor + GRPO): Built on the Conductor framework using Group Relative Policy Optimization (GRPO). It is trained to design agentic workflows expressed as natural language — outputting subtasks, worker assignments, and access lists that control which prior outputs each agent can see. It supports arbitrary topologies: best-of-N, sequential chains, and parallelizable trees. A two-stage reward grades (1) whether the workflow is well-formed and parseable, and (2) whether the final answer is correct.

Tool Use and Memory

Fugu Ultra extends to function calling with two notable mechanisms: intra-workflow agent isolation (so one early agent can't lock in the trajectory for everyone downstream) and persistent shared memory (so agents can observe tool calls from previous workflows).

⚠️ Common Mistake: Assuming "multi-agent" automatically means "slow and expensive." Fugu's decision-only routing and single-rate billing are specifically engineered to defeat that assumption. The standard Fugu variant is built to add minimal latency overhead.

7. Fugu vs Fugu Ultra: Which Should You Use?

Sakana ships two variants because real workloads have two very different needs: fast and good enough, versus slower but the best possible answer.

Dimension	Fugu	Fugu Ultra
Optimized for	Latency / everyday use	Maximum answer quality
Underlying mechanism	Trinity (evolved roles)	Conductor (RL orchestration)
Agent pool depth	Standard	Deeper pool of experts
Typical latency	~Comparable to a direct frontier-model call	Higher — trades latency for quality
Best for	Chatbots, interactive apps, high-volume API calls	Hard reasoning, agentic coding, research, multi-step problems
Orchestration style	Lightweight selection	Designs full workflows (chains, trees, best-of-N)

Rule of thumb:

• Reach for Fugu when responsiveness matters and the task is routine — customer support, content drafting, code completion, routine Q&A.
• Reach for Fugu Ultra when the quality of the answer is worth waiting a few extra seconds for — solving a gnarly bug across a large codebase, reproducing a research paper, scientific reasoning, or anything you'd normally escalate to your most senior expert.

💡 Expert Tip: Many teams use both — Fugu as the default for interactive traffic, and Fugu Ultra reserved for an "escalate" button or a nightly batch of hard jobs. Because both share one OpenAI-compatible API, switching is literally a change to the model name string.

8. Benchmarks: How Fugu Actually Performs

Here is where the orchestration thesis is put to the test. The headline finding from the technical report: Fugu Ultra matches or surpasses the strongest frontier models — including Anthropic's Fable 5 and Mythos Preview — without needing direct access to those export-controlled models.

The table below shows results from the Sakana Fugu Technical Report. Higher is better; bold marks the top score in each row.

Benchmark	Fugu Ultra	Fugu	Claude Opus 4.8	Gemini 3.1-Pro	GPT-5.5
SWE-Bench Pro	73.7	59.0	69.2	54.2	58.6
Terminal-Bench 2.1	82.1	80.2	74.6	70.3	78.2
LiveCodeBench v6	92.0	90.3	90.3	88.9	90.7
LiveCodeBench Pro	90.8	87.8	84.8	82.9	88.4
GPQA-Diamond	95.5	95.5	92.0	94.3	93.6
Humanity's Last Exam	50.0	47.2	49.8	44.4	41.4
CharXiv Reasoning	86.6	85.1	84.2	83.3	84.1

A few observations worth sitting with:

• Fugu Ultra tops every row in this table. It doesn't just average its workers — it consistently beats the best individual worker by coordinating them.
• On SWE-Bench Pro and Terminal-Bench, Fugu Ultra posts roughly 5–6% relative gains over the next-best performer — a margin the report characterizes as comparable to an entire model generation's worth of improvement.
• Even the standard Fugu variant is competitive with or ahead of individual frontier models on several coding and reasoning benchmarks, while keeping latency low.

🚀 Pro Tip: The most strategically important number here isn't any single score — it's that Fugu Ultra reaches frontier-class performance while you only pay and integrate once. For teams that can't get access to certain top-tier models directly, orchestration becomes a path to frontier capability that would otherwise be closed.

9. Beyond Benchmarks: Real-World Capabilities

Benchmarks can be gamed; open-ended real tasks are harder to fake. The technical report includes several striking demonstrations.

Autonomous AI research. In an "AutoResearch" experiment optimizing LLM training, Fugu Ultra ran 123 autonomous experiments over roughly 14 hours of wall-clock time, reaching a validation score of 0.9774 ± 0.0019 bits-per-byte — edging out the best baseline (0.9781). In other words, it can drive a genuine research loop, not just answer questions.

Reading classical Japanese. On Kana-Shōsoku (classical Japanese letter reading), Fugu Ultra achieved a 0.776 normalized edit distance versus 0.642 for the strongest baseline — a domain where pure data-driven learning struggles, yet coordination still pulled ahead.

Engineering design (CAD). Asked to generate a mechanical iris (an intricate mechanism of interlocking blades), Fugu Ultra produced a complete, mechanically functional design, while frontier baselines produced incomplete coverage or structurally weak results.

📌 Best Practice: When evaluating Fugu for your own use case, replicate one of these patterns — give it a multi-step, verifiable task (write code that must pass tests, design something that must function, run an experiment with a measurable metric). That's where orchestration's advantage is largest.

10. The Agent Pool: Which Models Fugu Commands

As of launch, Fugu's worker pool is composed of three publicly accessible frontier models:

Worker Model	Provider	Notable strength (per Fugu's routing)
Claude Opus 4.8	Anthropic	Strong coding and agentic reasoning
GPT-5.5	OpenAI	Peaks on terminal/agentic and math tasks
Gemini 3.1-Pro	Google DeepMind	Favored for hard science (e.g., GPQA), chemistry, biology

Two important nuances:

• Some elite models are deliberately not in the pool. Anthropic's Fable 5 and Mythos Preview are excluded because they are not publicly accessible. The remarkable part: Fugu Ultra matches or beats them anyway by coordinating the models it does have.
• The pool is configurable and will grow. You can exclude specific models from your pool to satisfy compliance, privacy, or data-residency requirements — without retraining. Sakana has signaled that open models and its own models will join the pool over time.

✅ Recommendation: If your organization has a "no data to provider X" policy, take advantage of pool exclusion from day one. You keep Fugu's orchestration benefits while honoring your governance constraints.

11. Pricing and Plans

Fugu offers both subscription tiers (predictable monthly cost) and pay-as-you-go token pricing (usage-based). One of its most user-friendly properties: fees do not stack when multiple agents run — you're charged a single rate based on the top-tier model involved.

Subscription Tiers

Plan	Price	Usage	Best for
Standard	$20 / month	Baseline	Occasional API calls, personal experiments
Pro	$100 / month	~10× Standard	Regular coding and research sessions
Max	$200 / month	~30× Standard	Heavy, long-running workloads

Pay-As-You-Go (Fugu Ultra, token-based)

Token type	Standard context	Extended context (272K+)
Input	$5 / million	$10 / million
Output	$30 / million	$45 / million
Cached input	$0.50 / million	$1.00 / million

For the standard Fugu variant, pricing aligns with whichever underlying model is active for your request.

⚠️ Common Mistake: Comparing Fugu's per-token price head-to-head with a single base model and concluding it's "more expensive." That misses the point — you're paying for orchestration plus verification plus synthesis in one call, with no fee stacking. Judge it on cost-per-solved-task, not cost-per-token.

12. How to Get Started With Sakana Fugu

Getting started is intentionally frictionless because Fugu is OpenAI-compatible — most existing integrations work by changing two things: the base URL and the model name.

Step 1 — Create an Account and Get an API Key

Go to the Sakana console at console.sakana.ai/get-started, sign up, and generate an API key. Keep it secret — treat it like a password.

Step 2 — Choose Your Access Method

You have two main paths:

• CLI (fastest for coding): A one-line install brings up Fugu's coding agent.

  curl -fsSL https://sakana.ai/fugu/install | bash
  

  Then launch it with:

  codex-fugu
  

• API (for apps and automation): Point any OpenAI-compatible client at Fugu's endpoint, supply your key, and set the model to fugu or fugu-ultra. Fugu supports both Chat Completions and Responses endpoints.

💡 Expert Tip: Because the API is OpenAI-compatible, you usually only need to override the base_url and api_key in your existing SDK setup and swap the model string. No rewrite of your app's logic required.

Step 3 — Send Your First Request

Conceptually, your call looks just like a standard chat request — set the model to fugu for fast everyday work or fugu-ultra for hard problems, send your messages, and read the single response Fugu returns. Optionally configure your worker pool to exclude any provider you don't want involved.

⚠️ Heads up on availability: At launch, Fugu is not available in the EU or EEA while Sakana completes GDPR compliance work, with no published timeline yet. Check current availability for your region before building on it.

13. Use Cases by Audience

Fugu is general-purpose, but its value lands differently depending on who you are.

For beginners and hobbyists. Start on the Standard plan ($20/mo) with the fugu model. You get frontier-quality answers without learning agent frameworks, prompt-routing, or multi-model plumbing. It's the simplest way to access "the best available answer" through one key.

For professional developers. Use the CLI for in-terminal coding and fugu-ultra for hard, cross-file bugs and agentic tasks. The OpenAI compatibility means you can A/B test Fugu against your current model by swapping a string in CI.

For businesses. Fugu reduces vendor lock-in risk — if one provider changes pricing or access, Fugu reroutes. Single-rate billing simplifies cost forecasting, and pool exclusion supports compliance. The decision-only latency design makes the base fugu model viable for customer-facing apps.

For students and researchers. Fugu is unusually transparent for a commercial product — the technical report and the Trinity/Conductor papers are public, making it an excellent case study in orchestration, evolutionary optimization, and RL-based coordination. The AutoResearch demo also hints at autonomous experimentation workflows.

For agencies. Recommending Fugu lets you deliver frontier-class results to clients without managing three separate provider relationships, three billing accounts, and three sets of rate limits. One integration, one invoice, broad capability.

🚀 Pro Tip: Agencies and businesses should benchmark Fugu Ultra on their own representative tasks before committing — orchestration's advantage is largest on multi-step, verifiable work, so your real ROI depends on your task mix.

14. Sakana Fugu vs Traditional Single-Model APIs

How does Fugu stack up against simply calling one frontier model directly? Here's an honest side-by-side.

Factor	Sakana Fugu	Single-Model API
Capability ceiling	Coordinates multiple models; can beat any one of them	Capped at that one model's ability
Integration effort	One OpenAI-compatible endpoint	One endpoint
Vendor lock-in	Low — reroutes across providers	High — fully dependent on one vendor
Access to elite models	Reaches frontier-class results even without access to certain top models	Blocked if you lack access
Billing	Single rate, no fee stacking	Single rate
Routing control	Learned + configurable pool exclusion	N/A (only one model)
Latency (best case)	Fugu ≈ direct call; Fugu Ultra higher	Baseline
Transparency of routing	Proprietary (routing details not exposed)	Fully known (it's just one model)
Regional availability	Limited (no EU/EEA at launch)	Varies by provider

Pros and Cons

Pros

• Frontier-class quality, often exceeding any single worker
• Provider independence and resilience
• One integration, one bill, configurable pool
• Built on peer-reviewed, public research
• Low-latency option (fugu) for interactive apps

Cons

• Routing is proprietary — you can't see exactly which model handled what
• Fugu Ultra adds latency for its quality gains
• Not available in EU/EEA at launch
• Can't exceed its best worker on genuinely novel tasks where no worker is strong

Winner: For multi-step, high-value, verifiable work, Fugu Ultra is the clear choice — frontier-class output with resilience baked in. For ultra-simple, latency-critical, single-shot calls where you already have access to a top model and full routing transparency matters, a direct single-model API can still be the pragmatic pick. Most teams benefit from using Fugu as the default and keeping a direct model on hand for edge cases.

15. Limitations and Things to Watch

A definitive guide owes you the caveats, not just the highlights.

• It can't beat its best worker on truly novel tasks. Fugu coordinates existing models; on problems where no worker is competent, orchestration has nothing strong to route to.
• Routing is a black box. The specific models Fugu picks and how it coordinates them are proprietary and not exposed — a trade-off for the simplicity.
• Results vary with prompts and trials. As with any LLM system, the report notes outputs can vary across runs and phrasings.
• Fugu Ultra latency. Its quality comes from multi-step orchestration, which costs time. Don't put fugu-ultra on a latency-critical hot path; use fugu there.
• Regional gating. No EU/EEA availability at launch pending GDPR work.
• Pool depends on public access. Certain elite models (e.g., Fable 5, Mythos Preview) aren't in the pool because they aren't publicly accessible — though Fugu Ultra still matches them.

📌 Best Practice: Treat Fugu like hiring a brilliant general contractor. It coordinates great specialists superbly — but it can't conjure expertise that none of its specialists possess. Match it to tasks where strong workers exist.

16. Expert Tips and Best Practices

A consolidated cheat-sheet for getting the most out of Sakana Fugu.

• Default to fugu, escalate to fugu-ultra. Wire an "escalate" path rather than running everything on Ultra. You'll save latency and money while reserving maximum quality for when it matters.
• Benchmark on your own tasks. Public benchmarks predict capability but not your ROI. Run a small eval on representative, verifiable tasks.
• Lean into verifiable problems. Fugu's orchestration shines when success is measurable — passing tests, correct math, functional designs. Frame tasks that way when you can.
• Use pool exclusion for governance. If data residency or vendor policy matters, configure exclusions up front.
• Don't double-orchestrate. Avoid wrapping Fugu in your own agent framework; it already orchestrates internally.
• Forecast cost per solved task, not per token. Single-rate, no-stacking billing changes the math in Fugu's favor for complex work.
• Watch the changelog. The pool is set to expand to open and Sakana's own models — capabilities and economics will shift over time.

✅ Recommendation: Start with the $20 Standard plan and the CLI to build intuition, then graduate to API integration and fugu-ultra once you've identified the high-value tasks where orchestration earns its keep.

Conclusion

Sakana Fugu represents a genuinely different bet on where AI capability comes from. Instead of asking "how big can one model get?", it asks "how well can many models cooperate?" — and answers that question with a system that, in its Ultra form, reaches frontier-class performance while remaining a single, simple API call.

For developers, it collapses the complexity of multi-agent systems into one model name. For businesses, it offers resilience against vendor lock-in and access to top-tier results even without direct access to the most exclusive models. For students and researchers, it's a public, well-documented case study in the future of orchestrated intelligence. And for everyone, it's a preview of an architecture that may define the next phase of applied AI — not one brain to rule them all, but a coordinated school of them.

The pufferfish, it turns out, is more than a clever name. It's a thesis: that the safest path to enormous capability is expert coordination. With Fugu, Sakana AI has made that thesis something you can call from a single line of code.

🚀 Pro Tip: The best way to understand Fugu is to use it. Spin up the $20 plan, give fugu-ultra a hard, multi-step problem you'd normally hand to your most senior engineer, and watch the orchestra play.

Sources

• Sakana AI — Fugu product page
• Sakana AI — Fugu release notes
• Sakana Fugu Technical Report (arXiv)
• SakanaAI/fugu — GitHub
• Sakana developer console