Sakana Fugu: Learned LLM Orchestration

• Sakana Fugu is a learned orchestration system that dynamically composes specialized LLM agents to process queries via adaptive, query-specific scaffolds.
• It offers two variants: Fugu for low-latency single-step routing and Fugu-Ultra for multi-step, complex workflows with agent isolation and persistent memory.
• Training leverages supervised fine-tuning, evolutionary strategies, and reinforcement learning to optimize performance across diverse benchmarks and tasks.

Searching arXiv for the cited papers to ground the article. Sakana Fugu is a family of learned LLM orchestrators developed to combine the domain specializations of frontier LLM agents into a collectively intelligent system (Tang et al., 19 Jun 2026). In the technical report, Fugu models are described as LLMs trained to understand user queries and dynamically devise agentic scaffolds over a pool of specialized workers, including coding, math, search, and terminal/interpreter agents (Tang et al., 19 Jun 2026). The report distinguishes two released variants: Fugu, a latency-aware orchestrator that routes each input to a single best-matched worker model, and Fugu-Ultra, a performance-first orchestrator that constructs multi-step, multi-agent workflows tailored per query (Tang et al., 19 Jun 2026). The name “Fugu” has also been used for unrelated systems, including the Stanford “Fundamentals of Graph Understanding” benchmark for chart reasoning (Tartaglini et al., 2 Oct 2025) and the Sandia National Laboratories neuromorphic framework for composing spiking neural algorithms (Aimone et al., 2019); Sakana Fugu is a separate system focused on learned orchestration of specialized LLM agents (Tang et al., 19 Jun 2026).

1. Definition and scope

Sakana Fugu is presented as “Learned Orchestration of Specialized LLM Agents via Dynamic, Query-Adaptive Scaffolds” (Tang et al., 19 Jun 2026). Its central purpose is to expose multi-agent intelligence through a single model interface: a Fugu model receives a query, selects or coordinates worker models, decides what subtasks to assign, determines how workers communicate, manages tool use, and synthesizes outputs (Tang et al., 19 Jun 2026). The report frames orchestration itself as a scaling axis, motivated by the increasing specialization of frontier models across domains such as mathematics, software engineering, cybersecurity, factual recall, and tool use (Tang et al., 19 Jun 2026).

The two released variants embody distinct operating points. Fugu is intended for “everyday interactive workloads, multi-turn tasks, and deployment scenarios where latency and cost matter,” and it uses a fast decision-only orchestrator that outputs logits for worker selection and then delegates execution to the chosen frontier model (Tang et al., 19 Jun 2026). Fugu-Ultra is intended for “complex problems requiring composition of multiple specializations,” supports long-horizon function calling and memory, and generates multi-step workflows with chains, trees, parallel branches, and aggregation steps (Tang et al., 19 Jun 2026).

This design suggests that Sakana Fugu should be understood less as a monolithic assistant than as an orchestration layer over heterogeneous black-box models. A plausible implication is that its primary novelty lies in learned control over model composition, rather than in any single worker model’s intrinsic capability.

2. Orchestrator architectures and workflow semantics

The latency-aware Fugu orchestrator is described as a pre-trained LLM equipped with a lightweight selection head operating on hidden states (Tang et al., 19 Jun 2026). It performs decision-only routing: for a state $s$ such as a query or turn context, it computes a hidden state $h(s)$ at an early token position, maps it to agent logits $f_\theta(h(s))$, and dispatches immediately without autoregressive decoding (Tang et al., 19 Jun 2026). Its selection policy is given as

$$\pi_\theta(a \mid s) \propto \exp(f_\theta(h(s))_a).$$

The report further states that Fugu uses singular-value fine-tuning of selected backbone matrices, with orthogonal components fixed, to refine the representation for routing with minimal trainable parameters (Tang et al., 19 Jun 2026). Unlike Trinity, Fugu “does not assign explicit roles”; it selects a worker and invokes it, which narrows the coordination space and minimizes orchestration latency (Tang et al., 19 Jun 2026).

