What Is Sakana Fugu? Inside Sakana AI’s Multi-Agent System (2026 Guide)
Sakana Fugu, built by Sakana AI, is a model interface for coordinating specialized AI agents through one OpenAI-compatible API. Instead of you wiring up an agent pipeline by hand, Fugu learns to assemble a pool of models, assign them roles, and route work between them on its own — so a genuinely multi-agent AI model shows up on the outside as a single chat completion. It ships in two flavors, Fugu (fast, balanced) and Fugu Ultra (deeper coordination for hard, high-stakes tasks), and its agent orchestration logic is grounded in two ICLR 2026 papers, TRINITY and the Conductor.
- Developer
- Sakana AI
- Release
- 2026
- API
- OpenAI-compatible
- Architecture
- Multi-agent orchestration
- Models
- Fugu, Fugu Ultra
- Research basis
- TRINITY & the Conductor (ICLR 2026)
- Pricing
- $20–$200/month, or pay-as-you-go
- Availability
- Worldwide, except EU/EEA
If you’ve spent any time wiring up agent pipelines yourself — defining a router node here, a verifier step there — you already know the unglamorous part of agentic AI isn’t the models. It’s the plumbing. Sakana AI’s pitch with Fugu is that the plumbing itself can be learned, not designed, and the result is a product that’s strange to categorize: it’s a multi-agent system, sold and billed as if it were one model. I’ll admit I went into the sakana fugu documentation expecting another orchestration wrapper with a new name — what changed my mind was the agent orchestration research underneath it, which I’ll get into below.
- 1What Sakana Fugu actually is and how it differs from a normal multi-agent pipeline
- 2The research behind it — TRINITY and the Conductor papers
- 3Fugu vs. Fugu Ultra — which one fits which workload
- 4Benchmark results against Opus 4.8, Gemini 3.1 Pro, and GPT 5.5
- 5Pricing, plans, and regional availability
- 6My take: is this “real” multi-agent, or just a wrapper?
What Is Sakana Fugu?
Most agentic systems you build today are explicit. You pick a router model, you pick worker models, you write the conditionals that decide who does what and in what order. The orchestration logic lives in your code — in your n8n canvas, your LangGraph state machine, your custom Python loop.
Fugu inverts that. Sakana describes it as a multi-agent AI model that doesn’t use “domain knowledge to prescribe team organization, roles, or workflows” — instead, it learns to dynamically assemble agents from a pool and coordinate them through collaboration patterns that aren’t necessarily obvious to a human designer, but turn out to be efficient. You send one request to one endpoint, and a coordinated team of models handles it on the other side.
How Does Sakana Fugu Work?
Internally, Fugu decides which models to call, what role each one plays, and how their outputs get merged into the answer you receive — all inside the same request-response cycle you’d use with any single model. Sakana isn’t presenting this as a black box conjured from nowhere, either: it ties the system directly to two of its own ICLR 2026 papers on learned model orchestration.
TRINITY
A lightweight evolved coordinator that runs multiple LLMs over several turns, assigning each one a Thinker, Worker, or Verifier role and adaptively delegating work across coding, math, reasoning, and knowledge tasks.
The Conductor
Trained with reinforcement learning to discover natural-language coordination strategies — designing agent communication patterns and focused prompts that let diverse LLM pools outperform any single worker on hard reasoning benchmarks.
Here’s what I kept coming back to while reading the technical report: the role assignment and hand-off logic aren’t hard-coded by Sakana’s engineers. They’re trained behavior. That’s the actual novelty of “multi-agent as a model” — the orchestration itself is a learned skill, not a flowchart someone drew once and shipped.
Fugu vs. Fugu Ultra: Two Models, One Endpoint
Sakana ships sakana fugu in two variants behind the same OpenAI-compatible API, so switching between them doesn’t require touching your integration code.
Fugu
Balanced performance & latencyThe everyday default — strong results without the wait. Built to sit inside responsive tools.
- Coding & code review (e.g. Codex-style tools)
- Responsive chatbot products
- Opt specific models out of the pool for compliance
Fugu Ultra
Optimized for performanceA deeper agent pool, coordinated for maximum answer quality on hard, high-stakes problems — at the cost of speed.
- Kaggle competitions
- Academic paper reproduction
- Cybersecurity & patent/literature analysis
Benchmark Results: How Sakana Fugu Stacks Up
Sakana published head-to-head numbers against Opus 4.8, Gemini 3.1 Pro, and GPT 5.5 across coding, reasoning, and science-heavy benchmarks. A few of the standout rows:
| Benchmark | Fugu | Fugu Ultra | Opus 4.8 | Gemini 3.1 Pro | GPT 5.5 |
|---|---|---|---|---|---|
| SWE Bench Pro | 59.0 | 73.7 | 69.2 | 54.2 | 58.6 |
| TerminalBench 2.1 | 80.2 | 82.1 | 74.6 | 70.3 | 78.2 |
| LiveCodeBench | 92.9 | 93.2 | 87.8 | 88.5 | 85.3 |
| GPQA-Diamond | 95.5 | 95.5 | 92.0 | 94.3 | 93.6 |
| Humanity’s Last Exam | 47.2 | 50.0 | 49.8 | 44.4 | 41.4 |
| SciCode | 60.1 | 58.7 | 53.5 | 58.9 | 56.1 |
One qualitative example stands out for agentic-workflow builders specifically: in an AutoResearch test, an agent ran 123 experiments over roughly 14 hours on a single H100 GPU, iteratively editing a small GPT’s training recipe. Fugu Ultra finished with the best mean validation score across the run — ahead of all three frontier baselines — which says more about sustained, multi-step agentic reliability than any single-turn benchmark does.
“For code review, Fugu Ultra is significantly better than GPT-5.5. Where other tools flag about three issues, Sakana Fugu surfaced more than twenty.”
Pricing: Subscription and Pay-As-You-Go
Sakana offers three monthly tiers, each bundling access to both Fugu and Fugu Ultra, plus a token-based pay-as-you-go plan for production-scale load.
For pay-as-you-go on Fugu Ultra specifically: $5 per million input tokens, $30 per million output tokens, $0.50 per million cached input tokens — rising to $10 / $45 / $1.00 once context passes 272K tokens. Fugu’s own pricing blends rather than stacks: even with multiple agents active, you’re billed one rate, based on the top-tier model in that pool — not the sum of every model touched.
How Does Sakana Fugu Compare to Building Your Own Agent System?
This is the question I actually care about, since I build agent pipelines for a living. Fugu isn’t competing with n8n or LangGraph on the same axis — it’s optimizing for a different thing entirely. n8n and LangGraph give you a visible, controllable orchestration layer that you design; Fugu gives you a learned orchestration layer you can’t see inside of. Here’s how that trade-off breaks down feature by feature:
| Feature | Fugu | n8n | LangGraph |
|---|---|---|---|
| Easy setup | ✅ | ⚠️ | ❌ |
| Routing visibility | ❌ | ✅ | ✅ |
| Debugging individual steps | ❌ | ✅ | ✅ |
| Tool / external API calling | Limited | ✅ | ✅ |
| Full control over agent roles | ❌ | ✅ | ✅ |
| Coordination quality out of the box | ✅ | ⚠️ | ⚠️ |
| Setup time for a working pipeline | Minutes | Hours–days | Hours–days |
The pattern that jumps out: Fugu wins on setup speed and out-of-the-box coordination quality, and loses on everything related to visibility and control. That’s not a flaw in Fugu’s design — it’s the entire premise of the product. You’re trading the ability to inspect and steer individual steps for not having to build that orchestration layer in the first place. Whether that trade makes sense depends entirely on whether your use case needs auditability (a security review, a regulated workflow) or just needs a strong final answer (a coding assist, a research summary).
I’ll be honest — when I first opened the Fugu page I expected another orchestration wrapper with a fresh coat of branding. The TRINITY and Conductor papers are what made me sit up and actually rethink that assumption, because the role-switching isn’t something Sakana’s team designed by hand; it’s something the system learned to do on its own.
I’ve spent years building agent systems with visible orchestration — in n8n, that’s a router node, a worker agent, a verifier step, conditional branches based on confidence scores. That visibility isn’t a limitation for me, it’s the point: when something breaks, I can see exactly which node failed and why.
Fugu deliberately gives that up. It really is running something like Thinker/Worker/Verifier roles internally, switching models mid-task — but every bit of that machinery sits behind one chat-completion call. You never see the hand-offs. You never know which model answered which sub-part. You just get a final response, and Sakana confirms this is intentional: routing information isn’t exposed by design. I can see why some teams would love that simplicity, but I’d personally miss the visibility that n8n and LangGraph-style pipelines give me — especially on a production system where I need to know *why* something went wrong, not just that it did.
When I went through the benchmark numbers, I was actually more interested in the AutoResearch experiment than the headline scores — 123 unsupervised experiments over 14 hours tells you more about whether the coordination holds up under sustained pressure than any single-turn benchmark does. What you gain: zero orchestration code and strong results on exactly that kind of sustained agentic work. What you lose: the debuggability that hand-built pipelines give you. If Fugu’s internal verifier misjudges something, there’s no step to inspect.
For an n8n-based agentic workflow, I wouldn’t treat Fugu as a replacement for the orchestration layer you build yourself — I’d treat it as an unusually capable single node you drop into that workflow, one that happens to be running its own internal multi-agent coordination for whatever sub-task you hand it. You’d still want your own pipeline for business logic, tool access, and auditability. Fugu solves a narrower problem — squeezing maximum quality out of model coordination for a given task — extremely well. It doesn’t solve “I need to see and control every step,” which is often the actual reason people build agentic systems by hand in the first place.
Final Verdict: Where Sakana Fugu Fits
See the hand-built version of orchestration — the workflow approach Fugu is trying to automate away.
Sakana Fugu FAQ
Is Sakana Fugu actually a multi-agent system, or just one model?
It’s genuinely multi-agent on the inside — it assembles and coordinates a pool of specialized models per task — but it’s exposed to developers as a single OpenAI-compatible endpoint. You interact with it like one model; the multi-agent coordination happens entirely behind the API.
Which model should I start with, Fugu or Fugu Ultra?
Start with standard Fugu for everyday coding, chat, or review tasks where latency matters. Move to Fugu Ultra only for harder, high-stakes work — research reproduction, security assessments, competition-style problems — where you can tolerate slower responses for better accuracy.
Can I see which underlying models Fugu used for my request?
No. Sakana keeps the specific models and coordination logic proprietary and doesn’t expose routing information by design — a deliberate trade-off for anyone who wants full visibility into their agent stack.
Does Sakana Fugu replace tools like n8n for agentic workflows?
Not really — it solves a different layer of the problem. n8n-style tools give you visible, controllable orchestration across your own business logic and tool calls. Fugu is better thought of as a very strong single node you could plug into that kind of workflow when a sub-task needs maximum model-coordination quality.
Is Sakana Fugu available worldwide?
It’s available outside Japan, but not currently in the EU or EEA while Sakana works toward GDPR-aligned compliance. Access elsewhere may also depend on local network conditions or regulations.
How do I access Sakana Fugu?
Sign up through the Sakana console, generate an API key, and point your existing client or coding harness at the Fugu endpoint. There’s no separate SDK to install — it works with the tooling you already have.
Who owns Sakana Fugu?
Sakana Fugu is built and operated by Sakana AI, a Japan-based AI research company. The system is grounded in two of the company’s own ICLR 2026 papers on learned model orchestration, TRINITY and the Conductor.
Can you use Sakana Fugu with the OpenAI SDK?
Yes. Fugu exposes an OpenAI-compatible API, so you can point the standard OpenAI SDK (or any client built against it) at the Fugu endpoint with your API key and start sending requests — no code migration required.
Source: Sakana Fugu official page.
