What Is Sakana Fugu?

Sakana Fugu is a multi-agent orchestration system that Sakana AI ships as a single foundation model behind one OpenAI-compatible API. It is a trained language model specialized in delegation, agent communication, and work synthesis, and it dynamically coordinates a pool of other LLMs (including recursive copies of itself) to answer a single prompt. Sakana announced it on June 22, 2026 under the headline “One Model to Command Them All” (see the official release page). If you have read our breakdowns of other frontier releases like Claude Fable 5, Fugu is a different kind of animal: it is a conductor, not a soloist.

The name fits the design. Fugu is the Japanese pufferfish, a delicacy that is lethal unless a skilled chef prepares it exactly right. Raw power that only becomes useful through careful preparation is a good way to think about a system whose whole value comes from how it coordinates other models.

TL;DR

What it is: A trained “conductor” LLM that orchestrates a team of frontier models behind one endpoint. Two variants: “Fugu” (balanced, low latency) and “Fugu Ultra” (maximum answer quality). The pitch: One OpenAI-compatible API; point your existing client at it, no SDK migration. The catch: Fugu calls other vendors’ models (recursively including itself), so its benchmark wins are model-of-models results, not single-model wins. Access: Product page plus console.sakana.ai behind a Google/email login.

What Sakana Fugu actually is

Most foundation models answer you directly. You send a prompt, the weights run a forward pass, you get tokens back. Fugu adds a layer on top of that idea.

Fugu is a trained language model whose specialty is coordination. When a request arrives, Fugu decides whether to answer it itself or to assemble a team of other models, hand each one a piece of the work, route messages between them, and synthesize the results into a single answer. Per Sakana, the conductor can even spin up recursive instances of itself as team members. You see one response. Behind it, several models may have done the work.

This is why the “single foundation model” framing matters and also why it needs an asterisk. From your code, Fugu looks like one model with one endpoint. Architecturally, it is a model-of-models. We unpack that honesty point in detail below, because it changes how you should read every benchmark number.

The branding leans into a fish theme on purpose. “Sakana” is Japanese for “fish,” and the company’s identity centers on school-of-fish collective intelligence, many small agents producing behavior smarter than any one of them. Fugu is the pufferfish member of that school.

The two variants: Fugu and Fugu Ultra

Sakana ships two variants through the same API.

Fugu is the balanced, low-latency option. Sakana positions it for everyday work: coding, code review, chatbots, and interactive services where response time matters. This is the variant the beta and much of the early press called “Fugu Mini.” Lead with “Fugu”; “Mini” is just the old beta name.

Fugu Ultra targets maximum answer quality. Sakana points it at heavier work: AI research, paper reproduction, cybersecurity analysis, and literature or patent investigation. You trade latency for depth.

Both variants run behind one endpoint. Fugu itself decides, per request, whether to answer directly or to assemble a team, so you do not micromanage the orchestration. If you want the full mechanics and a deeper comparison, our Fugu Ultra vs Fable 5 vs Mythos breakdown sits alongside this article in the same cluster.

Spec table

How the orchestration works

The core of Fugu is a learned conductor, not a hand-written router. That distinction is the real story.

A traditional router picks one model for a request and forwards it. Tools like OpenRouter or Martian do this well. An agent framework like Swarm, AutoGen, or LangGraph goes the other way: it gives you the plumbing to build a team, but you, the human, write the coordination logic. Fugu sits between those two. It is a model trained to be the coordinator. It learns when to delegate, how to split work, what to ask each agent, and how to merge their outputs.

Per Sakana, the conductor handles three jobs:

• Delegation. It chooses which agents (or recursive copies of itself) get which subtasks.
• Communication. It manages the messages flowing between agents, shaping the team’s structure on the fly.
• Synthesis. It combines partial results into one coherent answer.

Two more mechanics make Fugu distinct, and both lean toward governance:

• Swappable agents. The pool is not fixed. Teams can opt specific agents out for data or compliance reasons, so you can keep a given vendor’s model out of your requests entirely.
• Routing around restrictions. Per Sakana, Fugu “dynamically routes around” provider restrictions, picking a different agent when one is unavailable or disallowed.