Fugu-Ultra is described as a workflow-generating orchestrator that “conducts an orchestra” by emitting an agentic workflow in natural language (Tang et al., 19 Jun 2026). Each step contains three fields: a subtask string, an agent id, and an access list specifying which prior step outputs enter the worker’s context (Tang et al., 19 Jun 2026). This workflow semantics supports “best-of-N, sequential chains, tree structures (parallel leaves, aggregator roots), repeated verification/critique cycles, test generation, debugging, multi-step tool use and terminal execution” (Tang et al., 19 Jun 2026). The report emphasizes intra-workflow agent isolation, which prevents orchestration collapse by ensuring that each agent’s function-calling context is isolated, and persistent shared memory across workflows, which maintains multi-turn context while preserving isolation except where the access list permits cross-agent observation (Tang et al., 19 Jun 2026).

The report provides high-level orchestration loops for both variants. For Fugu, the loop performs per-turn routing until completion or budget exhaustion; for Fugu-Ultra, the model emits a workflow $$W = [(subtask_1, id_1, access_1), \ldots, (subtask_S, id_S, access_S)]$$ with $S \leq 5$ in training, executes each step under orchestrator-defined context composition, and then synthesizes a final output (Tang et al., 19 Jun 2026). Ultra is also allowed to include the orchestrator itself as a worker in topologies if beneficial (Tang et al., 19 Jun 2026).

These mechanics formalize the paper’s notion of an agentic scaffold: a dynamic orchestration pattern generated per query, rather than a fixed prompt template or a static committee.

3. Training paradigm

The report describes a multi-stage training paradigm spanning supervised fine-tuning, evolutionary strategies, and reinforcement learning (Tang et al., 19 Jun 2026). For supervised fine-tuning of Fugu on single-step tasks, the training data consists of large-scale tasks spanning “coding, mathematics, reasoning, language understanding, and agentic scenarios with verifiable ground truth” (Tang et al., 19 Jun 2026). For each question $q_i$ and worker $M_j$, the system runs $n$ repetitions to obtain rewards $r_k^{M_j}$ and computes an average

$h(s)$0

These averages are converted into soft targets using a temperature-$h(s)$1 softmax,

$h(s)$2

and the objective is KL minimization,

$h(s)$3

The stated rationale is that soft targets preserve relative performance magnitudes and robustness when multiple workers are similarly capable, while enabling stable, generation-free training of the orchestrator (Tang et al., 19 Jun 2026).

For end-to-end tasks, Fugu is further optimized with sep-CMA-ES using multi-turn trajectories from real coding-assistant environments such as Claude Code, Codex, and OpenCode (Tang et al., 19 Jun 2026). A trajectory is written as $h(s)$4 with terminal reward $h(s)$5, and the objective is

$h(s)$6

Candidate policies are sampled as

$h(s)$7

and recombined via

$h(s)$8

The report states that this directly optimizes end-to-end outcomes with sparse or noisy signals and stably refines routing behavior from an SFT initialization (Tang et al., 19 Jun 2026).

For Fugu-Ultra, the training method is reinforcement learning for workflow design under the Conductor framework (Tang et al., 19 Jun 2026). Ultra emits workflows, and rewards are defined by two conditions: a format condition, where $h(s)$9 for malformed workflows, and a correctness condition, where $f_\theta(h(s))$0 if executing the workflow yields the correct final output and $f_\theta(h(s))$1 otherwise for a well-formatted but incorrect workflow (Tang et al., 19 Jun 2026). The objective is GRPO over grouped completions with advantage normalization,

$f_\theta(h(s))$2

with

$f_\theta(h(s))$3

and the report specifies $f_\theta(h(s))$4 in the reported training (Tang et al., 19 Jun 2026).

Taken together, these methods indicate that Sakana Fugu is trained not merely to answer queries, but to estimate comparative worker utility, optimize routing under sparse terminal rewards, and learn valid workflow syntax jointly with task performance.

4. System design, tools, and memory model

The report organizes the system around four core principles: robustness, adaptivity, verification, and modularity (Tang et al., 19 Jun 2026). Robustness is implemented through format validation, terminal rewards, budgets and turn caps, and workflow parsing checks (Tang et al., 19 Jun 2026). Adaptivity appears at multiple levels: per-query scaffold generation, per-turn routing in Fugu, and per-step topology adaptation in Ultra (Tang et al., 19 Jun 2026). Verification is supported by self-critique, aggregation, test generation, and environment feedback through terminal or harness execution (Tang et al., 19 Jun 2026). Modularity follows from treating frontier workers as black-box models in a configurable agent pool that can respect provider, privacy, and compliance constraints (Tang et al., 19 Jun 2026).

