---
title: 'FUGU: Multi-Domain Composition Frameworks'
url: https://www.emergentmind.com/topics/fugu
type: topic
---

# FUGU: Multi-Domain Composition Frameworks

Searching arXiv for the relevant "FUGU" usages and papers to ground the article.
FUGU is a label used in several distinct arXiv research contexts rather than a single unified system. In recent literature, it denotes a high-level, hardware-independent framework for composing spiking neural algorithms in neuromorphic computing [1905.12130]; a controlled task suite, “Fundamentals of Graph Understanding,” for diagnosing bottlenecks in data-visualization understanding by vision-language models [2510.21740]; Sakana AI’s family of learned orchestrator models for dynamic multi-agent scaffolds [2606.21228]; and, in high-performance computing search usage, a colloquial rendering of Fugaku in work on a 102 PFLOPS lattice QCD quark solver [2109.10687]. The shared name therefore spans neuromorphic programming, mechanistic evaluation of VLMs, multi-agent orchestration, and exascale-class scientific computing.

## 1. Terminological scope

In the cited literature, “FUGU” is not a single acronym with a stable expansion across fields. It appears as a proper name or search label attached to separate systems with different technical objectives.

| Usage | Domain | Core characterization |
|---|---|---|
| Fugu [1905.12130] | Neuromorphic computing | High-level, hardware-independent framework for composing spiking neural algorithms into larger applications |
| FUGU (“Fundamentals of Graph Understanding”) [2510.21740] | Vision-language evaluation | Controlled scatter-plot task suite and dataset for diagnosing where VLM chart understanding fails |
| Sakana Fugu [2606.21228] | Multi-agent LLM systems | Learned orchestrator models that dynamically devise agentic scaffolds over frontier LLM workers |
| Fugaku, colloquially searched as “FUGU” [2109.10687] | High-performance computing | Arm-based, SVE-enabled flagship supercomputer used for a 102 PFLOPS lattice QCD quark solver benchmark |

A recurrent pattern across these usages is the elevation of composition to a first-class concern. In the neuromorphic framework, composition links reusable spiking kernels; in the VLM benchmark, task decomposition isolates chart-understanding subskills; in Sakana Fugu, orchestration composes specialists; and in the Fugaku solver, algorithmic, architectural, and communication optimizations are combined to achieve extreme-scale throughput. This suggests that the name’s research salience lies less in a common acronym than in a recurring design orientation toward structured system integration.

## 2. Fugu as a neuromorphic programming framework

Fugu in neuromorphic computing was introduced as a response to the difficulty of programming, configuring, and deploying neuromorphic systems despite their promise of energy-efficient, event-driven computation inspired by the brain. Its stated purpose is to provide a higher-level abstraction that allows developers to link scalable spiking neural algorithms from multiple sources without requiring intricate low-level knowledge of spiking neural dynamics or of each target platform’s idiosyncrasies [1905.12130].

The framework models applications as computation graphs called *scaffolds*. A scaffold contains *bricks*, which encapsulate individual spiking neural algorithms, and edges that define the flow of spike-event information among bricks. Applications are written in conventional languages such as Python or C++, and Fugu raises the abstraction from a directed graph of neurons and synapses to what the paper describes as “networks of networks.” The programming model explicitly separates three roles: general application developers, spiking neural algorithm designers, and hardware experts. This separation is central to its hardware-independence claim, because reusable algorithmic bricks do not commit to a specific neuromorphic substrate.

Its intermediate representation is implemented in Python using NetworkX. The IR comprises a library of bricks, algorithms to link bricks, and the combined application graph. Bricks are scripts that generate local circuit graphs at build time rather than fixed circuits. To support composition, Fugu associates metadata with each brick: $N_{\text{in}}$, $T_{\text{in}}$, $N_{\text{out}}$, $T_{\text{out}}$, and $D$, where $D$ is the circuit depth in global timesteps from input at $t=1$ to output. It also standardizes a local index on each output neuron so that downstream bricks can align inputs with outputs across varying shapes and dimensionalities. This indexing mechanism is one of the framework’s key composition devices, because it decouples inter-brick routing from the internal design of any one brick.

