You use the Sakana Fugu API by creating a key at console.sakana.ai, copying the base URL shown in your console, and pointing your existing OpenAI client at that endpoint. No SDK migration is needed. Fugu ships as a single OpenAI-compatible API, so the same openai Python and JavaScript libraries you already use will talk to it once you swap the base URL and key. Behind that one endpoint, Fugu is a multi-agent orchestration system: per the Sakana release page, it decides whether to answer directly or assemble a team of models, and your code never sees that decision. If you have wired up other gateways before, like in our guide to the Claude Fable 5 API, this setup will feel familiar.
This guide walks through getting a key, configuring the client in two languages, picking the model field, and handling streaming, so you can send your first chat completion in a few minutes.
What the Sakana Fugu API actually is
Fugu is not a single model in the usual sense. Sakana describes it as a trained language model specialized in delegation, agent communication, and work synthesis. The release headline is “One Model to Command Them All.” When you send a request, a trained conductor reads your prompt and either responds on its own or dynamically coordinates several LLMs, including recursive instances of itself, then synthesizes the result into one answer.
From your code’s point of view, none of that matters. You call one OpenAI-compatible endpoint and get back a normal chat completion. The orchestration graph stays server-side. You never assemble agents, route between providers, or manage a team. That is the whole pitch: the complexity lives behind the API, not in your client.
There are two variants. “Fugu” is the balanced, low-latency option built for everyday work, coding, code review, chatbots, and interactive services. “Fugu Ultra” targets maximum answer quality for AI research, paper reproduction, cybersecurity analysis, and literature or patent investigation. During the beta and across much of the early press, the smaller variant was called “Fugu Mini.” Lead with the current names, Fugu and Fugu Ultra, and treat “Mini” as the old beta label.
The research lineage is real and public. Two ICLR 2026 papers underpin the approach: Trinity, a sub-20K-parameter coordinator optimized by derivative-free evolution with Thinker, Worker, and Verifier roles, and Conductor, a 7B model trained with reinforcement learning that learns the communication structure between agents. They use different methods and sizes, so do not conflate them. The shipped product’s exact parameter count is not published.
Step 1: Create a Fugu API key at console.sakana.ai
Head to console.sakana.ai. Access goes through a login wall, so you sign in with Google or email before you reach the dashboard. The beta ran with roughly 500 users starting in late April 2026. Whether general-availability self-serve sign-up is fully open or still gated can change, so check the current state when you land on the page. A reported EU/EEA availability restriction has circulated as well; verify your region is supported before you build against the API.
Once you are in, look for the API keys section. Generate a key and store it somewhere safe, like an environment variable or a secrets manager. Treat it the way you would any other provider key: never commit it to source control, and rotate it if it leaks.
While you are in the console, find and copy your account base URL. This is the single most important step, and it is the one detail you cannot guess. The base URL for the Fugu endpoint is not published on any public Sakana page as of this writing. Copy the exact value the console shows you. Do not assume it follows some pattern from another provider, and do not paste a host you saw in a forum post. The console is the source of truth.
Step 2: Point your existing OpenAI client at Fugu
Because Fugu is OpenAI-compatible, you keep your current SDK. You only change two things: the base_url and the api_key. Everything else in your request stays the same shape as a standard OpenAI chat completion.
In the snippets below, <YOUR_FUGU_BASE_URL_FROM_CONSOLE> is a placeholder. Copy the real base URL from your console; do not guess it. The same goes for the model string, which we cover in the next section.
Python
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, do not guess
)
response = client.chat.completions.create(
model="fugu", # confirm the exact model string in your console
messages=[
{"role": "system", "content": "You are a helpful engineering assistant."},
{"role": "user", "content": "Refactor this function to remove the nested loop."},
],
)
print(response.choices[0].message.content)
JavaScript
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.FUGU_API_KEY,
baseURL: "<YOUR_FUGU_BASE_URL_FROM_CONSOLE>", // copy from console.sakana.ai, do not guess
});
const response = await client.chat.completions.create({
model: "fugu", // confirm the exact model string in your console
messages: [
{ role: "system", content: "You are a helpful engineering assistant." },
{ role: "user", content: "Refactor this function to remove the nested loop." },
],
});
console.log(response.choices[0].message.content);
That is the entire migration. If you have routed an OpenAI client through a third-party gateway before, the pattern is identical to setups like Claude Code with OpenRouter: same client, new base URL, new key. The difference is what happens server-side, which we get to below.
Step 3: Choose the model field
The model field selects the variant. Reported strings are fugu for the balanced model and fugu-ultra for the maximum-quality model. Some sources have also reported a dated identifier, something along the lines of fugu-ultra-20260615. Identifiers like that can change between releases, so confirm the exact string your console lists rather than copying a dated id from an article. That is also why this guide keeps dated ids out of the headings: they go stale, and your console is authoritative.
A practical rule of thumb: start with fugu for interactive workloads, coding, and chat, where latency matters. Move to fugu-ultra when answer quality outweighs speed, for example deep research, paper reproduction, or a security review. Both variants live behind the same endpoint, so switching is a one-line change to the model value.
Here is the variant choice in code:
# Balanced, low latency
fast = client.chat.completions.create(
model="fugu",
messages=[{"role": "user", "content": "Summarize this changelog in three bullets."}],
)
# Maximum answer quality
deep = client.chat.completions.create(
model="fugu-ultra", # confirm the exact string in your console
messages=[{"role": "user", "content": "Reproduce the main result of this paper and flag any gaps."}],
)
Step 4: Stream responses
Streaming works exactly as it does with OpenAI. Set stream=True (or stream: true) and iterate over the chunks. This is useful for chat UIs and long answers where you want tokens to appear as they arrive.
Python streaming
stream = client.chat.completions.create(
model="fugu",
messages=[{"role": "user", "content": "Walk me through setting up a CI pipeline."}],
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="", flush=True)
JavaScript streaming
const stream = await client.chat.completions.create({
model: "fugu",
messages: [{ role: "user", content: "Walk me through setting up a CI pipeline." }],
stream: true,
});
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta?.content;
if (delta) process.stdout.write(delta);
}
One thing to understand about streaming with Fugu: even when the response streams token by token, the orchestration still happened server-side first. If the conductor assembled a team for your request, that coordination resolved before or during generation, and your stream only carries the synthesized output. You will not see intermediate agent chatter or a routing graph in the stream. You get clean text, the same as a single-model API.
What happens behind one request
This is the part that makes Fugu different from a plain model API, and it is worth understanding even though your code stays simple. When your request arrives, the conductor reads it and makes a call: answer directly, or build a team. If it builds a team, it can pull in multiple LLMs, recursively including more instances of Fugu, then merge their work into one reply.
A few mechanics from the release page are worth knowing if you have governance requirements. Agents in the pool are swappable. Teams can opt specific agents out, which helps when a data or compliance rule means a given provider should not touch certain workloads. Fugu can also dynamically route around provider restrictions. That makes the orchestration layer a compliance lever, not just a quality one.
Here is the honest framing, because it matters for how you read any benchmark. Fugu is an orchestrator that calls other vendors’ frontier models, recursively including itself. So when Sakana reports that 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, attributed to Sakana, from a model-of-models, not a single-model win. Sakana also reports that Fugu “consistently outperforms” Gemini 3.1 Pro, Opus 4.8, and GPT 5.5 on specific applications like AutoResearch, one-shot chess, and financial time-series prediction. A result like “beats Opus 4.8” may come from Fugu calling Opus and synthesizing its output. That is a real capability, and it is a different thing from a standalone model topping a leaderboard. If you want to dig into the single Anthropic models Fugu is measured against, our Claude Fable 5 API guide covers Fable 5 directly. For more on the model lineage and the orchestration story, see what is Sakana Fugu.
A note on access, pricing, and alternatives
Pricing structure is confirmed on the release page: Sakana offers subscription tiers for everyday use and a pay-as-you-go plan for heavier and enterprise workloads. The specific dollar figures circulating for tiers, promos, and per-token rates come from secondary, JavaScript-rendered sources, not the release page itself. Because those numbers shift and were not on the official page, this guide does not quote them. Check the live pricing in your console as of today, 2026-06-22, before you commit to a plan.
If you are evaluating Fugu against routing gateways, keep the categories straight. Routers like OpenRouter and Martian pick one model per request. Fugu instead runs a learned, adaptive topology that can use several models and itself. If you are comparing gateways for your stack, our roundup of the best OpenRouter alternatives is a useful starting point, since it frames the trade-offs between single-model routing and orchestration.
How this fits your Apidog workflow
Because Fugu speaks the OpenAI chat-completions format, you can test it the same way you test any HTTP API. Drop the base URL from your console into a new request in Apidog, add your key as a bearer token, set the JSON body with your model and messages, and send. You will see the raw response, including token usage and the synthesized message, without writing a line of client code. That makes it easy to confirm your base URL is correct, sanity-check the model string, and watch how streaming chunks arrive before you wire Fugu into an application.
Apidog also lets you save the request, parameterize the key across environments, and share a working example with your team. For a focused walkthrough, see our guide on how to test the Sakana Fugu API with Apidog. When you are ready to build, Download Apidog and start from a verified request instead of guessing at the contract.
Frequently Asked Questions
Do I need a new SDK to call the Sakana Fugu API?
No. Fugu exposes one OpenAI-compatible endpoint, so you keep your existing openai Python or JavaScript client. Change the base_url to the value from your console and set your Fugu API key. The request and response shapes match standard OpenAI chat completions.
Where do I find the Fugu base URL?
Copy it from your dashboard at console.sakana.ai after you log in with Google or email. The base URL is not published on any public Sakana page, so do not guess it or reuse a host from another provider. The console value is the only reliable source.
What is the difference between Fugu and Fugu Ultra?
Fugu is the balanced, low-latency variant for everyday work, coding, code review, and chat. Fugu Ultra targets maximum answer quality for research, paper reproduction, and security analysis. Both run behind the same endpoint, so you switch by changing the model field. The smaller variant was called “Fugu Mini” during the beta.
Does Fugu beat single models like Fable 5?
Treat that carefully. Sakana frames Fugu Ultra as standing shoulder-to-shoulder with Fable 5 and Mythos Preview, which is a parity claim, not a “beats” claim. Fugu is an orchestrator that can call other vendors’ frontier models, so its numbers reflect a model-of-models rather than a single-model win. See our Claude Fable 5 API guide for the single-model comparison point.
How much does the Sakana Fugu API cost?
The release page confirms subscription tiers plus a pay-as-you-go plan, but the specific dollar amounts circulating come from secondary sources and shift over time. Check the live pricing in your console as of 2026-06-22 before you subscribe. This guide does not quote unverified numbers.
How do I test Fugu before writing code?
Send a request from an API client like Apidog: paste your console base URL, add your key, set the model and messages, and inspect the response. It confirms your setup works before you integrate. The test Sakana Fugu API with Apidog guide shows the full flow.
Fugu collapses a multi-agent system into one OpenAI-compatible call, which means the hardest part of getting started is just copying the right base URL from your console. Once that is in place, your existing client does the rest, and Apidog gives you a fast way to verify the contract before you ship. Download Apidog and send your first Fugu request from a clean, repeatable request.
