Back to publications

Agentic AI · openJiuwen Team, Huawei · 2026

ConvRSI

From Recursion to Convolution: Parallel Self-Improvement for Multi-Agent Systems

A framework that replaces part of the sequential recursion in multi-agent self-improvement with convolutional updates: within each agent over its features, and across agents over the collaboration graph, all in latent space.

+5.04% performance improvement on MATH-500 over RecursiveMAS
45.11% lower latency, with 17.27% lower inference cost
1.82× faster than RecursiveMAS on MATH-500 at three recursion rounds (1.80× on MBPP+)
01

Motivation

Deeper recursion is slow and lets errors spread.

Recursive self-improvement lets a multi-agent system feed its improvements back into the next round. Scaling it to more agents and deeper iterations runs into three problems. Each round builds on earlier outputs, so mistakes propagate. Chain-like dependencies force later updates to wait for earlier ones, which wastes parallel compute. And refining one feature or one agent in isolation ignores how roles, prompts, experience, and messages depend on each other.

ConvRSI takes a space–time view: improvement can come not only from more sequential iterations but also from more structured spatial computation within each iteration.

02

Method

Two coupled convolution stages in latent space.

Stack agent features

Each agent's task, role, system prompt, experience, and message are read from its frozen LLM as hidden-state slots and projected into a shared width.

Intra-agent convolution

A channel-wise 1-D convolution along the feature axis lets related features refine each other. A gated readout pools them into one local message per agent.

Inter-agent graph convolution

A GCN layer updates all agents' messages at once using the adjacency matrix of the collaboration graph, so sequential, mixture, and other topologies fit the same operator.

Train in parallel

Inner training learns prefixes from each agent's local messages independently. Outer training precomputes prefixes for all rounds through the convolutional recurrence, then optimizes on the final output.

The language models stay frozen. Only the projections, convolutions, graph layer, and latent transfer modules are trained.

03

Performance

Better accuracy as depth grows, at a fraction of the runtime.

75.0%

MATH-500 accuracy

At three rounds, 3.6 points above RecursiveMAS and 5.4 above Recursive-TextMAS, with a planner–critic–solver team of small models.

+5.2 pts

Mixture collaboration

With code, science, and math specialists plus a summarizer, MATH-500 accuracy rises from 60.6% to 65.8% over RecursiveMAS.

+25.6%

Runtime growth, 1 → 3 rounds

On MATH-500, compared with +88.6% for RecursiveMAS and +109.4% for Recursive-TextMAS. Generated tokens stay nearly flat.

Sequential-Light team at recursion depth r = 3. Runtime is total benchmark time on NVIDIA RTX 4090D GPUs.
Method MATH-500 acc. (%) Time (s) MBPP+ pass@1 (%) Time (s)
ConvRSI75.0145932.9695
RecursiveMAS (latent)71.4265832.11249
Recursive-TextMAS (text)69.6472129.13575

ConvRSI also outperforms adapted ModularRSI, Hermes+, and MASS baselines on both benchmarks; MASS at Level-1 trails it by 6.3 points on MATH-500 and 4.2 on MBPP+.