Composition is lazy. As the scaffold is traversed, a brick instantiates its local graph only when its parameters are fully determined, often by upstream output shape. Two main composition problems are then handled automatically: size alignment and timing alignment. Downstream bricks can be resized to match upstream $N_{\text{out}}$, and branches with different circuit depths can be synchronized by adding delay bricks such as repeater neurons. When depth is variable or input-dependent, buffers and control nodes are inserted so that staged spikes are flushed only after all branches complete. The framework also exposes explicit time–space trade-offs: if a branch has free time, a brick can be re-instantiated in a more time-costly but space-efficient form to reduce neuron footprint.

The default formal substrate is a leaky integrate-and-fire model with threshold $V_{\text{thresh}}$, time constants $\tau_i$, reset voltage $V_{\text{reset}}$, point synapses with weights $w_{i,j}$, and stochastic firing via a Bernoulli variable $P$ at rate $p$, with $p=1$ for deterministic neurons. Fugu can carry attributes for learning rules, structural plasticity, multi-compartment neurons, and conductance-based models, but these are not guaranteed to map across hardware. The key interface requirement is narrower: components must emit discrete spike events at outputs and consume spike events at inputs.

Hardware independence is achieved by keeping platform-specific concerns outside the IR. The IR is a single NetworkX graph whose nodes are neurons with dynamics parameters and whose edges are synapses with weights as attributes; it can then be passed either to hardware-specific “neuromorphic hardware compilers” or to Fugu’s conservative reference simulator. That simulator intentionally omits learning and complex neuron types and does not predict runtime, energy, or throughput. The evaluation is correspondingly illustrative rather than quantitative: the paper uses case studies to demonstrate algorithmic compositionality and functional correctness under the basic LIF assumptions.

The brick library spans multiple domains. Examples include a constant-time 1-D max cross-correlation brick, logic bricks for AND and OR based on spike timing and thresholds, shortest-path computation via spike timing in graph-analytic circuits, a sketch of pure-strategy Nash equilibria for the prisoner’s dilemma, and a scientific-computing pipeline in which a random-walk diffusion solver is decomposed into a binary random number generator, a binary-to-unary conversion, and a grid position tracker. Relative to environments such as PyNN, Nengo, and N2A, the framework’s stated emphasis is not a fixed neural-computation perspective but the hardware-independent composition of heterogeneous spiking neural algorithms.

## 3. FUGU as a diagnostic benchmark for visualization understanding

“FUGU” in the VLM literature expands to *Fundamentals of Graph Understanding*. It is a controlled task suite and dataset designed to pinpoint where vision-language models fail in data visualization understanding: in the vision encoder, in the vision–language handoff, or in the language module [2510.21740]. Its design explicitly differs from benchmarks such as FigureQA, DVQA, PlotQA, ChartQA, and ChartQA-Pro, which mix chart types, naturalistic layouts, and higher-level reasoning demands. FUGU instead isolates foundational visuospatial and mathematical subskills using simple synthetic scatter plots.

The dataset contains 3,968 question–image pairs across five tasks and 768 synthetic scatter plots. The plots have a white background and black axes; axes are labeled with integer ticks 0 through 8 on both axes; the plots are described as an 8×8 grid; points occupy non-overlapping natural-number positions; and each point is identified by a unique shape–color combination drawn from four shapes and four colors. Sample sizes are $n \in \{1,2,4,8,16\}$. Count and Position are paired with all 768 plots, Distance with plots having $n \ge 2$, and Extremum and Mean with plots having $n \ge 4$.

The core tasks are defined so that both the perceptual readout and the numerical target are controlled. *Count* outputs a single integer. *Position* reports the exact $(x,y)$ coordinates of a specified point and is evaluated by exact match after rounding to the nearest integer. *Distance* computes
$$
d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}
$$
with correctness determined after rounding to the nearest integer. *Extremum* identifies the point with the minimum or maximum value on one axis, returning a shape–color identity; flexible matching accepts either both attributes or a single uniquely identifying attribute. *Mean* computes the centroid using
$$
\mu_x = \frac{1}{n}\sum_{i=1}^n x_i,\qquad
\mu_y = \frac{1}{n}\sum_{i=1}^n y_i
$$
and returns the rounded coordinate pair. A second set of ensemble tasks extends the benchmark to denser scatter plots with 16, 32, 64, or 128 points and probes correlation thresholding, cluster membership, function-family identification, and outlier detection. For correlation, the canonical statistic is the Pearson coefficient
$$
r(x,y)=\frac{\sum (x_i-\mu_x)(y_i-\mu_y)}
{\sqrt{\sum (x_i-\mu_x)^2}\sqrt{\sum (y_i-\mu_y)^2}},
$$
thresholded at 0.5.