The tooling layer includes terminal and code execution through reference agent harnesses such as Mini-SWE-Agent and Terminus 2, along with coding environments including Claude Code and Codex (Tang et al., 19 Jun 2026). Web search, browsing, retrieval, file I/O, sandboxing, and caching are environment-managed, while the orchestrator tracks function-call origins and routes responses to the correct agent (Tang et al., 19 Jun 2026). For Fugu, tool interaction is delegated to the selected worker and harness (Tang et al., 19 Jun 2026).

The memory model differs between the two variants. In Ultra, intra-workflow agent function-calling trajectories are isolated, while persistent shared memory across workflows retains conversation background and avoids redundant tool calls (Tang et al., 19 Jun 2026). The orchestrator also tracks selected models, communication topology, and assigned subtasks across user-agent interactions so that function-call loops can be returned to the originating agent while preserving topology (Tang et al., 19 Jun 2026). In Fugu, the multi-turn state $f_\theta(h(s))$5 includes transcript, tool calls, and environment feedback, and routing is recomputed per state (Tang et al., 19 Jun 2026).

This architecture suggests that Sakana Fugu’s operational complexity lies not only in choosing strong workers, but in preserving correct communication structure under tool-mediated execution.

5. Empirical performance and benchmark profile

The technical report evaluates Sakana Fugu on a range of challenging tasks with the same frontier worker pool and compares it against those frontier models run directly with matched reasoning effort (Tang et al., 19 Jun 2026). The headline results position Fugu-Ultra as the strongest variant on several difficult benchmarks, while Fugu often provides a lower-latency operating point with competitive or superior performance to individual workers (Tang et al., 19 Jun 2026).

Benchmark	Fugu-Ultra	Fugu
SWE-Bench Pro	73.7	59.0
Terminal Bench 2.1	82.1	80.2
LiveCodeBench v6	93.2	92.9
LiveCodeBench Pro (Q2 2025, text-only, no tools)	90.8	87.8
GPQA-Diamond	95.5	95.5
Humanity’s Last Exam (multimodal samples, no tools)	50.0	47.2
CharXiv Reasoning	86.6	85.1
SciCode	58.7	60.1
$f_\theta(h(s))$6 Banking (pass@4)	20.6	21.7
Long Context Reasoning	73.3	74.7
MRCRv2 (8-needle retrieval up to 128k)	93.6	86.6

On SWE-Bench Pro, the report gives 73.7 for Fugu-Ultra, compared with 69.2 for Claude Opus 4.8, and notes that this is consistent with “generational-level gains” (Tang et al., 19 Jun 2026). On Terminal Bench 2.1, Fugu-Ultra scores 82.1 and Fugu 80.2, versus 78.2 for GPT-5.5; the report attributes Fugu’s strength here to alternation between GPT-5.5 and Opus-4.8 at critical debugging steps despite its single-selection design (Tang et al., 19 Jun 2026). On GPQA-Diamond, both Fugu variants score 95.5 and are described as setting new state of the art by dynamically drawing on GPT’s math and physics expertise and Gemini’s scientific recall (Tang et al., 19 Jun 2026). On Humanity’s Last Exam, Ultra reaches 50.0, ahead of Claude Opus 4.8 at 49.8, and the report states that Ultra uses tree-like debate and task-dependent aggregation such as choosing Gemini for trivia-heavy tasks (Tang et al., 19 Jun 2026).

The report also includes several expert-designed end-to-end evaluations. In AutoResearch, after 123 experiments on a single H100 GPU, Fugu-Ultra achieves mean best validation BPB of 0.9774 ± 0.0019 and best single seed 0.9748, compared with Model C at 0.9781 ± 0.0011, Model B at 0.9793 ± 0.0025, and Model A at 0.9822 ± 0.0017 (Tang et al., 19 Jun 2026). In Classical Japanese kana letter reading order, the mean normalized edit distance is 0.776 for Fugu-Ultra, 0.473 for Fugu, and 0.116 for the baseline heuristic (Tang et al., 19 Jun 2026). In one-shot Rubik’s cube solver synthesis, Fugu-Ultra solves 300/300 with mean 19.72 HTM and mean time 72.6 s, while Fugu also solves 300/300 with mean 21.15 HTM and mean time 1.9 s (Tang et al., 19 Jun 2026). The report states that Ultra achieves the shortest solutions, whereas Fugu trades approximately one extra move for approximately 35 times faster solving (Tang et al., 19 Jun 2026).

