📊 PAPER → Collective Intelligence 1️⃣ of ♾️: Multi-Agents
Intermediate to Advanced AI Scientists and Engineers | Today's Word: Solace
🎼 "What is past is prologue." — William Shakespeare, on The Tempest

Saturdays are a great day to review a few papers related to one of my main areas of interest (for many years): collective (super)intelligence and multiplayer agents. The backlog is large, but this is fun (and we have our whole lives ahead of us).
For anyone new here, multi-agent deployment is directly relevant to the work we're doing on NULLSTAR's PleiadesOS:CELAENO module.
As I read through the material, I wrote down a few highlights — with a moderate attempt at coherence — for my personal inventory and delight (and perhaps as a way to connect with other friendly AI scientists and builders out there who love talking about the same things). As always, remember the rules:
🤖 If you see a 👾, it means I found something particularly cool or learned something new.
🤖 If you see a ✨, it means things that are so cool that they need a lil glitter around them.
🤖 If these notes look cool to you, it's your ✦moral duty✦ to read the original resources.
🤖 Just another blog, but not your usual blog: they're living notes that I change as I fancy.
🪂 Self-Consistency Improves Chain of Thought Reasoning in Language Models (2023)
Chain-of-thought prompting combined with pre-trained large language models has achieved encouraging results on complex reasoning tasks. In this paper, we propose a new decoding strategy, self-consistency, to replace the naive greedy decoding used in chain-of-thought prompting. It first samples a diverse set of reasoning paths instead of only taking the greedy one, and then selects the most consistent answer by marginalizing out the sampled reasoning paths. Self-consistency leverages the intuition that a complex reasoning problem typically admits multiple different ways of thinking leading to its unique correct answer.

🪂 Language Models are Super Mario (2024)
Language Models (LMs), similar to Apocalypse and Super Mario, can enhance their capabilities by absorbing other models without the need for retraining or even GPUs.

Discussed the extremely redundant properties of SFT delta parameters in LMs and proposed a simple approach DARE to effectively reduce the number of delta parameters needed for SFT without any data, retraining, or even GPUs. DARE can impressively drop 90% or even 99% SFT delta parameters without sacrificing much performance compared with using all SFT delta parameters. We further employed DARE as a versatile plug-and-play approach for existing model merging methods to merge multiple task-specific fine-tuned models into a single model with diverse abilities. Extensive experimental results on both encoder- and decoder-based LMs demonstrated the effectiveness of DARE in reducing SFT delta parameter redundancy and facilitating the model merging performance. We also provided a deeper analysis of why DARE works as well as the prerequisites for using DARE. We hope that our findings can advance the understanding of model alignment from the perspective of analyzing model parameters.
🪂 A Survey on the Memory Mechanism of LLM based Agents (2024)
In the agent-environment interaction process, there are three key phases, that is, (1) the agent perceives information from the environment, and stores it into the memory; (2) the agent processes the stored information to make it more usable; and (3) the agent takes the next action based on the processed memory information. In all these phases, memory plays an extremely important role.

The textual memory stores raw information about the agent-environment interactions, which is more comprehensive and detailed. However, it is constrained by the token limitation of LLM prompts, which makes the agent hard to store extensive information. In contrast, the parametric memory is not limited by the prompt length, but it may suffer from information loss when transforming texts into parameters, and the complex memory training can bring additional challenges.
For textual memory, each LLM inference requires to integrate memory into the context prompt, which leads to higher costs and longer processing times. In contrast, for parametric memory, the information can be integrated into the parameters of the LLM, eliminating the extra costs of these contexts. However, parametric memory takes additional costs in the writing process, but textual memory is easier to write, especially for small amounts of data. In a nutshell, textual memory is more efficient in writing, while parametric memory is more efficient in reading.
Textual memory is usually more explainable than the parametric one, since natural languages are the most natural and straightforward strategies for humans to understand, while parametric memory is commonly represented in latent space. Nevertheless, such explainability is obtained at the cost of information density. This is because the sequences of words in textual memory are represented in a discrete space, which is not as dense as continuous space in parametric memory.