The evaluation protocol uses a standardized context prompt, temperature 0, and up to 1,000 generated tokens. Claude 3.5 Sonnet performs automated judging, with reported 99% agreement with a hand-designed regex on items parsable by regex. Mechanistic analysis is integral rather than ancillary. Activation patching swaps selected hidden states $h_{(r,c,\ell)}$ between source and target images; linear probes read out Position and Distance from layerwise vision and language representations using standard multinomial logistic regression, $\hat{y}=Wh+b$.

The main empirical picture is that current VLMs often fail early, at coordinate recovery. Counting is near-perfect for $n=1$ but falls to 0% at $n=16$ across the three evaluated models. Position accuracy also declines sharply with point count, although InternVL3 maintains high position accuracy above 80% for $n<16$. The paper’s main text reports combined five-task FUGU accuracy of approximately 69.3% for InternVL3, 55.7% for LLaVA-OneVision, and 55% for LLaMA-3.2, while an appendix table reports 65.5%, 52.1%, and 55.7%, respectively. Coordinate extraction accuracy degrades strongly for LLaMA-3.2 and LLaVA-OneVision as plots become denser, whereas InternVL3 remains near ceiling.

Ground-truth coordinate listing substantially improves performance on the basic tasks for LLaMA-3.2 and LLaVA-OneVision, which the authors interpret as evidence that inaccurate coordinate extraction is a major bottleneck. By contrast, providing correct coordinates generally harms performance on ensemble tasks, suggesting that explicit enumeration of many points does not scale to multi-point statistical reasoning. Activation patching shows that at the earliest visual layer, swapping only the dot tokens yields 100% intervention success across tasks and models, whereas deeper layers distribute task-relevant information more broadly. Linear probes show that Position is decodable with 100% test accuracy from vision-encoder features across all layers and models, but decodability often collapses in language-model layers for LLaVA-OneVision and, to a lesser extent, LLaMA-3.2. The paper therefore localizes a major failure mode at the vision–language handoff rather than at initial visual encoding alone.

Fine-tuning improves but does not saturate performance. Training on 100k examples raises FUGU test accuracy from 54.2% to 77.7% for LLaMA-3.2, from 59.4% to 77.9% for LLaVA-OneVision, and from 67.1% to 85.9% for InternVL3, with all models reaching 98–99% training accuracy. Because none achieve ceiling performance on FUGU or on the ensemble tasks, the paper argues for architectural constraints beyond simple data scarcity. Proposed remedies in the report include explicit structured intermediate representations for coordinates, specialized connectors that preserve numeric transfer, arithmetic modules for quantities such as distances and means, and aggregation mechanisms better suited to multi-point statistical structure.

## 4. Sakana Fugu as a learned orchestration family

Sakana Fugu is a family of learned orchestrator models that expose a single model interface while internally harnessing a team of more capable LLM agents with different specializations in mathematics, coding, cybersecurity, scientific reasoning, factual recall, long-context retrieval, and interactive tool use [2606.21228]. The system’s central claim is that capability can be amplified through *collective intelligence*: instead of requiring one model to dominate every domain, an orchestrator learns to route, decompose, coordinate, verify, and synthesize across multiple frontier models.

Two released variants are distinguished by orchestration depth. *Fugu* is a latency-aware learned router. It uses a pre-trained language-model backbone with a lightweight selection head operating in parallel to the LM head; the selection head reads an internal hidden state $h \in \mathbb{R}^d$ at an early token position and emits logits over worker models. It is adapted with singular-value fine-tuning of selected parameter matrices, training only the singular-value scales while holding orthogonal components fixed. At runtime it performs per-turn worker selection over state $s_t$, which includes the task, previous turns, tool calls, and execution feedback. *Fugu-Ultra* is a workflow-generating conductor trained as a language model to output natural-language workflows whose steps consist of a subtask string, a worker agent identifier, and an access list specifying which previous outputs are visible.

The execution model of Fugu-Ultra is correspondingly richer. A workflow execution engine prompts designated workers, routes tool and function calls, stores outputs for later steps, and enforces memory policies. Each agent’s function-calling transcript is isolated within a workflow to prevent what the report calls “orchestration collapse,” yet shared memory can persist across workflows in the same multi-turn conversation. The architecture supports chains, trees, best-of-$N$ structures, debate, and aggregation. The report gives qualitative examples of per-domain adaptivity: Gemini used for scientific recall or niche factual synthesis, GPT for mathematical derivations or as a coding “builder,” and Claude Opus for software engineering, cybersecurity, and re-verification at critical debugging points.

