Recursive Multi-Agent Systems
| Authors | Xiyuan Yang et al. |
| Year | 2026 |
| HF Upvotes | 246 |
| arXiv | 2604.25917 |
| Download | |
| Code | https://github.com/RecursiveMAS/RecursiveMAS |
Abstract
Recursive or looped language models have recently emerged as a new scaling axis by iteratively refining the same model computation over latent states to deepen reasoning. We extend such scaling principle from a single model to multi-agent systems, and ask: Can agent collaboration itself be scaled through recursion? To this end, we introduce RecursiveMAS, a recursive multi-agent framework that casts the entire system as a unified latent-space recursive computation. RecursiveMAS connects heterogeneous agents as a collaboration loop through the lightweight RecursiveLink module, enabling in-distribution latent thoughts generation and cross-agent latent state transfer. To optimize our framework, we develop an inner-outer loop learning algorithm for iterative whole-system co-optimization through shared gradient-based credit assignment across recursion rounds. Theoretical analyses of runtime complexity and learning dynamics establish that RecursiveMAS is more efficient than standard text-based MAS and maintains stable gradients during recursive training. Empirically, we instantiate RecursiveMAS under 4 representative agent collaboration patterns and evaluate across 9 benchmarks spanning mathematics, science, medicine, search, and code generation. In comparison with advanced single/multi-agent and recursive computation baselines, RecursiveMAS consistently delivers an average accuracy improvement of 8.3%, together with 1.2times-2.4times end-to-end inference speedup, and 34.6%-75.6% token usage reduction. Code and Data are provided in https://recursivemas.github.io.
Engineering Breakdown
Plain English
undefined
Core Technical Contribution
The core novelty is casting a multi-agent system as a unified latent-space recursive computation, rather than treating agent collaboration as discrete message passing or function calls. RecursiveLink is the technical mechanism—a lightweight module that enables agents to exchange and refine latent states across recursion iterations in-distribution, meaning agents stay in a coherent latent space without expensive serialization or protocol translation. The inner-outer loop learning algorithm is designed to optimize the entire recursive system holistically; instead of training agents independently then composing them, this approach co-trains all agents through their shared recursion structure. This represents a fundamental shift from thinking of multi-agent systems as fixed compositions to viewing them as dynamically refined latent computations.
How It Works
RecursiveMAS operates in a loop: at each recursion step, agents receive a shared latent state representing the current problem understanding, perform their specialized computation, and output refined latent thoughts. The RecursiveLink module acts as the glue, taking outputs from one agent's latent space and preparing them for the next agent's input without conversion to discrete tokens, preserving information density. Over multiple recursion iterations (e.g., 2-5 steps), this latent exchange allows agents to iteratively sharpen their understanding of the task—early iterations may capture high-level problem decomposition, while later iterations focus on refinement and error correction. The inner loop optimizes individual agent parameters given the current shared latent trajectory, while the outer loop adjusts how latent states propagate between recursion steps. The entire system is differentiable end-to-end, so gradients flow through both within-agent computation and between-agent latent transfers.
Production Impact
For teams building multi-agent systems, this approach could reduce integration friction by replacing rigid agent APIs with latent-space communication, though this requires careful consideration of system coherence and debuggability. The iterative refinement principle is valuable for high-stakes tasks like code generation, theorem proving, or complex reasoning where intermediate error detection and correction matter—you can run 2-3 recursion steps on easy problems and 5+ steps on hard ones without changing agent code. However, the compute cost grows linearly with recursion depth (roughly 3-5× cost for 3-5 iterations), making this approach most suitable for latency-tolerant applications like offline analysis rather than real-time systems. In practice, you would instrument latent states at each recursion step to monitor convergence and detect divergence, adding operational complexity compared to simple agent pipelines. The approach requires careful initialization and tuning of the RecursiveLink module; poor design there can cause information loss that amplifies across recursion steps.
Limitations and When Not to Use This
The paper does not address how to compose RecursiveMAS with truly heterogeneous agents that were not designed for latent-space collaboration—if you have legacy agents with fixed I/O signatures, you still need adapters that may bottleneck performance. The framework assumes agents can meaningfully improve across multiple iterations, but for tasks with a single correct answer (e.g., factual retrieval), recursion may yield diminishing returns or even hurt performance through amplified hallucination. Scalability to very large numbers of agents (10+) is unexplored; the latent-space bottleneck and optimization complexity may become prohibitive. The paper does not analyze failure modes when one agent's latent output is incomprehensible to another, nor does it provide strategies for detecting or recovering from such breakdowns during recursion.
Research Context
This work extends recent advances in recursive or looped language models (e.g., iterative refinement as a scaling law) from single-model settings to multi-agent systems, positioning agent collaboration itself as a learnable, deepenable computation. It builds on prior multi-agent research that treats agents as modular components, but departs by embedding agents in a shared latent-space recursion rather than explicit message passing or orchestration protocols. The framework is situated in the broader trend of moving away from discrete intermediate representations (tokens, structured outputs) toward continuous latent refinement for reasoning-heavy tasks. This opens a new research direction: exploring recursion depth as a controllable axis for multi-agent system capability and efficiency, similar to how scaling laws have evolved for single models.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::