Sakana AI's Fugu Explained: How the Multi-Agent Model Orchestrates Frontier LLMs

What Fugu Actually Is

Sakana AI describes Fugu as a multi-agent system as a model. You send one request to a single endpoint, and Fugu decides how to distribute the work across a pool of specialist models. That pool is not locked to a single vendor. The system can dynamically assemble agents, coordinate them, and even let users opt out of specific models or providers to fit privacy, data, or compliance requirements. The goal is to keep the API simple while making the backend coordination much smarter than a hand-built router.

There are two public variants:

• Fugu – balances latency and quality
• Fugu Ultra – uses a deeper pool of agents for harder tasks

This split is useful because not every task deserves the most expensive path. A lot of day-to-day coding, review, and internal support work needs a fast default. More difficult tasks, like deep reasoning, paper reproduction, or security analysis, can justify a heavier orchestration setup.

How It Works

The basic workflow is different from a normal single-model call. First, the incoming task is routed into a learned coordination process. Fugu decides which agents should participate, what role each one should play, and how the exchange should proceed. The system learns collaboration patterns that are not obvious to a human operator, but work well in practice.

Fugu is grounded in two ICLR 2026 papers: TRINITY and Conductor. TRINITY uses a lightweight evolved coordinator that assigns roles like Thinker, Worker, and Verifier across a multi-turn task. Conductor learns natural-language coordination strategies with reinforcement learning. Together, they show that instead of hand-designing every workflow, you can train a system to discover how to orchestrate other models. This points to a broader shift: while the last wave of AI progress focused on making single models stronger, this wave is about making model systems smarter.

Why the Orchestration Layer Matters

Most teams already know that different models are good at different things. While one model might excel at code, others are better suited for long reasoning or factual retrieval. In a hand-built stack, someone has to decide when to call which model, how to verify the output, and when to stop paying for more inference. Fugu tries to learn those decisions instead of hard-coding them.

This approach improves cost-performance. If the system can route easy subtasks to lighter agents and reserve heavier agents for the hard parts, the overall result can be better than sending every request to the most expensive model in the pool. It also improves reliability. A lot of failures in agentic systems happen because orchestration is brittle. When one model does everything, a single mistake ripples through the whole chain. Fugu's design reduces that risk by using specialists and verification roles more deliberately.

Fugu versus Fugu Ultra

The difference between the two variants is mostly about how much orchestration you want to pay for. Fugu is the balanced option, designed as the practical default for coding, interactive work, and general workloads where latency still matters. Fugu Ultra goes further, with Sakana positioning it for more complex, high-stakes, multi-step work where answer quality matters more than speed. The examples they highlight include paper reproduction, Kaggle competitions, security analysis, literature review, and patent research.

This framing shows what the product is really for. Fugu is not just a better chat model; it is a system for tasks where the model has to reason, delegate, verify, and even disagree with itself before it answers.

What the Benchmarks Suggest

Sakana reports strong performance across coding, reasoning, science, and agentic benchmarks. Fugu and Fugu Ultra compare well with publicly available frontier models, sometimes sitting right alongside or ahead of them. The benchmarks they call out include:

• SWE-Pro for coding
• TerminalBench for terminal and tool use
• LiveCodeBench and LiveCodeBench Pro
• Humanity's Last Exam for hard reasoning
• GPQA-D for scientific reasoning
• SciCode
• Long-context reasoning
• MRCRv2

The exact numbers matter less than the pattern. Rather than claiming to be a single monolithic model, Fugu demonstrates that orchestration itself can produce frontier-level results on difficult tasks. Their qualitative examples make that point even more clearly. Sakana shows Fugu on tasks like autonomous research, classical Japanese reading-order recovery, Rubik's Cube solving, CAD generation for a mechanical iris, blindfold chess, and trading simulations. These environments are very different, but they all reward a system that can choose the right internal strategy instead of guessing once and hoping for the best.

The Product Details That Matter

Fugu is delivered through an OpenAI-compatible API, which means teams do not need to rebuild their integration layer to try it. If you already have a client, a harness, or an internal agent stack that talks to an OpenAI-style endpoint, Fugu slots in without much friction.

Sakana offers both subscription and pay-as-you-go plans. The pay-as-you-go model avoids stacking fees across every model in the pool; you pay a single rate based on the top-tier model involved in the configured pool. This makes orchestration financially viable instead of prohibitively expensive.

One limitation: Fugu is not yet available in the EU/EEA while Sakana works toward compliance.