Training differs across the two variants. Fugu is trained first by large-scale supervised fine-tuning on verifiable single-step tasks, using soft targets over workers derived from repeated worker performance and a KL-divergence objective matching the orchestrator policy to that distribution. It is then refined on end-to-end, multi-turn tasks by sep-CMA-ES over sparse terminal rewards. Fugu-Ultra is trained with the Conductor framework and GRPO. Its reward shaping assigns 0 to unparsable workflows, 1 to well-formatted workflows yielding correct final outputs, and 0.5 otherwise; training uses grouped completions to estimate a Monte-Carlo advantage, and the report states that Fugu-Ultra is run without KL regularization, $\beta=0$.

The benchmark results reported are broad and numerically specific. Fugu-Ultra scores 73.7 on SWE-Bench Pro, 82.1 on Terminal Bench 2.1, 93.2 on LiveCodeBench v6, 90.8 on LiveCodeBench Pro, 50.0 on Humanity’s Last Exam, 86.6 on CharXiv Reasoning, and 95.5 on GPQA-Diamond. Fugu scores 59.0, 80.2, 92.9, 87.8, 47.2, 85.1, and 95.5 on the same benchmarks. The report also gives results on SciCode, $\tau^3$ Banking (pass@4), Long Context Reasoning, and MRCR v2, and describes additional stress tests including AutoResearch, classical Japanese letter reading order, CAD generation, Rubik’s cube solver synthesis, blindfold chess, and online sequential trading.

These results are presented as evidence that learned orchestration can exceed the performance of individual public frontier models on many tasks. The report also emphasizes infrastructure: integration with Mini-SWE-agent and Terminus 2, harness-enforced turn budgets, sandboxed execution, routing through provider APIs, workflow-format validation, and configurable agent pools for provider preference or compliance constraints. Its limitations are correspondingly operational as well as algorithmic. Incorrect agent selection can produce poor trajectories; brittle external environments may fail independently of orchestration quality; Fugu-Ultra’s workflow invalidity is both a guardrail and a failure mode; and deeper workflows incur greater latency and cost. The stated future directions include richer tool-use RL, broader agent pools, routing topologies that explicitly optimize cost and latency, stronger verification, and broader production harnesses beyond coding.

## 5. Fugaku, colloquially searched as “FUGU,” in lattice QCD

A distinct HPC usage arises from the Fugaku supercomputer, which the cited benchmark report notes is “often colloquially searched as ‘FUGU.’” In that context, the term refers not to a software framework or benchmark suite but to an Arm-based, SVE-enabled flagship supercomputer built through co-design between RIKEN and Fujitsu [2109.10687]. The benchmarked application is a single-precision lattice QCD quark solver for a Clover–Wilson Dirac matrix, preconditioned by the Schwarz Alternating Procedure domain decomposition and using Jacobi iterations for local domain inverses.

The linear system has the form $Ax=b$, where $A$ is the Clover–Wilson Dirac operator on a four-dimensional Euclidean lattice. The report gives both the standard Wilson–Dirac operator and the clover-improved form
$$
D_{CW}=D_W + c_{SW}\sum_{\mu<\nu}\sigma_{\mu\nu}F_{\mu\nu},
$$
and describes the QWS implementation as
$$
D = 1 + C - \kappa H.
$$
The solver uses right-preconditioned BiCGStab on the operator $(AM_{\mathrm{SAP}})y=b$, with $x=M_{\mathrm{SAP}}y$. SAP splits the lattice into non-overlapping even and odd domains; the local block inverses are approximated via truncated Neumann series, equivalently Jacobi iterations, within each domain. This organization is chosen because it allows communication–computation overlap in all phases of the $AM_{\mathrm{SAP}}$ application, minimizing synchronization points.

The headline result is a single-precision quark solver sustaining 102 PFLOPS on the full-machine configuration used for the benchmark, corresponding to about 10% of Fugaku’s single-precision peak of approximately 996 PFLOPS for 147,456 nodes in boost mode. On the same $192^4$ lattice problem, the solver achieves a 38× reduction in time-to-solution compared with the K supercomputer. Five repeated weak-scaling runs on 147,456 nodes yield per-iteration times of 0.8000, 0.7998, 0.7982, 0.7989, and 0.7978 ms, compared with approximately 30.65 ms per iteration on K. Average power during the evaluation region is reported as about 20 MW, or about 5 GFLOPS/W on this application.

