Stanford and NVIDIA collaborate on AI breakthrough, increasing reasoning speed by 2.4x

Imagine a scenario where you have three AI assistants working together to solve a math problem.

The traditional approach is for the first AI to “write” out the solution strategy, the second AI to “read” it and then write a new strategy, and the third AI to “read” and then “write” again.

This process is like three people taking turns using walkie-talkies to pass messages, where each person must first “translate” their thoughts into words, and the other person must then “translate” those words back into thoughts. Is it slow? Yes. Is it inefficient? Yes. Worse still, this “translation” process loses information—what you think in your mind is often not the same as what you say out loud.

This is the core dilemma facing current multi-agent AI systems: the “language tax.”

Recently, UIUC, Stanford, NVIDIA, and MIT jointly proposed a new approach—RecursiveMAS—which enables AIs to communicate directly through "thought" without the need for verbal exchange. In tests, it improved reasoning speed by 2.4 times and reduced token consumption by 75%.

(Research reference: https://arxiv.org/abs/2604.25917)

Over the past two years, multi-agent systems have become one of the most popular research directions in AI. From OpenAI’s Swarm to Microsoft’s AutoGen, from LangGraph to CrewAI, everyone is exploring how to enable multiple AIs to collaborate on complex tasks that single models cannot accomplish alone. However, in these systems, the efficiency of collaboration among multiple agents has always been constrained by a fundamental assumption—that agents must communicate through natural language text.

When you have a "math expert" and a "code reviewer" collaborate, the process seems very "reasonable," but upon closer inspection, many issues arise:

Each message transmission involves a dual transformation: internal thought → text → internal thought. The tokens consumed in this process represent not only monetary cost but also precious computational resources and time. More critically, this “write then read” process loses information—the rich semantic meaning compressed into text during model decoding cannot be fully restored when the next model re-decodes it. In a workflow involving five agents, the time overhead of text encoding and decoding often accounts for more than 60% of total latency.

What’s even more frustrating is that this paradigm has always lacked a clear “knob” for systematic optimization: adding more agents? Marginal returns diminish while communication overhead grows exponentially. Expanding the context window? Token costs explode. Increasing model parameters? Individual agents become stronger, but collaborative efficiency doesn’t improve fundamentally—like giving everyone in a group better walkie-talkies, yet they still have to read text one by one; the communication method hasn’t changed, so even if everyone is smarter, overall efficiency can’t break through. Industry solutions—whether prompt engineering or LoRA fine-tuning—can only alleviate symptoms to some extent, but cannot cure this fundamental architectural issue.

The core idea of RecursiveMAS is brilliant: since language is the bottleneck, don't use language at all.

It draws inspiration from the Recursive Language Model. In traditional language models, data flows linearly from the first layer to the last, with more layers leading to more parameters; in contrast, the Recursive Language Model does the opposite—it does not add more layers, but instead repeatedly reuses the same set of layers, allowing data to circulate back and forth between them. Each pass through this set of layers is equivalent to an additional round of “thinking,” deepening the reasoning depth without increasing the number of parameters.

RecursiveMAS extends this idea from "within a single model" to "a multi-agent system":

Each agent is like a layer in a recursive language model, no longer generating text but passing on "thoughts"—a continuous vector representation existing in latent space.

Researchers used a poetic metaphor: "agents communicating telepathically as a unified whole"—agents collaborating as one, like through telepathy.

Specifically, after processing, Agent A1 passes its hidden representation to Agent A2, which processes it and passes it to A3, and so on, until the final Agent completes its task. The final hidden output is then directly fed back to A1, initiating a new recursive iteration. The entire process occurs entirely within the hidden space; only at the last step of the final iteration is the ultimate hidden representation decoded into textual output. This is like a group of experts sitting around a table—no speaking, no note-taking—each simply thinks silently and directly passes their internal “thought成果” to the next person—a process that is both quiet and efficient.

Figure: RecursiveMAS Architecture Diagram—Multiple Agents Achieve Closed-Loop Recursive Collaboration Through an Embedding Space (Source: arXiv)

The key component of this system is called RecursiveLink, a lightweight two-layer residual module responsible for preserving and transforming the hidden representations of one model and transferring them to the embedding space of the next model. The hidden states from the final layer of a language model already encode rich semantic reasoning information; RecursiveLink’s role is to fully “transfer” these high-dimensional insights directly, rather than first translating them into text and then interpreting them. It comes in two versions: internal and external.

Figure: Recursive Learning Process—Internal and External Links Co-trained (Source: arXiv)

In terms of training strategy, RecursiveMAS features an elegant design: the backbone model weights are fully frozen, and only the RecursiveLink module needs to be trained. This aligns with the spirit of LoRA (Low-Rank Adaptation), but RecursiveLink is even more lightweight—the entire system requires updating only about 13 million parameters, accounting for just 0.31% of all trainable parameters. It has the lowest peak GPU memory demand among all compared methods and reduces training costs by more than 50% compared to full fine-tuning. Think of it as a “lightweight adapter” that plugs directly into existing Agent ecosystems without requiring retraining of new models from scratch. If multiple Agents are based on the same base model (e.g., all using Qwen), they can even share the same model weights, further conserving memory.

Training is conducted in two phases:

Inner loop warm-up: Each agent trains its own Inner RecursiveLink independently, learning to "think" in latent space rather than "write" questions. This phase can be performed in parallel, like having everyone practice "inner monologue" first.

Outer-loop training: Chain all agents into a complete recursive pipeline, optimizing for the quality of the final text output by jointly updating all RecursiveLinks through shared gradients. This stage addresses the "credit assignment" problem—how to accurately attribute the success or failure of the final outcome to each agent's contribution. This phased approach avoids the training instability that may arise from attempting to solve everything in a single step.

Researchers have theoretically proven that the gradients of recursive training remain stable, avoiding the gradient explosion or vanishing problems common in RNNs, while also offering better runtime complexity than traditional text-based MAS.

No matter how well the theory sounds, it ultimately comes down to data. The research team conducted comprehensive evaluations across nine mainstream benchmarks covering mathematics, science and medicine, code generation, and search-based question answering, using four collaboration modes: sequential reasoning, mixture of experts, knowledge distillation, and negotiated tool calling. The open-source model lineup used in the experiments was quite impressive—Qwen, Llama-3, Gemma3, and Mistral—each assigned different roles to form various collaboration patterns.

Compared against equally rigorous baselines: LoRA fine-tuning, full fine-tuning (SFT), Mixture-of-Agents, TextGrad, LoopLM, and Recursive-TextMAS, which uses the same recursive loop structure but enforces text communication. This final control is especially critical—it demonstrates that RecursiveMAS’s advantages stem from “skipping text decoding,” not from the recursive structure itself. All comparisons were conducted under the same training budget, ensuring fairness.

RecursiveMAS Core Performance Metrics

The results show that RecursiveMAS achieved consistent improvements across all metrics:

Accuracy: Average accuracy improved by 8.3%, outperforming TextGrad by 18.1% on AIME2025 and by 13% on AIME2026. Skipping text decoding not only avoids information loss but enables the model to retain richer latent semantics—after all, compressing thought into text and then decompressing it incurs far greater information loss than we typically assume.

Speed: End-to-end inference speed increases by 1.2x to 2.4x, and continues to improve with additional recursive rounds. This is highly significant for real-world applications: a more than 2x speed improvement in AI customer service or code assistance systems means a qualitative leap in user experience.

Cost: Token consumption is reduced by 34.6% to 75.6% compared to Recursive-TextMAS. This is not just a cost saving—it means deeper reasoning can be attempted within the same token budget.

Speedup factor under different recursive rounds

Here’s a key insight: the greater the recursion depth, the higher the yield. The acceleration effect increases with each recursion round: 1.2x on round 1, 1.9x on round 2, and 2.4x on round 3. The reason is simple—you’re eliminating the time each Agent spends turning ideas into text, and the more Agents and rounds, the more time you save.

Token savings ratio across different recursion rounds

During the third round of recursion, token consumption decreased by 75.6%—meaning that, at equivalent performance, operational costs can be reduced to about one-quarter of the original. This is undoubtedly a major advantage for production environments requiring complex, multi-step reasoning.

If it were merely a numerical improvement, this paper might not have attracted such attention. What truly makes it noteworthy is its potential to redefine the scaling direction of multi-agent systems.

Over the past few years, scaling efforts in the multi-agent field have primarily focused on three approaches: increasing the number of agents, expanding the context window, and stacking larger models. However, each of these methods faces its own bottlenecks—more agents lead to communication explosion, larger windows cause cost explosion, and bigger models result in training explosion.

RecursiveMAS offers a new approach: deepening recursive depth. It transforms the paradigm of “multi-agent collaboration” from a parallel, text-based interaction model into a deep, latent-space recursive one. Just as recursive language models deepen reasoning by repeatedly processing the same problem, RecursiveMAS enables multiple agents to iteratively “refine” each other’s “thoughts” without needing to “speak and listen” each time.

The core question raised by researchers in the paper is: “Can agent collaboration itself be extended through recursion?” The answer appears to be yes.

When the system no longer needs to translate internal representations into human-readable intermediate formats, the upper limit of collaborative efficiency can be further unlocked.

The current industry context also provides practical use cases for this research. Baidu's 2026 Developer Conference is themed "Everything as One (Agents at Scale)," Anthropic has launched Claude Managed Agents, and OpenAI continues advancing real-time reasoning for GPT-5-level models—the entire industry is seeking ways to move Agent collaboration from demos to production environments. And the three major challenges—computational cost, inference latency, and VRAM limitations—are precisely what RecursiveMAS aims to address with just 0.31% parameter overhead.

Of course, this research is still in its early stages, and several issues warrant attention:

The reliability of the data is yet to be verified. All current results are self-reported by the author and have not been independently replicated. The academic community typically adopts a stance of “bold hypotheses, careful verification” toward new technologies. In this era of “paper explosion,” independent replication remains the best way to assess the true value of a technology.

Compatibility of heterogeneous agents. Although Outer RecursiveLink is designed to connect models with different architectures, the paper does not provide detailed insights into how latent representations are transferred across architectures. If it can only be used with homogeneous agents, its practical applicability will be significantly limited, as real-world scenarios often require mixing closed-source APIs such as GPT-4o and Claude.

Explainability decreases. When what is passed between agents is no longer readable text but a set of vector representations, the entire collaboration process becomes a "black box." In production environments where accountability for AI decisions is required, this opacity can lead to compliance and audit challenges.

The complexity of production environments. The paper tests relatively clean collaborative scenarios, whereas real production environments often involve external tool calls, human-computer interactions, dynamic workflows, and other complex factors.

The proposal of RecursiveMAS essentially introduces the "recursion" strategy, proven effective in the era of single models, into the multi-agent era, challenging the default assumption that agents must exchange information through natural language. If data is reproducible, the next scaling axis for the MAS赛道 may shift from "increasing the number of agents" to "deepening recursive depth."

Of course, this research still needs to be validated on more independent benchmarks, requires solving the issue of interconnected heterogeneous models, and must prove itself in real production environments. But at the very least, it shows us a possibility—

Collaboration between AI agents doesn't always have to be like talking past each other.

((This article was originally published on the Titanium Media APP, author | Silicon Valley Tech_news, editor | Jiao Yan))