If you want the conceptual cousin in this cluster, the Mythos-class model explainer covers the single-model frontier tier that Fugu measures itself against.

The honesty box: orchestrator, not a single model

This is the part to read twice.

Fugu is an orchestrator that calls other vendors’ frontier models, recursively including itself. When you see a Fugu benchmark result, it may have been produced by Fugu calling Opus 4.8 (or Fable 5, or several models) and synthesizing their outputs. That is a model-of-models result. It is not a like-for-like single-model win. Fable 5 and Mythos are single Anthropic models that answer from their own weights. Comparing Fugu’s numbers to theirs without that caveat is comparing a team to an individual.

Keep this in mind for two specific claims Sakana makes.

First, per Sakana, Fugu Ultra “stands shoulder-to-shoulder with leading models like Fable 5 and Mythos Preview” across engineering, scientific, and reasoning benchmarks. Read that as a parity claim, not a “beats” claim. Note also that Sakana named the older Mythos Preview (April), not the current Mythos 5.

Second, and separately, per Sakana, Fugu “consistently outperforms” Gemini 3.1 Pro (high), Opus 4.8 (max), and GPT 5.5 (xhigh) on a specific set of applications: AutoResearch, Rubik’s Cube, Mechanical Design, Japanese Handwriting Analysis, One-Shot Chess, and Financial Time Series Prediction. Even here, the honesty point holds. A “beats Opus 4.8” result can come from Fugu calling Opus and adding orchestration on top. The orchestrated team can beat the soloist while still depending on the soloist.

This is not a knock on Fugu. Orchestration is a real capability. It is a reason to label the numbers correctly. We never present Fugu’s results as a single-model win, and you should not either.

For reference, Fable 5 is Anthropic’s most powerful generally available model, a Mythos-class model made safe for public use and a tier above Opus 4.8. Mythos Preview (April 7, 2026) was the frontier model Anthropic deemed too dangerous to release. Our Claude Fable 5 explainer has the full picture on that side.

The research lineage: Trinity and Conductor

Fugu did not appear from nowhere. Two real, citable ICLR 2026 papers form its research moat, and they use different methods.

Trinity: An Evolved LLM Coordinator (arXiv:2512.04695) describes a tiny coordinator, under 20,000 parameters, optimized by derivative-free evolution. It assigns Thinker, Worker, and Verifier roles. The headline is that a very small evolved controller can drive a useful multi-agent loop.

Conductor: Learning to Orchestrate Agents in Natural Language (arXiv:2512.04388) describes a 7B model trained with reinforcement learning that learns the communication structure between agents. It claims to beat Mixture-of-Agents at lower cost.

These are different methods (evolution versus RL) and different sizes (sub-20K versus 7B). Do not conflate them. Sakana has not published a parameter count for the shipped product, so applying the 7B, Qwen2.5, or GRPO specifics to Fugu itself is third-party inference, not an official spec.

The honest framing of novelty: Mixture-of-Agents (Together AI, ICLR 2025) already showed that orchestrated models can beat a single model. Fugu’s narrow real novelty is a learned, adaptive, cost-selective topology shipped as one endpoint, backed by that trained-conductor research.

What early users report

Sakana shares two testimonials worth repeating with attribution.

A software engineer using Fugu Ultra for code review said it surfaced “more than twenty” issues in cases where other tools flag “about three,” and called it better than GPT-5.5. A security engineer said one scoped instruction drove a full end-to-end assessment, recon, XSS and SQLi probing, and an auth review, while staying inside the defined scope.

Treat these as vendor-reported anecdotes, not benchmarks. They are useful signal for where Fugu’s orchestration helps most: tasks that decompose well into parallel subtasks with a verification step at the end. If you are mapping Fugu against Sakana’s other release, the Mirofish explainer covers the sibling model in the same lineup.

Using the Fugu API

