Today, Sakana AI launched Sakana Fugu. It is a multi-agent orchestration system that behaves like one model. You send a request to a single endpoint. Fugu decides how to handle it internally. It solves a task directly when that is enough. It also assembles and coordinates a team of expert models when needed. The complexity of a multi-agent system never reaches your code.
TL;DR
- Fugu delivers a multi-agent system behind one OpenAI-compatible API.
- Fugu Ultra leads most published coding and reasoning benchmarks.
- The orchestrator beats the individual models it coordinates.
- Opt-out and provider routing target compliance and single-vendor risk.
- Routing is proprietary, so per-query model selection stays hidden.
What is Sakana Fugu
Fugu is itself a language model. It is trained to call other LLMs in an agent pool. That pool includes instances of itself, called recursively. Fugu manages model selection, delegation, verification, and synthesis internally.
Instead of hard-coded roles or workflows, Fugu learns how to coordinate. It decides when to delegate and how agents should communicate. It then combines their work into one answer. From the outside, you call a single model. Inside, a coordinated system of experts does the work.
Sakana AI frames this as a hedge against single-vendor dependency. If one provider restricts access, Fugu routes around the disruption. The research team cites recent export controls on Anthropic’s Fable and Mythos models as motivation. Over time, newer models can be folded into the pool.
Fugu and Fugu Ultra: Two Models, One API
Fugu ships in two variants, both behind one OpenAI-compatible API:
- Fugu balances strong performance with low latency. It is a default for everyday coding, code review, and chatbots. It also fits tools like Codex. You can opt specific agents out of its pool. That helps teams meet data, privacy, and compliance requirements.
- Fugu Ultra is tuned for maximum answer quality on hard, multi-step problems. It coordinates a deeper pool of expert agents. Its pool is fixed, so opt-out is not available. The current model ID is
fugu-ultra-20260615.
The Research Behind the Orchestrator
Fugu builds on two ICLR 2026 papers Trinity and the Conductor on learned orchestration.
TRINITY uses a lightweight evolved coordinator across several turns. It assigns Thinker, Worker, or Verifier roles to delegate work adaptively. Conductor is trained with reinforcement learning. It discovers natural-language coordination strategies and focused prompts for diverse LLM pools.
Together, they show systems can learn to assemble and route agents per task. That replaces hand-designed workflows.
Interactive Explainer
‘;
Q(‘#agents’).innerHTML = ”;
Q(‘#answer’).innerHTML = ‘
Awaiting run…‘;
Q(‘#status’).textContent=”Ready.”;
}
Q(‘#resetBtn’).addEventListener(‘click’, function(){ if(!state.busy) reset(); });
function addStep(n, role, html){
var d = document.createElement(‘div’);
d.className=”step”;
var r = role ? ‘
‘+role+’‘ : ”;
d.innerHTML = ‘
‘+n+’
‘+r+html+’
‘;
Q(‘#log’).appendChild(d);
Q(‘#log’).scrollTop = Q(‘#log’).scrollHeight;
}
function agentBars(used){
var box = Q(‘#agents’); box.innerHTML=”;
used.forEach(function(u){
var line = document.createElement(‘div’); line.className=”agentline”;
line.innerHTML = ‘
‘+AGENTS[u.id].name+’‘+
‘
‘+
‘
‘+u.role+’‘;
box.appendChild(line);
var bar = line.querySelector(‘i’);
setTimeout(function(){ bar.style.width = (40+Math.random()*55)+’%’; }, 120);
});
}
function run(){
if(state.busy) return;
state.busy = true;
Q(‘#runBtn’).disabled = true; Q(‘#resetBtn’).disabled = true;
Q(‘#log’).innerHTML=”; Q(‘#agents’).innerHTML=”;
Q(‘#answer’).innerHTML=’
Orchestrating_‘;
Q(‘#status’).textContent=”Running\u2026″;
var task = Q(‘#task’).value;
var ultra = state.model===’ultra’;
var pool = activePool();
var workers = pool.filter(function(a){return a!==’self’;});
if(workers.length===0) workers=[‘self’];
var T = TASKS[task];
// choose mode: ultra or research/repro/reason => multi-agent team
var team = ultra || task===’research’ || task===’repro’ || task===’reason’;
var steps = [];
steps.push({d:300, role:null, html:’Request received at a
single endpoint. No client-side multi-agent code.’});
steps.push({d:600, role:null, html:’Decide: ‘+(team?’this task is multi-step —
assemble a team.’:’one strong model is enough —
solve directly, then verify.’)});
var used = [];
if(team){
var thinker = workers[0];
var worker = workers[1] || workers[0];
var verifier = workers[2] || workers[0];
steps.push({d:700, role:’Thinker’, html:’
‘+AGENTS[thinker].name+’ drafts a plan and decomposes the task.’});
steps.push({d:700, role:’Worker’, html:’
‘+AGENTS[worker].name+’ executes sub-tasks and produces candidate output.’});
if(pool.indexOf(‘self’)>-1){
steps.push({d:600, role:’Worker’, html:’Fugu issues a
recursive self-call on a hard sub-problem.’});
}
steps.push({d:700, role:’Verifier’, html:’
‘+AGENTS[verifier].name+’ checks the result and flags gaps to revise.’});
used = [{id:thinker,role:’Thinker’},{id:worker,role:’Worker’},{id:verifier,role:’Verifier’}];
if(pool.indexOf(‘self’)>-1) used.push({id:’self’,role:’Worker’});
} else {
var solo = workers[0];
steps.push({d:700, role:’Worker’, html:’
‘+AGENTS[solo].name+’ handles the task in one pass.’});
steps.push({d:700, role:’Verifier’, html:’
‘+AGENTS[(workers[1]||solo)].name+’ verifies the diff before returning.’});
used = [{id:solo,role:’Worker’},{id:(workers[1]||solo),role:’Verifier’}];
}
if(state.restricted){
steps.splice(2,0,{d:650, role:null, html:’
‘+AGENTS[state.restricted].name+’ is restricted. Routing around it — no integration change.’});
}
steps.push({d:700, role:null, html:’Synthesize the agents’ work into
one reliable answer.’});
// dedupe used by id keeping first role
var seen={}; used = used.filter(function(u){ if(seen[u.id])return false; seen[u.id]=1; return true; });
var i=0, n=0;
function next(){
if(i>=steps.length){ finish(used, T); return; }
var s = steps[i++]; n++;
setTimeout(function(){
addStep(n, s.role, s.html);
if(n===Math.min(4,steps.length-1)) agentBars(used);
next();
}, s.d);
}
next();
}
function finish(used, T){
setTimeout(function(){
QA(‘#agents .bar i’).forEach(function(b){ b.style.width=”100%”; });
var mhtml = T.metrics.map(function(m){
return ‘
‘+m[0]+’‘+m[1]+’
‘;
}).join(”);
Q(‘#answer’).innerHTML = ‘
‘+T.answer+’
‘+mhtml;
Q(‘#status’).textContent=”Done. Routing details are proprietary and not exposed in production.”;
state.busy=false; Q(‘#runBtn’).disabled=false; Q(‘#resetBtn’).disabled=false;
sz();
}, 500);
}
Q(‘#runBtn’).addEventListener(‘click’, run);
Q(‘#task’).addEventListener(‘change’, function(){ if(!state.busy) reset(); });
renderModel();
// —- auto-resize for WordPress iframe embed —-
function sz(){
var h = root.offsetHeight + 40;
if(window.parent && window.parent!==window){
window.parent.postMessage({type:’fugu-sim-height’, height:h}, ‘*’);
}
}
window.addEventListener(‘load’, sz);
window.addEventListener(‘resize’, sz);
setTimeout(sz, 300);
// observe DOM changes that affect height
if(window.MutationObserver){
new MutationObserver(sz).observe(root, {childList:true, subtree:true, attributes:true});
}
})();