To test the Sakana Fugu API in Apidog, create a new HTTP request pointed at Fugu’s OpenAI-compatible /chat/completions path, add an Authorization: Bearer header with your key, and send a payload that names either the fugu or fugu-ultra model. Because Fugu ships one OpenAI-compatible endpoint, any tool that speaks the OpenAI chat format works without an SDK swap, and Apidog gives you streaming inspection, saved request variants, and response diffing in one window. This guide walks the full loop: build the request, watch SSE deltas, read the usage object, and compare latency between the balanced tier and the slower Ultra tier so you can see the orchestration hop cost in real responses.
If you want the code-first integration path instead of the test-and-observe path, the companion guide to using the Sakana Fugu API covers SDK wiring. This article stays inside Apidog.
What you are actually testing with Fugu
Fugu is not a plain chat model. Per Sakana, it is a multi-agent orchestration system presented as a single foundation model behind one API. A trained language model specializes in delegation, agent communication, and work synthesis, then dynamically coordinates multiple LLMs, including recursive instances of itself. The release headline is “One Model to Command Them All.” For the orchestration backstory, see the explainer on what Sakana Fugu is.
That design matters for testing. When you send one request, Fugu decides whether to answer directly or assemble a team behind the scenes. You see one response, but the work underneath may have crossed several models. So the things worth measuring in Apidog are different from a normal model test: you watch latency as a proxy for whether Fugu ran a single pass or an orchestration hop, and you read the usage object to see token cost on the parent call.
Two variants share that single endpoint:
- Fugu (the balanced, low-latency variant) targets everyday work: coding, code review, chatbots, and interactive services.
- Fugu Ultra targets maximum answer quality: AI research, paper reproduction, cybersecurity analysis, and literature or patent investigation.
The beta and much of the early press called the small variant “Fugu Mini.” The release page leads with “Fugu” and “Fugu Ultra,” so use those names; “Mini” is the old beta label.
Get the base URL and key before you start
Fugu lives behind a login wall. You sign in at console.sakana.ai with Google or email, and the console is where you copy your API key and base URL.
One important note for 2026-06-22: the base URL is not published on any public Sakana page. Do not guess it. Copy the real host from the console and keep it as a variable. Everywhere in this guide you see <YOUR_FUGU_BASE_URL_FROM_CONSOLE>, replace it with the value the console shows you. Access also moved from a roughly 500-user beta toward general availability; whether self-serve sign-up is fully open and whether there is an EU/EEA restriction are both worth checking live in the console.
Set up the Fugu request in Apidog
Download Apidog if you do not have it, then create a new project and a new HTTP request.
Use environment variables for the key and host
Do not paste secrets into the URL bar. Apidog environments let you store the base URL and key once and reference them across every request. Create an environment (call it Fugu Prod) and add two variables:
fugu_base_urlset to your<YOUR_FUGU_BASE_URL_FROM_CONSOLE>value.fugu_keyset to your console API key.
Now your request URL becomes {{fugu_base_url}}/chat/completions and your header value becomes Bearer {{fugu_key}}. Switching between a staging key and a production key is one dropdown change, not a find-and-replace across requests. If you have wired other OpenAI-compatible providers through a gateway before, this mirrors the pattern in the Claude Code with OpenRouter walkthrough, where one base URL and one bearer token redirect an OpenAI client at a new backend.
Build the request body
Set the method to POST, the URL to {{fugu_base_url}}/chat/completions, and add these headers:
Authorization: Bearer {{fugu_key}}
Content-Type: application/json
Then drop a standard OpenAI chat payload into the JSON body:
{
"model": "fugu",
"messages": [
{ "role": "system", "content": "You are a concise API testing assistant." },
{ "role": "user", "content": "Summarize what an SSE delta is in two sentences." }
],
"stream": false
}
The shape matches the OpenAI chat completions reference exactly, which is the point of an OpenAI-compatible endpoint. The model id strings reported at launch are fugu and fugu-ultra (and possibly a dated form like fugu-ultra-20260615). Confirm the exact id in the console rather than hardcoding a dated string, since dated ids rotate.
Send it. You should get a normal chat completion object back, with a choices array and a usage block. Save this request in Apidog as “Fugu balanced.”
Send to the Ultra variant and save both
Duplicate the saved request, change one field, and you have your second test case:
{
"model": "fugu-ultra",
"messages": [
{ "role": "user", "content": "Reproduce the core result of the Trinity coordinator paper in plain language and note one limitation." }
],
"stream": false
}
Save this as “Fugu Ultra.” Now you have two saved requests hitting one endpoint, separated only by the model field. This is the setup that makes the rest of the test meaningful. You send the same prompt to both, then diff the responses and compare timing. Apidog keeps a response history per request, so you can re-run each one and watch how the answers and latency move. For a broader pattern on chaining and comparing API calls, the API test orchestration guide covers how to sequence and assert across multiple requests.
Inspect SSE streaming deltas
Streaming is where Fugu’s behavior gets interesting, because a long orchestration hop still streams tokens as they finalize. Flip stream to true:
{
"model": "fugu-ultra",
"messages": [
{ "role": "user", "content": "Walk through a one-shot chess opening analysis, step by step." }
],
"stream": true
}
With streaming on, the response is text/event-stream and arrives as a series of data: chunks. Apidog renders the SSE stream live, so you watch deltas land instead of staring at a spinner. Each chunk looks like this:
data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"The"},"finish_reason":null}]}
data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" Sicilian"},"finish_reason":null}]}
data: [DONE]
The delta object carries the incremental token content. The first chunk usually carries the role, then subsequent chunks carry content fragments, and the stream ends with finish_reason set and a final data: [DONE] line. Watch the gap before the first delta on Ultra. A long pause before tokens start, then a steady stream, is a useful signal that Fugu assembled a team before answering. The balanced variant tends to start streaming sooner because it more often answers directly.
Read the usage object and compare cost
Once a non-streaming call returns, open the usage block in the response:
{
"usage": {
"prompt_tokens": 38,
"completion_tokens": 412,
"total_tokens": 450
}
}
Token counts on the parent call are what Apidog shows you directly. Keep one honesty point in view: Fugu is an orchestrator that calls other vendors’ frontier models, recursively including itself. The usage you read is the accounting on your request to Fugu, not a window into every downstream model it may have called. Pricing structure, per Sakana, is subscription tiers for everyday use plus a pay-as-you-go plan for heavier and enterprise workloads.
For a grounded comparison anchor, Anthropic’s published rates (2026-06-09) put Fable 5 and Mythos 5 at $10 per 1M input and $50 per 1M output. The companion Claude Fable 5 API guide covers that endpoint if you want a single-model baseline to test alongside Fugu in the same Apidog project.
Measure the orchestration hop cost in latency
This is the test that justifies running both variants. Send the same prompt to “Fugu balanced” and “Fugu Ultra,” then read the response time Apidog reports at the bottom of each result.
You will usually see the balanced variant return faster. Per Sakana, the balanced “Fugu” targets low latency and interactive services, while Ultra targets maximum quality for research-grade work. The latency delta is your visible read on the orchestration hop: when Ultra spends longer, that extra time is Fugu coordinating a team rather than answering in one pass. Apidog’s per-request timing and saved history let you run each variant several times and eyeball whether the gap is stable or prompt-dependent.
To stress the difference, pick a task from Sakana’s own application list where it claims strong results: AutoResearch, mechanical design, financial time-series prediction, or one-shot chess. Per Sakana, Fugu consistently outperforms Gemini 3.1 Pro, Opus 4.8, and GPT 5.5 on those specific applications. Read that claim carefully. Fugu may reach those results by calling those very models and synthesizing their output, so a “beats Opus 4.8” outcome can be a model-of-models result, not a single-model win. Sakana also positions Fugu Ultra as standing shoulder-to-shoulder with Fable 5 and the older Mythos Preview across engineering and reasoning benchmarks, which is a parity claim, not a “beats” claim. Test it yourself and judge by your own prompts.
Agent routing and governance you can probe
Fugu’s release page describes mechanics worth testing directly. Agents in the pool are swappable. Teams can opt specific agents out for data or compliance reasons. Fugu also dynamically routes around provider restrictions. If your console exposes agent-pool controls, you can change which models are eligible and re-run your saved Apidog requests to watch how routing and answers shift.
The research lineage is real and citable. Two ICLR 2026 papers sit behind this approach: Trinity, “An Evolved LLM Coordinator”, a sub-20K-parameter coordinator optimized by derivative-free evolution with Thinker, Worker, and Verifier roles, and Conductor, “Learning to Orchestrate Agents in Natural Language”, a 7B model trained with reinforcement learning that learns its own communication structure and claims to beat Mixture-of-Agents at lower cost. They use different methods and sizes, so do not conflate them, and note that mapping any specific param count onto the shipped product is third-party inference rather than an official figure.
How this fits your Apidog workflow
The point of testing Fugu in Apidog instead of a one-off curl is repeatability. You save both variant requests, keep your key and host in an environment, replay them against new prompts, diff the responses side by side, and read latency and usage without leaving the tool. When Fugu rotates a model id or you switch from a staging key to production, you change one environment variable and every saved request follows. That is the test-and-observe loop: build once, then watch how an orchestration system behaves as you push different prompts through it.
Sakana takes its name from the Japanese word for fish, and the school-of-fish branding fits an orchestrator that coordinates many models into one answer. Fugu, the pufferfish, is a delicacy that is safe only when a skilled chef prepares it. The careful-preparation metaphor is a fair way to think about routing work across agents, as long as you remember it is color, not a benchmark.
Point your OpenAI-compatible requests at Fugu, save your variants, and let Apidog show you what the orchestrator does under load. Download Apidog to set up your first Fugu environment, and start by sending the same prompt to both variants to see the orchestration hop for yourself.
Frequently Asked Questions
What base URL do I use to test Fugu in Apidog?
Copy the base URL from console.sakana.ai after you sign in. Sakana has not published the host on any public page as of 2026-06-22, so do not guess it. Store it as an Apidog environment variable and reference it as {{fugu_base_url}}/chat/completions.
Do I need a special SDK to call Fugu?
No. Fugu ships one OpenAI-compatible endpoint, so any OpenAI client or any tool that speaks the OpenAI chat format works with only a base URL and key change. The same redirect pattern appears in the Claude Code with OpenRouter guide.
How do I test streaming responses from Fugu?
Set "stream": true in the request body. The response arrives as text/event-stream with data: chunks that carry incremental delta content, ending in data: [DONE]. Apidog renders the SSE stream live so you can watch deltas land in real time.
What is the difference between Fugu and Fugu Ultra?
Fugu is the balanced, low-latency variant for everyday coding, review, and chatbots. Fugu Ultra targets maximum answer quality for research, paper reproduction, and security analysis. Both run through the same endpoint, separated only by the model field, which is what makes them easy to save and diff in Apidog.
Why is Fugu Ultra slower than the balanced variant?
The extra latency is the orchestration hop. Per Sakana, Fugu can answer directly or assemble a team of models, and Ultra leans toward deeper coordination for quality. The slower response time you read in Apidog is your visible signal that Fugu coordinated multiple models rather than answering in one pass.
Are Fugu’s benchmark wins single-model results?
No. Fugu is an orchestrator that calls other vendors’ frontier models, recursively including itself. So a result that “beats Opus 4.8,” per Sakana, may come from calling Opus and synthesizing its output. Treat Fugu’s numbers as model-of-models results, not single-model wins, and verify against your own prompts.