Why This Is a Bigger Product Than It Looks Like

At first glance, Fugu sounds like a very good router, but that description undersells it. The deeper idea is that model orchestration itself is becoming a first-class capability. If that holds, the value is not only in better benchmark scores, but in turning a pile of expensive, specialized models into a single system that a team can use without hand-tuning workflows from scratch. The system is useful for real teams because it hides just enough complexity to make multi-model workflows practical.

There is also a strategic angle. Relying on one provider for every critical task is a risk. A learned orchestration layer that can route around constraints, swap agents, or exclude a provider reduces that dependency. Sakana is clearly leaning into that idea.

Where teamcopilot.ai Fits

teamcopilot.ai is a shared control layer for AI workflows, permissions, and approvals. That makes it a natural fit for a system like Fugu. If Fugu is the orchestration engine for a task, teamcopilot.ai is the governance layer around it. You can route work through reusable workflows, keep approvals visible, and decide who can do what before the model ever touches the task. Production AI requires making models safe, repeatable, and shareable across a team.

Related reads:

• AI Agent Governance Is the New Enterprise Control Plane
• Why Your AI Agent Should Never See Your API Keys
• Best AI Agent Platforms for Teams in 2026: Comparing 13 Tools
• How to Use Claude Code with a Team: Shared Context, Permissions, and MCP

The Tradeoffs

Fugu is impressive, but it has tradeoffs. Latency will always be part of the conversation when a system calls into multiple models or multiple agent steps. If you need instant responses for a live UI, a simpler single-model path may still win. The routing logic is also proprietary. Sakana does not expose the exact internal selection process, so you get the benefits of orchestration without full visibility into every decision. Additionally, while the standard Fugu allows opt-outs, Fugu Ultra uses the full agent pool. If you need strict control over every provider in the loop, that is worth keeping in mind.

Still, these are normal tradeoffs for a new product category. The real test is whether the system earns that complexity back with better results.

The Bigger Takeaway

Fugu is a sign that the market is moving from single-model thinking to system thinking. That change is easy to miss if you only look at raw benchmark numbers, but the product story is clear. Sakana AI is betting that the most useful AI systems will be coordinated pools of models, with a learned layer deciding how to use them. Many teams are already heading in this direction manually, and Fugu simply makes the orchestration layer explicit.

FAQ

What is Sakana Fugu?
Sakana Fugu is a multi-agent orchestration system presented as a single model API. It coordinates a pool of frontier models instead of relying on one model to do everything.

Is Fugu a model or a product?
It is both. Sakana exposes it as a model API, but the real value is in the orchestration system behind it.

What is the difference between Fugu and Fugu Ultra?
Fugu is the balanced, lower-latency option. Fugu Ultra uses a deeper agent pool for harder, higher-stakes tasks where quality matters more than speed.

How does Fugu work?
It routes tasks across multiple specialist models, assigns roles, and coordinates the response. The research behind it comes from TRINITY and Conductor.

Why not just call one frontier model directly?
Because different models excel at different tasks. Fugu decides when to delegate, verify, or switch strategies instead of making one model carry the whole load.

Can I control which models Fugu uses?
Yes, for Fugu. Sakana lets you opt out of specific models or providers to fit privacy, data, or compliance needs. Fugu Ultra uses the full pool.

Is Fugu OpenAI-compatible?
Yes. It fits into existing clients and agent stacks without requiring a major integration rewrite.

What tasks is Fugu best for?
Coding, reasoning, research, security analysis, paper reproduction, and other multi-step workflows where orchestration matters.

Is Fugu good for real-time apps?
Not necessarily. The more agents you coordinate, the more latency becomes a factor, so it may not be ideal for instant responses.

Does Fugu show which underlying models it used?
No. Sakana treats the exact routing logic as proprietary.

Can teams use Fugu safely?
Yes, if the surrounding workflow is controlled. Approval layers, audit trails, and secret handling are essential for making any model safe and useful in a team setting.

Why should teams care about orchestration at all?
Because orchestration is where real productivity wins happen. Choosing the right model for the right subtask can matter as much as choosing the model itself.

Where does teamcopilot.ai fit in?
teamcopilot.ai provides a shared control layer for AI workflows, permissions, and approvals, making it easy to run systems like Fugu inside a governed, reusable process.

Will Fugu replace single-model workflows?
Not entirely. Simple tasks are still better served by a single call, but harder workflows that benefit from delegation and verification will increasingly rely on systems like Fugu.