Although parametric memory holds great prospects, it currently faces numerous challenges. Foremost among these is the issue of efficiency: how to effectively transform textual information into parameters or modifications of parameters is a critical question. Presently, researchers can transfer vast amounts of domain knowledge into the parameters of LLMs by SFT. However, it is time-consuming and requires extensive text corpus, making it unsuitable for situational knowledge. One viable approach is to employ meta-learning to let models learn to memorize. Moreover, the lack of interpretability associated with parametric memory can be a hindrance, especially in domains requiring high levels of trust, such as medicine. Therefore, enhancing the credibility and interpretability of parametric memory is an urgent issue that needs to be addressed.
🪂 Learning to Orchestrate Agents in Natural Language (Nielsen et al., 2026)
- Introduce a new kind of conductor model trained with RL to automatically discover coordination strategies among LLMs. -> Learns not only to design targetered communication technologies for effective agent-to-agent collaboration, but also prompt engineer focused instructions to the LLMs to maximally leverage their individual capabilities.
- By learning optimal coordination strategies over pools of powerful worker LLMs, a 7B conductor achieves significant performance grains beyond any individual worker.
- By training with randomized agent pools, the conductor effectively adapts to arbitrary sets of open and closed source agents. -> allowing the conductor to select itself as a worker gives rise to recursive topologies, elevating performance with a new form of dynamic test-time scaling through online iterative adaptation.
- RL conductor -> a new kind of reasoning model trained with RL to dynamically divide challeging problems, delete targeted subtasks, design communication topologies for a set of worker LLM agents -> our model itself is a LLM tasked to output a sequence of workflow steps, each defined by a natural language instruction focusing on some aspect of the overall task.
- Extend the framework by finetuning the pre-trained conductor with two additional techniques: 1) by training with randomized agent pools at each step, 2) by allowing the conductor to specify itself as a worker LLM (giving rise to a new kind of recursive topology).
- RL conductor -> a language model trained through e2e RL to divide challeging problems, delegate targeted subtasks, and design communication topologies for a set of worker LLMs.
- RL reasoning paradigm (introduced by DeepSeek R1) -> optimize an LLM policy using a custom system prompt, by making it generate its own completions on a set of verifiable problems -> the reward ri for each output of the model are determined by two conditions: 1) the format condition, setting ri to -1 for any model that does not adhere to <think>/<solution>, 2) the correctness, setting ri to 1 in case the model's correctly formatted outputs match the solution si and to -0.5.
- The model is trained with GRPO.
🪂 Trinity: An Evolved LLM Coordinator (J. Xu et al., 2026)
Lightweight coordinator that orchestrates collaboration among large language models (LLMs). The coordinator, comprising a compact language model (≈ 0.6Bparameters) and a lightweight head (≈ 10K parameters), is optimized with an evolutionary strategy for efficient and adaptive delegation. -> TRINITY processes queries over multiple turns, where at each turn the coordinator assigns one of three roles (Thinker, Worker, or Verifier) to a selected LLM, effectively offloading complex skill acquisition from the coordinator itself.