The benchmark profile supports a clear division of labor between the variants. Fugu is optimized for low-latency routing and can outperform single frontier models through per-turn alternation in interactive settings; Fugu-Ultra uses dynamic topologies, critique, and aggregation to maximize accuracy on difficult tasks (Tang et al., 19 Jun 2026).

6. Observed orchestration strategies, limitations, and interpretation

The report gives several qualitative descriptions of the orchestration strategies learned by the system. Debate and aggregation are common in Ultra, which can build tree topologies with adaptive aggregators such as Gemini for knowledge-intensive trivia and GPT for math-heavy synthesis (Tang et al., 19 Jun 2026). Build-and-debug patterns are also described: Ultra can deploy GPT as builder and Opus as debugger or verifier, while Fugu can alternate selections across turns so that GPT builds and Opus resolves merge conflicts or derives required logic (Tang et al., 19 Jun 2026). In another case, Ultra “brings in a specialist” by invoking GPT as a math specialist after Opus constructs a cybersecurity attack, thereby composing math, engineering, and security expertise (Tang et al., 19 Jun 2026).

The report also presents ablation-style findings. It states that ES on end-to-end tasks is more stable than supervised fine-tuning on those tasks and that SFT provides a strong initialization anchored by empirical worker performance (Tang et al., 19 Jun 2026). It contrasts router vs multi-agent workflows, arguing that Fugu’s per-turn router achieves low-latency gains while Ultra’s adaptive topologies unlock new state of the art (Tang et al., 19 Jun 2026). It further notes that verifier and critic use in Ultra improves correctness on multidisciplinary and knowledge-intensive tasks, and that tool access is crucial for coding-heavy evaluations such as SWE-Bench and Terminal Bench (Tang et al., 19 Jun 2026).

Several limitations are stated explicitly. Fugu single-selection may miss synergy when a composite approach would be superior, though this is precisely what Ultra is designed to address at the cost of latency (Tang et al., 19 Jun 2026). Sparse rewards and environment brittleness in end-to-end tasks can limit learning signal, and benchmark scores can depend on harness fidelity, with package-version differences affecting measurements such as SciCode (Tang et al., 19 Jun 2026). The report also identifies complexity in persistent memory design for multi-agent function calling, where subtle bugs can arise if isolation or access lists are mis-specified (Tang et al., 19 Jun 2026). More broadly, dependence on heterogeneous frontier providers can introduce latency and cost variability, mitigated through configurable pools, caching, and provider prioritization (Tang et al., 19 Jun 2026).

These limitations indicate that Sakana Fugu’s performance gains are inseparable from systems engineering concerns: workflow validity, harness fidelity, provider heterogeneity, and memory isolation are part of the method rather than peripheral implementation details.

7. Relation to other systems named “Fugu”

The term Fugu is overloaded across multiple research contexts. In “Diagnosing Bottlenecks in Data Visualization Understanding by Vision-LLMs”, FUGU is an acronym for Fundamentals of Graph Understanding, a Stanford benchmark and analysis suite for diagnosing why current vision-LLMs fail on basic chart and plot understanding (Tartaglini et al., 2 Oct 2025). That work uses controlled synthetic scatter plots, activation patching, and linear probes to analyze perceptual encoding, the vision-language handoff, and language-side reasoning in VLMs (Tartaglini et al., 2 Oct 2025). Its subject matter is data visualization understanding rather than LLM orchestration (Tartaglini et al., 2 Oct 2025).

In “Composing Neural Algorithms with Fugu”, Fugu is a high-level, hardware-independent framework from Sandia National Laboratories for composing spiking neural algorithms into executable neuromorphic applications (Aimone et al., 2019). It centers on abstractions such as bricks, scaffolds, and a platform-independent graph-based intermediate representation, and is intended to simplify neuromorphic programming rather than orchestrate frontier LLMs (Aimone et al., 2019).

Sakana Fugu is therefore distinct from both of these earlier uses. Its scope is learned orchestration over specialized LLM agents, using query-adaptive scaffolds, tool-mediated execution, and multi-agent workflow design (Tang et al., 19 Jun 2026). The shared naming does not imply shared architecture, authorship, or research program.