Recursion Turns Agents into Depth-Limited Subroutines

RecursiveLink is a lightweight two-layer residual module that moves last-layer hidden states between agents and across rounds. Instead of decoding text, an agent’s final hidden state passes through an inner link that maps it back toward the model’s input-embedding space. An outer link projects that representation to the hidden dimensionality of the next agent. The module is residual: it preserves original latent semantics and only learns the distributional shift between agents. That keeps training stable and avoids wholesale remapping of representations. Two engineering choices matter. First, only the final round decodes tokens; intermediate rounds remain latent, eliminating per-round vocabulary projections. Second, base LLM weights are frozen; only the inner/outer links are trained. In the paper’s setup that is roughly 13M trainable parameters, about 0.3% of the full system, enabling system-level co-adaptation without full fine-tuning. The abstraction scales to heterogeneous teams. A math specialist, a code specialist, and a summarizer can be different model families. RecursiveLink bridges them in hidden space instead of forcing a brittle text protocol.

Training proceeds in two stages to make recursion learnable. The inner loop warm-starts each agent’s inner link with a regression objective. Concretely, the link learns via a cosine-style loss that pulls generated latent thoughts toward the input embedding of the gold text. This aligns individual agents to produce useful latent directions before system-level unrolling. The outer loop then unrolls the full recursive computation for n rounds and minimizes cross-entropy on the final textual output. Gradients backpropagate through the entire latent trace, giving every outer link a shared global credit signal. Because only the links are updated, the gradient path stays compact and the computational burden concentrates on low-dimensional transforms. The paper gives two theoretical justifications. Replacing repeated vocabulary projections with low-dimension latent transforms removes an |V| factor (vocabulary size) from per-step cost because hidden dimension d_h is far smaller than |V|. And they prove a gradient-stability result: text-mediated recursion can suffer vanishing gradients under confident token predictions, while latent recursion preserves informative gradients across rounds. Practically, that lets you learn deeper unrollings without gradient collapse.

The authors evaluate RecursiveMAS on nine benchmarks across mathematics (MATH500, AIME 2025/2026), QA (GPQA-D, MedQA), and code (LiveCodeBench), among others. They test four collaboration patterns—Sequential, Mixture, Distillation, Deliberation—using off-the-shelf agent checkpoints (examples include Qwen, Llama3, BioMistral variants) with the released RecursiveLink weights. Under matched training budgets and comparable MAS structure, RecursiveMAS reports an average +8.3% accuracy gain over the strongest baselines. Per-task improvements reach +18.1% on an AIME-style math task. End-to-end inference speeds improve by 1.2×–2.4×, and token usage drops 34.6%–75.6% relative to text-based multi-agent methods. Gains scale with recursion depth. In sequential experiments the latent-loop performance increases as round r grows, while text-based recursive MAS either plateaus or regresses. Two practical takeaways: you can get deeper joint reasoning from small (<~4B) agents by stacking latent rounds, and the token/latency savings compound across rounds, yielding substantial system-level wins.

Think of RecursiveMAS as scaffolding that converts agents into compartmentalized, callable subroutines with a bounded depth budget. That mirrors standard engineering practice: recursion and subroutines build complexity from simple pieces. RecursiveMAS provides cheap, differentiable call/return semantics in hidden space. It is not a universal fix. The method assumes you can freeze base LLMs or avoid full-system fine-tuning. If upstream agents must adapt their weights to a task distribution, you will need additional machinery. When interactions involve noisy external tools or chaotic environment state, text or structured tool outputs may still be necessary. Recursion also does not solve delegation errors or hallucinations. It reduces coordination cost but verification remains required. Still, for workflows that stitch specialized models and where latency and reproducibility matter, latent recursion is a low-friction, high-leverage lever. The code, checkpoints, and datasets are released on GitHub and Hugging Face, so this is a runnable pattern, not just a paper claim.