Several levels of optimization are combined. Fugaku nodes contain a single A64FX CPU with 48 compute cores arranged into four 12-core CMGs, 32 GiB HBM2 with up to 1024 GB/s sustained bandwidth per node, and a 6D TofuD mesh/torus interconnect. QWS uses a structure-of-arrays, x-major layout suited to 512-bit SVE; masked vector loads and XOR operations for the x-direction stencil; manual prefetching; enlarged OpenMP regions; and a reorganization of the local clover-inverse multiplication routine to avoid register spill/fill. Compiler flags are used to reduce spills from 512 to 14. Communication employs double-buffered, one-sided RDMA through the uTofu API with strong ordering, cache injection, and polling of TCQ and MRQ queues. Global reductions are reorganized to exploit Fugaku’s three-element hardware Allreduce via the Tofu barrier engine.

At full scale, performance is already communication-limited to a substantial degree. The report gives a per-iteration breakdown of approximately 0.807 ms total, with about 0.400 ms in computation and about 0.407 ms in communication. Halo exchange and global reductions together consume roughly half the runtime. The authors therefore note that in production settings, fewer nodes may yield better overall efficiency even if the peak benchmark uses the full machine. For physics production, the report also notes that single precision is used only in the evaluation region; double-precision accuracy is recovered through mixed-precision deficit-correction outer loops.

The significance of this “FUGU” usage is therefore terminological rather than nominal. It does not designate a separate artifact called FUGU; rather, it indexes a body of work on Fugaku in which extreme-scale stencil computation is realized through domain decomposition, communication overlap, topology-aware mapping, wide-vector SVE utilization, and co-designed collective operations.

## 6. Cross-domain patterns and distinctions

The principal misconception surrounding FUGU is that it names a single system. In the cited arXiv literature, it does not. One Fugu is a neuromorphic programming framework, another is a controlled VLM benchmark suite, another is a family of learned LLM orchestrators, and another usage refers indirectly to Fugaku through colloquial search practice [1905.12130]. Their overlap is conceptual rather than taxonomic.

A first commonality is the centrality of *scaffolds*. In the neuromorphic framework, the scaffold is an explicit computation graph of bricks with timing and size metadata. In Sakana Fugu, the scaffold is an adaptive multi-agent workflow over specialist LLMs. In the VLM benchmark, the term appears differently, but the task suite effectively decomposes chart understanding into foundational subskills such as coordinate extraction, distance computation, extremum identification, and mean estimation. This suggests that the shared name tracks a broader systems view in which high-level competence is assembled from carefully composed lower-level operations.

A second commonality is the use of intermediate representations to mediate between heterogeneous components. Fugu’s NetworkX IR separates algorithm composition from hardware mapping. FUGU’s visualization benchmark uses explicit coordinate targets, activation patching, and linear probes to localize failure between vision and language representations. Sakana Fugu turns hidden-state routing decisions or natural-language workflows into executable coordination structures over multiple external models. Fugaku’s QWS solver likewise depends on structured mappings between mathematical operators, process grids, SVE layouts, and TofuD communication patterns. In each case, performance depends on preserving salient information across interfaces.

The main distinctions concern what is being optimized. The neuromorphic framework optimizes programmability and compositionality under hardware heterogeneity. The VLM benchmark optimizes diagnostic resolution rather than leaderboard breadth, and its most notable result is that accurate coordinate information can exist in vision representations while degrading at the vision–language interface. Sakana Fugu optimizes system capability by learning to allocate tasks across specialized closed-source workers. The Fugaku work optimizes throughput and weak scaling for a specific lattice QCD kernel on a particular machine. These are different research agendas even when they converge on similar language of composition, routing, or scaffolding.

Taken together, these uses of FUGU show how a single label can attach to distinct research programs that all foreground system structure. Whether the object is a spiking circuit, a chart-understanding pipeline, a multi-agent workflow, or a lattice QCD solver, the salient question is not merely the power of the underlying primitive but how primitives are linked, synchronized, and exposed through an interface.

Source: https://www.emergentmind.com/topics/fugu