Theoretical and empirical analyses highlight two key factors driving this success: (1) the coordinator’s hidden-state representations provide rich contextualization of inputs, and (2) under high dimensionality and strict budget constraints, the separable Covariance Matrix Adaptation Evolution Strategy algorithm provides substantial advantages over RL, imitation learning, and random search, leveraging potentA prominent line of work involving large language models (LLMs) aspires to scale in line with empirical scaling laws, targeting gains by enlarging model size, training tokens, and compute. Yet the extent to which such scaling remains efficient and yields sustained returns is uncertain and often resource intensive. An alternative at the micro level is model merging, which seeks parameter-level integration. However, this approach is frequently impractical due to architectural incompatibilities and the closed-source nature of many high-performing models. In light of these limitations, we adopt a macro-level approach: test-time model composition via coordination, which fuses the complementary strengths of multiple state-of-the-art models from diverse providers without modifying their weights. Leveraging prior data and training investments, this coordination can deliver performance improvements without retraining individual models.ial block-ε-separability.
A prominent line of work involving large language models (LLMs) aspires to scale in line with empirical scaling laws, targeting gains by enlarging model size, training tokens, and compute. Yet the extent to which such scaling remains efficient and yields sustained returns is uncertain and often resource intensive. An alternative at the micro level is model merging, which seeks parameter-level integration. However, this approach is frequently impractical due to architectural incompatibilities and the closed-source nature of many high-performing models. In light of these limitations, we adopt a macro-level approach: test-time model composition via coordination, which fuses the complementary strengths of multiple state-of-the-art models from diverse providers without modifying their weights. Leveraging prior data and training investments, this coordination can deliver performance improvements without retraining individual models.
To ensure the coordinator remains lightweight and offloads complex skill acquisition, TRINITY assigns the selected agent one of three distinct roles: (1) a thinker to devise high-level strategies and decompositions; (2) a worker to perform concrete problem-solving steps; and (3) a verifier to evaluate the current solution’s soundness and completeness.
🪂 Sakana Fugu Technical Report (2026)
✨ How to combine the individual specializations of various LLMs into a collectively intelligent system? The next frontier might not be achieved by any single model alone, but by systems that can identify, combine, amplify the strength of models: Intelligence as an emergent property of coordinated model collective. ✨
- Sakana Fugu is a family of learned LLM orchestrators that expose multi-agent intelligence through a single model interface:
➡️ Fugu models learn to construct query-adaptive workflows over a pool of expert LLM workers a model orchestration can serve as practical scaling axis
➡️ It composes models at the behavioral level rather than the parameter level
➡️ Treating orchestration as a first class scaling axis may distibute the benefits of frontier AI more broadly
- Fugu Models are themselves language models trained to understand user queries and dynamically devise agentic scaffolds to solve them.
- Agent scaffolds augment autoregressive generation with: 1) structured prompting, 2) external tool use and function calling, 3) environment feedback, and 4) memory management.
- The growing range of language models with diverse capabilities and the impact of domain-specific agentic scaffolds motivate the development of systems that can orchestrate collective intelligence: dynamically choosing which models to evolve, how they should communicate, use tools, and interact with the environment.
- The scaffold is generated by a trained orchestrator at inference time. Rather than applying a fixed interaction pattern or relying on a task-specific harness, Fugu dynamically decided how to reason about each request, which frontier agents to involve, how they should communicate, and how the output should be synthesized into a final answer.
Related Work
- A growing body of work studies how to coordinate groups of LLM agents through communication protocols, voting mechanisms, routing policies, and learned collaboration structures.
- Multi-agent LLM systems often rely on hand-designed collaboration patterns: orchestrating multiple agents across sucessive discussion or reasoning rounds, using fixed interaction structures to improve final answers -> other works move toward learned or adaptive conditions and coordination, mapping queries to suitable agents -> collaboration as learned graphs.
- Shaping the models's reasoning through prompting and decoding strategies, including CoT prompting, self-consistency, and structured search over reasoning paths such as Tree of Thoughts.
- Interleaving reasoning with acting, allowing the model to plan, call tools, and incorporate observations. -> coupling reasoning traces with actions, equiping the model with external tools and function calling -> adding feedback and interaction, where models critique and revise their own outputs through self-reflection, or from singlas from the environment. -> together with support for a long-horizon memory, these components transform a static model into a capable agent.
- How to combine the capabilities of multiple models through model merging? At the parameter level, early approaches use static recipes such as weight averaging, models soups, or task-balanced interpolation to integrate capabilities across domains.
- More recent work introduces optimization-based merging, evolutionary search over merging recipes showing that learned strategies can outperform hand-designed ones.
- Other methods improve the reliability of parameter-space fusion by resolving task conflicts, sparsifying parameter updates, or preserving important directions. -> however, parameter-space merging operates directly on weights -> a complementary family of methods composes models in the data-flow or representation space. instead of averaging all weights, these approaches stitch layers, mix blocks, route hidden states, or construct hybrid architectures from existing components.
Sakana Fugu
A lightweight selection head operates in parallel to the base models LM head. It takes a hidden state
hfrom the orchestrator backbone as input and outputsLlogits, one for each worker model in the pool. Unlike the TRINITY coordinator, Fugu does not asssing roles. The selected model is always invoked as a worker, which reduces coordination latency.
- Family of learned orchestrators that expose a multi-agent system through a single model interface. -> Given a user query, a Fugu Model constructs an agentic scaffold over a pool of frontier LLM workers. -> The system can route, delegate, coordinate across multiple specialized agents.
- Builds on TRINITY, but scale and adapt the learned-orchestration idea to a production setting in which the orchestrator must make fast reliable routing decisions.
- Parametrization -> Fugu's orchestrator is designed as a fast decision module over a pool of frontier worker models. It uses pre-trained language models.
- Fine-tune the singular-value scales of selected parameter matrices in the LM's layer. -> concretely, given a pool of
Lworker models, we attach a lightweight prediction head after the final hidden layer of the orchestrator backbone.
- For a hidden state
h, the head outputsLlogits that score which worker model should be selected for the input. -> Unlike TRINITY, Fugu always dispatches the query to the selected model as a worker. -> Removing role assignment narrows the coordination space to model selection alone.
- To improve the representation used by this lightweight head without full fine-tuning, we adapt a small subset of the backbone parameters using singular-value fine tuning. -> Together with the lightweight prediction head, this yields a small trainable parameter set while allowing the orchestrator representation to adapt to the routing problem.
- A key design choice is that Fugu uses the orchestrator logits rather than its generated text -> since prompting and task execution are delegated to the selected frontier model, the orchestrator only needs to produce a worker-selection decision -> Inference becomes cheaper -> the system computes a hidden state and an early token position, apply the selection head, and dispatch the query to the selected worker, without the expensive autoregressive decoding process -> This decision-only parametrization is central to Fugu's latency profile and makes evolutionary optimization practical.
SFT on Single-step Tasks
- Train Fugu in 2 stages: starting with SFT, assemble a large collection of single-step tasks spanning coding, reasoning, etc.
- Construct training labels: run every worker model Mi in the pool on qi for N repetitions and measure each model's performance by comparing with si, yielding for each model a set of candidate solutions and reward set -> These rewards induce a ranking over the worker pool, from the model best suited to a problem -> rather than discarding the reward magnitude by supervising on the hard ranking alone, we convert the scores into soft target distribution over softmax -> use this distribution as supervision, training both the lightweight selection head and the singular-value scales in the orchestrator backbone.
- Learning from a soft performance distribution, rather than classifying a single best label, gives the orchestrator a richer training signal and makes its selection more robust when several workers are similarly capable.
- Because supervision is derived directly from measured worker performance and does not require generation from the orchestrator, this stage provides an efficient and stable initalization for the subsequent evolutionary optimization stage.
Applying Evolutionary Strategies on E2E Tasks
- After SFT on single-step tasks, we optimize Fugu with evolutionary strategies on E2E tasks -> collect real-world multi-turn trajectories from different coding-assistant environments context, iterative editing, tool calls, execution feedback. -> expand training distribution from static questions to agentic workflows.
For an E2E task
qidrawn from a collection, the orchestrator interacts with the harness over a sequence of turns.
Each candidate fitness is estimated by averaging the terminal reward over replicated E2E runs, and the top-M candidates are recombined via fitness-weighted averaging.
- Evolutionary algorithms are well-suited here because the SFT stage already places the orchestrator parameters in a strong region of the search space, allowing the evolutionary search to refine routing behavior at a finer granularity.
Fugu Ultra
- Most complex workflows -> add extensions to accommodate long-horizon function calling and multi-agent workflows through adaptive agent memory.
- The conductor's objective is to solve tasks indirectly by designing agentic workflows specific to any input question
qi.
- Each agentic workflow is a sequence of workflow steps whose final output is returned as the actual conductor response
oi.
- Each step specifies a string with a natural-language subtask, an integer ID corresponding to the assigned worker agent for the subtask, and an access list indexing which subtask solutions from the previous steps to include in the worker's context.
Workflow Execution
- The reward
rifor each response from conductor model is determined by two conditions: 1) the conductor format condition (list that cannot be parsed), 2) the conductor correctness (the final output from executing a well-formatted agentic workflow).
- Trained Fugu ultra with GRPO, using the grouped completions to compute a Monte-Carlo advantage function.
- The conductor framework allows one to specify the orchestrator itself as a worker, further extending the range of topologies.
Emergence of problem decompositions and prompt-engineered subtasks leveraging the differing strengths and skills of each agent.
Function Calling Agentic Workflows
- Function calling within a multi-agentic workflow poses a challenge in terms of memory.
- To honor the function call loop and enable any agent to interact freely with the environment, the system must retain which agent emitted each call, along with where the agent sits in the conductor workflow, so inter-agent communication topology is maintained -> Track the conductor's workflow state containing the selected models, communication topology, and assigned subtasks.
Intra-Workflow Agent Isolation
- In order to fully leverage the differing specialities of the agent team, we isolate each agent's workflow and function's calling trajectory from each other -> This intra-workflow isolation is necessary to prevent orchestration collapses.
- An agent observes the actions and outputs of another only through the access list -> avoid conditioning subsequent agent's solution trajectories on the work done by previous agents.
Persistent Shared Memory
- Complete isolation from all function calling over a multi-turn conversation history is suboptimal -> agents must retain some memory of their interactions with the environment in order to not make repeated tool calls to rediscover the same artifacts and accrue the background context to solve the task.
- Inter-workflow shared memory across agents, allowing them to observe tool calling from previous workflows -> grant agents full memory over ongoing state of a multi-turn conversation -> background context of each agent.
Training Setup
- To train Fugu-Ultra, scale the conductor's RL approach starting from a pre-trained checkpoint of a regular language model -> Designed agentic workflows of up to 5 steps using a diverse pool of frontier LLMs -> for multi-turn tasks, any agent is permitted unlimited interaction with the user environment -> we train using our conductor reward, with GRPO and without any KL divergence penalty.
- The training dataset is a mixture of public available data and expert-design e2e environments simulating real agents-user interactions.
Capabilities
Benchmarking
- coding, SWE -> SWE bench pro and terminal bench 2.1
- underlying capacities -> minimal evaluation harness, mini-SWE agent and terminus
- scientific -> GPQA diamond
- multidiciplinary reasoning -> humanity's last exam
- competitive programming -> live code bench
- science -> scicode
- multimodal graphical -> charxiv reasoning
- conversational dialogues -> t3
- long-context retrieval -> needle-in-a-haystack and long context retrieval
Domain adaptability is a hallmark feature of an intelligent orchestrator.
Autonomous ML Research Workflow
- Autoresearch -> an agent iteratively edits a small GPT training pipeline, executes each change, and retains modifications that reduce validation bits-per-byte.
- Success depends not on single coding step but on sustained exploration of optimizer settings, batching, architecture scale, and schedule choices over many sequential experiments.
- Fugu-Ultra is competitive early in the run and pulls ahead after mid-training, suggesting that orchestration is most valuable once the search space shifts from coarse configuration changes to finer optimizer and schedule tuning.
- Fugu-Ultra improves both peak performance and consistency (multi-model orchestration can outperform any individual frontier agent on an agentic training-optimization benchmark).
Optimal Strategies & Topologies
- Fugu-Ultra can produce any coordination topology describable in natural language on a per-question basis -> multi-round debate and tree topologies are powerful strategies to maximize the collective knowledge from an agent team -> domains requiring niche or specialized factual knowledge.
- Dynamic adaptation of an aggregator role is the kind of adaptation unavailable to multi-agent systems, which necessitate a fixed model to always act as a final synthesizer.
🪂 Recursive Harness Self-Improvement (Lee et al., 2026)
Under model–harness co-evolution, harnesses are not merely inference-time scaffolds but data-generating components whose execution traces can shape future foundation models. This motivates harness-in-the-loop learning: optimizing harnesses for both immediate agent performance and the quality of traces used for future model training.
Recursive Harness Self-Improvement (RHI) represents the harness as a prompt-level specification of the agent loop and iteratively refines it using pairwise feedback over its own revision history. It defines the harness as the agent loop itself, including the roles assigned to agents, the instructions they follow, the information exchanged between agents (contracts), and the workflow structure governing when reasoning is invoked (hops).

🪂 Continuous Thought Machines (L. Darlow et al., 2025)
- By incorporating neuron-level processing and synchronization, we reintroduce neural timing as a foundational element.
- Continuous Thought Machine (CTM): a model designed to leverage neural dynamics as its core representation. The CTM has two innovations: (1) neuron-level temporal processing, where each neuron uses unique weight parameters to process incoming histories; and (2) neural synchronization as a latent representation.
- The CTM uses an internal sequence, meaning training times are extended. NLMs also increase parameter counts compared to standard activation functions, but also provide a new avenue for scaling. The experiments in this paper are preliminary and not intended to beat state-of-the-art models tailored for performance, therefore a limitation of this paper is its relatively limited depth of comparison since we favored breadth to investigate the CTM’s internal functionality.