Fugu exposes one OpenAI-compatible endpoint. That is the practical selling point: if you already have an OpenAI client, you point it at Fugu’s base URL and use your Fugu key. No SDK migration. The same Chat Completions shape you know from the OpenAI API docs applies here.

One important caveat. As of 2026-06-22, the base URL is not published on any public page. Do not guess it. Copy the real base URL from your dashboard at console.sakana.ai and drop it into the placeholder below.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_FUGU_API_KEY",
    base_url="<YOUR_FUGU_BASE_URL_FROM_CONSOLE>",  # copy from console.sakana.ai
)

# Balanced variant for everyday work
response = client.chat.completions.create(
    model="fugu",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {"role": "user", "content": "Review this function for off-by-one bugs."},
    ],
)
print(response.choices[0].message.content)

Switch to Fugu Ultra by changing one string:

response = client.chat.completions.create(
    model="fugu-ultra",  # max-quality variant; reported id, verify in console
    messages=[
        {"role": "user", "content": "Reproduce the headline result from this paper."},
    ],
)

The model id strings (fugu, fugu-ultra, and a reported dated variant) come from secondary reporting. Confirm the exact strings in the console before you ship. For a full, tested walkthrough, see our guide on how to use the Sakana Fugu API.

How this fits your Apidog workflow

Because Fugu speaks the OpenAI Chat Completions format, you can test it the same way you test any other LLM endpoint. Set the base URL you copied from the console as an environment variable in Apidog, add your key as a bearer token, and send a request to the chat completions path. You get a clean request and response view, you can save the call as a reusable case, and you can compare Fugu against Fable 5 or Opus 4.8 side by side in the same project.

That last part matters for Fugu specifically. Since it is an orchestrator, latency and cost will vary more than a single model’s, depending on how big a team it assembles. Capturing real request timings and token counts in Apidog gives you the actual numbers instead of the marketing ones. Download Apidog and point a new request at your console base URL to start.

Frequently asked questions

Is Sakana Fugu a single model or many models?

Both, depending on how you look at it. To your code it is one model behind one API. Internally it is a trained conductor that calls a pool of other frontier models and synthesizes their work. That is why we flag its benchmark numbers as model-of-models results rather than single-model wins. See our Mythos-class model explainer for the single-model tier it compares against.

What is the difference between Fugu and Fugu Ultra?

Fugu is the balanced, low-latency variant for everyday work like coding and chatbots. Fugu Ultra trades latency for maximum answer quality and targets research, security analysis, and deep investigation. Both run through the same endpoint, and you select between them with the model id. The older “Fugu Mini” name referred to the small variant during beta.

Does Fugu really beat Opus 4.8 and GPT 5.5?

Per Sakana, Fugu “consistently outperforms” Gemini 3.1 Pro, Opus 4.8, and GPT 5.5 on a specific list of applications. The honest reading is that Fugu can call those same models and add orchestration on top, so a win for the team does not mean Fugu’s own weights beat any one model. We never present it as a single-model win.

How do I call the Fugu API?

Point an OpenAI-compatible client at Fugu’s base URL with your key, then use the standard Chat Completions request shape. The base URL is not published publicly, so copy it from console.sakana.ai. Our Sakana Fugu API guide walks through a working example end to end.

Is Fugu available to everyone right now?

Access runs through the product page and console.sakana.ai behind a Google or email login. The beta ran with roughly 500 users from late April 2026. Whether fully self-serve GA sign-up is open, and whether there is an EU/EEA restriction, are both worth checking live in the console.

How is Fugu different from a router or an agent framework?

A router (OpenRouter, Martian) picks one model and forwards your request. An agent framework (Swarm, AutoGen, LangGraph) makes you the coordinator. Fugu trains the coordinator itself, so a learned model decides delegation, communication, and synthesis. That trained-conductor approach, shipped as one endpoint, is its narrow real novelty.

Fugu is a bet that the next gains come from how models work together, not just from bigger weights. Whether the orchestration premium is worth it depends on your workload, and the fastest way to find out is to send real requests and watch the real numbers. Set up your first Fugu call in Apidog, compare it against the single models you already run, and let your own latency and cost data make the call.