betaFeedback

WorksComputer Science

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

Abstract

Multi-agent self-improvement enables agents to improve through interaction and feedback. However, sequential dependencies across agents and refinement rounds can propagate errors, increase computational costs, and limit parallelism. Moreover, refining individual features or agents in isolation can overlook their dependencies and restrict collective coordination. To address these challenges, we propose ConvRSI, a framework for parallelizing multi-agent self-improvement through convolution. ConvRSI couples intra-agent convolution, which jointly refines related agent features, with inter-agent graph convolution, which aggregates messages according to the collaboration topology. Both stages operate in latent space, enabling parallel updates without repeatedly decoding and re-encoding intermediate messages. Experiments on MATH-500 show that ConvRSI achieves 5.04% performance improvement while reducing 17.27% inference cost, and 45.11% latency compared with RecursiveMAS. It also supports diverse collaboration patterns by representing their topologies as adjacency matrices. These results demonstrate the potential of convolutional co-evolution for efficient multi-agent self-improvement. Our code and datasets are provided in https://github.com/LYA2333/ConvRSI.

Source Code: https://github.com/LYA2333/ConvRSI

Introduction

Multi-agent systems (MAS) tackle complex tasks by coordinating agents with complementary roles, knowledge, and reasoning capabilities. Beyond collaboration among fixed agents, recent research explores how agents can improve through their interactions and experience. Prior work advances MAS through role-specific training feedback [11] and the co-evolution of question generation, solving, and judging through self-play [1]. Recursive self-improvement (RSI) extends this direction by feeding improvements back into the system, enabling the updated system to guide subsequent rounds of improvement. For example, RecursiveMAS [26] iteratively refines shared latent states and jointly optimizes agents at the system level, while MASS [8] alternates workflow evolution with model training on self-generated trajectories. Despite this progress, scaling self-improvement to more agents and deeper iterations faces inherent challenges in optimization stability, computational efficiency, and the scope of collaboration, as discussed below.

First, deeper recursion propagates error. Each recursive round builds on earlier outputs or updates, allowing mistakes to influence subsequent decisions and become harder to correct. RecursiveMAS [26] jointly optimizes agents across rounds but retains the dependency chain through which errors can spread. Similar risks arise in other forms of agent RSI: inaccurate self-evaluation in MASS [8] can introduce flawed trajectories into subsequent training, while mistaken memory updates in Recuris [22] can affect future task execution. This raises a key question: can comparable improvement be achieved with fewer sequential updates?

Second, sequential multi-agent computation limits efficiency and parallelism. Multi-agent RSI repeatedly executes agents, exchanges information, and evaluates updates, increasing computational costs as agent count and iteration depth increase. Chain-like dependencies force later updates to wait for earlier results, limiting the use of available parallel computing resources. Such dependencies arise across recursive collaboration links in RecursiveMAS [26], the generation–verification–refinement pipeline in MALT [11], and successive harness evolution cycles in ModularRSI [17]. This motivates restructuring agent updates to reduce the time and cost required to reach a target level of performance.

Third, individual feature updates and chain-like evolution limit global coordination. Each agent’s behavior depends on related features, including task information, environmental observations, roles, experience, prompts, and messages. Refining one feature in isolation can overlook its dependencies on others. Existing methods address different aspects of improvement: Recuris [22] evolves memory, ModularRSI [17] evolves and integrates harness modules, MASS [8] improves workflows with model capabilities, and RecursiveMAS [26] refines hidden states across agents. These leave room for a complementary design that jointly models related features within each agent and aggregates information across agents to support global evolution. In particular, chain-like evolution passes information from one agent to the next, making distant agents interact through intermediate updates. A broader approach would aggregate agents for collective, rather than agent-by-agent evolution [22, 8].

To address these challenges, we propose ConvRSI, a framework for parallelizing multi-agent self-improvement through convolution. The idea is to replace portions of sequential recursive computation with convolutional updates over agent features and multi-agent collaboration graphs. This introduces a space–time scaling perspective: improvement can be pursued not only by increasing temporal iteration depth, but also by expanding spatial computation within each iteration. Rather than simply adding more independent agents, ConvRSI uses structured convolutional operations to coordinate parallel updates within and across agents.

ConvRSI comprises two coupled stages of improvement. Intra-agent convolution applies one-dimensional convolution to hidden-state sequences representing an agent’s task, role, experience, prompt, and messages. It jointly models local dependencies among these features, enabling each agent to independently refine its message state through the convolutional interactions. The features are initialized once and subsequently refined through convolution. Inter-agent convolution then applies graph convolution to the updated agent messages according to the collaboration topology. Through parallel matrix operations, it aggregates information across connected agents. The resulting messages are fed into the next intra-agent stage, coupling individual refinement with collective evolution. Both stages operate on latent representations, enabling efficient convolutional updates without repeatedly decoding messages into text and re-encoding them. This matrix-based design exposes parallelism across feature positions and agents throughout evolution. Moreover, ConvRSI supports diverse multi-agent collaboration patterns by representing their topologies as adjacency matrices for inter-agent graph convolution.

Empirically, we evaluate ConvRSI on 2 benchmarks spanning math and coding, using diverse model families and multi-agent collaboration patterns, including sequential style and mixture style. Compared with representative multi-agent and recursive baselines, ConvRSI improves task performance while reducing the cost of self-improvement. In particular, it achieves a 5.04% performance improvement, a 17.27% reduction in inference cost, and a 45.11% inference speedup. At comparable performance, ConvRSI achieves these gains with 1.82×1.82 \times and 1.80×1.80 \times inference speedups and generates 17.3% and 4.4% fewer tokens per problem, demonstrating the efficiency of convolutional co-evolution.

Our main contributions are:

  • We introduce a space–time perspective on multi-agent self-improvement, exploring how spatially parallel computation can reduce reliance on deep sequential updates.

  • We propose ConvRSI, which couples intra-agent convolution over related agent features with inter-agent graph convolution over collaboration topologies. Together, these stages support iterative individual refinement and collective evolution.

  • We evaluate ConvRSI across diverse benchmarks, model families, and collaboration patterns, measuring performance gains under matched time and computational costs, as well as reductions in time and cost at comparable performance.

Related Work

Recursive Self-Improvement of Agents. Recursive self-improvement enables agents to improve their capabilities through feedback and accumulated experience. Existing work explores different targets of improvement, including model behavior, agent workflows, harness components, and memory. Specifically, RecursiveMAS [26] extends recursive computation to multi-agent collaboration by iteratively refining shared latent states and jointly optimizing agents through an inner–outer learning procedure. MASS [8] alternates multi-agent workflow optimization with model training on self-generated trajectories, using collective behavior as a source of self-supervision. MetaRSI [14] further explores meta-level self-improvement by coordinating data, harness, and model updates and adapting the strategy that schedules these updates. Beyond model-level improvement, ModularRSI [17] evolves agent harness modules using execution experience, Recuris [22] updates agent memory based on feedback, and Dream-RSI [25] reuses discovery histories to improve exploration policies. Building on RSI, ConvRSI reorganizes the improvement process through convolutional updates, coupling individual agent refinement with collective evolution while reducing reliance on sequential recursive steps.

Multi-Agent Training and Co-Evolution. Multi-agent training methods improve collective performance by encouraging agents to develop complementary capabilities and learn from their interactions. MALT [11] trains specialized agents for generation, verification, and refinement, while MAPoRL [12] applies multi-agent reinforcement learning to improve collaboration among language models. Multi-Agent Evolve [1] uses interacting roles to generate training data and feedback for model self-improvement. Related approaches explore the evolution of agent populations, as in EvoAgent [23], or the automatic optimization of agentic workflows, as in AFlow [24]. ConvRSI jointly refines features within each agent and uses a graph to model collaboration among agents, enabling collective co-evolution.

Parallel and Efficient Multi-Agent Collaboration. Multi-agent systems improve performance through collaboration, but additional agents increase compute costs, while sequential interaction rounds increase latency and limit parallelism. Recent work [18] compares the accuracy–compute trade-offs of self-consistency, self-refinement, multi-agent debate, and agent aggregation. Parallel self-refinement [16] generates multiple candidate solutions concurrently and synthesizes them into an improved response. Studies of multi-agent debate [13] further highlight the importance of comparison with strong alternatives under matched computational budgets. RecursiveMAS [26] improves the efficiency of recursive collaboration through latent-state communication. Complementing existing approaches to efficient collaboration, ConvRSI uses matrix-based convolution to enable parallel updates across agent features and connected agents. Its latent-space operations avoid repeated text decoding and re-encoding during evolution.

Preliminary

Hidden States in Autoregressive Text Generation

An autoregressive language model generates a response one token at a time. Given an input context xx and the previously generated tokens y<ty_{<t}, a causal Transformer [15] produces a contextual hidden state ht−1∈RH\mathbf{h}_{t-1} \in\mathbb{R}^{H}. An output head maps this state to the distribution of the next token:

pθ(yt∣x,y<t)=softmax⁡(Woutht−1+bout)yt.(1)p_{\theta}(y_t \mid x, y_{<t}) = \operatorname{softmax}(\mathbf{W}_{\mathrm{out}}\mathbf{h}_{t-1} + \mathbf{b}_{\mathrm{out}})_{y_t}. \tag*{(1)}

The hidden state is a continuous representation of the preceding context, whereas the output distribution is defined over discrete vocabulary tokens. During teacher forcing, the model conditions on a reference prefix y<t∗y^{*}_{<t} and causal masking allows all reference positions in a given sequence to be processed in one forward pass. During free generation, the model instead conditions on its own preceding outputs.

Hidden states also provide a communication medium for a multi-agent system. Rather than decoding every intermediate thought into text, an agent can transform its hidden states into continuous input embeddings for another agent. Because agents may have different hidden widths and embedding spaces, these representations require learned mappings before they can be consumed by the receiving model.

Convolutional Computation

A one-dimensional convolution applies a shared local filter along an ordered axis [7]. For feature vectors xf\mathbf{x}_f, its output at position ff can be written as

zf=σ(∑δ∈KWδxf+δ+b),(2)\mathbf{z}_f = \sigma\left(\sum_{\delta\in\mathcal{K}} \mathbf{W}_{\delta}\mathbf{x}_{f+\delta} + \mathbf{b}\right), \tag*{(2)}

where K\mathcal{K} denotes the filter offsets and σ\sigma is a nonlinearity. In our setting, the ordered axis contains different feature types for the agent; each position on this axis corresponds to a feature type.

A graph convolutional network (GCN) aggregates information in the neighborhoods of a graph [5]. Let A∈R≥0N×N\mathbf{A} \in\mathbb{R}_{\geq0}^{N \times N} describe communication between NN agents, using the convention that Aij>0A_{ij} > 0 means that agent ii receives information from agent jj. We add a self-loop at each node and define

A~=A+I,D~ii=∑jA~ij,S=D~−12A~D~−12.(3)\widetilde{\mathbf{A}} = \mathbf{A} + \mathbf{I}, \qquad\widetilde{D}_{ii} = \sum_j \widetilde{A}_{ij}, \qquad\mathbf{S} = \widetilde{\mathbf{D}}^{-\frac{1}{2}}\widetilde{\mathbf{A}}\widetilde{\mathbf{D}}^{-\frac{1}{2}}. \tag*{(3)}

Multiplying a matrix of agent representations by S\mathbf{S} aggregates the representations of each receiver’s senders. In our implementation, this normalization can also be applied to a directed adjacency. In that case, S\mathbf{S} is not required to be symmetric.

Convolutional Multi-Agent Co-Evolution

We define Convolutional Multi-Agent Co-Evolution as a sequence of coupled representation updates. At the intra-agent convolution level, each agent combines its context features into a local message using a convolution over feature types. At the inter-agent convolution level, a graph convolution updates the messages jointly along the communication graph. The updated messages supply continuous prefixes for the current round and message features for the next round.

RecursiveMAS [26] performs multi-round collaboration in latent space, using InnerLinks to form continuous inputs and OuterLinks to transfer states between heterogeneous agents. ConvRSI augments this collaboration with a graph-message recurrence. The preceding GCN output supplies the recurrent message feature, and the underlying MAS routes agent execution states through its latent links.

Methodology

Consider a MAS with NN agents and frozen language models {Fi}i=1N\{F_i\}_{i=1}^{N} of native hidden widths HiH_i. The adjacency A\mathrm{A} specifies which agents exchange convolutional messages. The MAS supplies an execution schedule Π\Pi for model invocations and latent transfers, as well as a final output interface. Figure 1 shows a feature stack with F=5F=5 types ordered as task, role, system, experience, and message. The first F−1F-1 are static text features, with experience optional. The message feature is recurrent. In the full-sequence setting, each feature has KK slots. The convolutional operators use a shared width DD and run for RR rounds.

Figure 1. The ConvRSI framework shown for one slot across NN agents. Intra-agent convolution produces a local message from each feature stack. The GCN aggregates the stacked local messages and returns one updated message per agent for the next round. The schematic uses MtM^t and Mt+1M^{t+1} for the input and output of the graph layer, denoted by UkU_k and MkM_k in Eq. (7).

Convolutional Co-Evolution

Intra-Agent Convolution Let Zi∈RF×K×HiZ_i \in\mathbb{R}^{F \times K \times H_i} contain the feature slots of agent ii. The first round masks the message feature and initializes its slots to zero. Subsequent rounds obtain it from the preceding GCN output. An agent-specific projection maps each feature slot to the common space as

xi,f,k=WiinLN⁡(zi,f,k)+bi∈RD.(4)\mathbf{x}_{i,f,k} = \mathbf{W}^{\mathrm{in}}_i \operatorname{LN}(\mathbf{z}_{i,f,k}) + \mathbf{b}_i \in\mathbb{R}^{D}. \tag*{(4)}

We apply the feature mask after projection and after adding learned feature-type embeddings. At each slot kk, we stack the resulting vectors in feature order to form the F×DF \times D convolution input.

We then apply a channel-wise one-dimensional convolution along the feature axis. For a tensor V∈RF×D\mathbf{V} \in\mathbb{R}^{F \times D}, a convolutional block with the default residual connection is

V′=LN⁡[V+GELU⁡(Conv⁡(V))].(5)\mathbf{V}' = \operatorname{LN}\left[\mathbf{V} + \operatorname{GELU}\left(\operatorname{Conv}(\mathbf{V})\right)\right]. \tag*{(5)}

The operator Conv filters the feature axis independently in each channel, using a separate one-dimensional kernel per channel. The configured default has a kernel of size five, dilation one, and same padding. The convolution is applied independently to each slot and exchanges information across feature types while preserving the slot axis. In the optional no-residual variant, the block normalizes the activated convolution output without adding V\mathbf{V}; masks follow the actual convolution windows.

Let vi,f,kconv\mathbf{v}^{\mathrm{conv}}_{i,f,k} denote a feature vector after the final convolutional block. We apply a softmax to the gate scores gi(vi,f,kconv)g_i(\mathbf{v}^{\mathrm{conv}}_{i,f,k}) over the valid positions Ai\mathcal{A}_i, yielding weights βi,f,k\beta_{i,f,k}. A residual multilayer perceptron and a normalized projection ψi\psi_i transform the pooled vector vi,k=∑f∈Aiβi,f,kvi,f,kconv\mathbf{v}_{i,k} = \sum_{f \in\mathcal{A}_i} \beta_{i,f,k}\mathbf{v}^{\mathrm{conv}}_{i,f,k} into a local message

ui,k=ψi(vi,k+MLP⁡i(vi,k)).(6)\mathbf{u}_{i,k} = \psi_i\left(\mathbf{v}_{i,k} + \operatorname{MLP}_i(\mathbf{v}_{i,k})\right). \tag*{(6)}

We denote the full local operator, from feature projection to message readout, by Ci\mathcal{C}_i. Each agent has its own parameters and reuses them across rounds.

Inter-Agent Convolution For each slot, we stack the local messages into Uk=[u1,k;…;uN,k]∈RN×D\mathbf{U}_k = [\mathbf{u}_{1,k}; \ldots; \mathbf{u}_{N,k}] \in\mathbb{R}^{N \times D}. One GCN layer updates all nodes using the same pre-update matrix:

Mk=LN⁡[GELU⁡(SUkWg+1bgT)].(7)\mathbf{M}_k = \operatorname{LN}\left[\operatorname{GELU}\left(\mathbf{S}\mathbf{U}_k\mathbf{W}_g + \mathbf{1}\mathbf{b}_g^{\mathsf{T}}\right)\right]. \tag*{(7)}

The ii-th row, mi,k\mathbf{m}_{i,k}, is the updated graph message for agent ii. The vector 1∈RN×1\mathbf{1} \in\mathbb{R}^{N \times1} broadcasts the zero-initialized learnable bias bg\mathbf{b}_g to every agent. Layer normalization acts on the DD channels of each row. The graph weights are shared among agents and rounds. Under Eq. (3), each agent aggregates the senders selected by A\mathcal{A} and its own message via a self-loop. When slots are padded, aggregation uses the active nodes at that slot. The GCN updates those nodes synchronously.

Parallel ConvRSI Training

Figure 2 shows how the operators in Figure 1 are trained. Inner training learns to construct prefixes from each agent’s local messages. Outer training jointly optimizes the graph-message recurrence and the latent transfer modules.

Figure 2. The ConvRSI training pipeline. Inner training uses independent agent objectives. Outer training can compute prefixes for all rounds through the convolutional recurrence before the collaboration forwards. The collaboration consumes the prefix for each round and computes cross-entropy at the final output. Flames highlight trainable components and snowflakes mark frozen language models.

Training within Parallel Agents Each static component xi,fx_{i,f} is encoded independently by its agent’s frozen language model. Let

Hi,f=sg⁡[Fi(Emb⁡i(xi,f))]∈RLi,f×Hi,H_{i,f} = \operatorname{sg}\left[\mathcal{F}_i\left(\operatorname{Emb}_i(x_{i,f})\right)\right] \in\mathbb{R}^{L_{i,f} \times H_i},

where sg stops gradients through this static backbone computation. A trainable, agent-specific slot reader converts all valid hidden positions into KK content-dependent slots:

αi,f,ℓ,k=softmax⁡ℓ∈Ti,f([WistLN⁡(hi,f,ℓ)]k),\alpha_{i,f,\ell,k} = \operatorname{softmax}_{\ell\in T_{i,f}}\left(\left[\mathbf{W}^{\mathrm{st}}_i \operatorname{LN}(h_{i,f,\ell})\right]_k\right),
zi,f,k=LN⁡(∑ℓ∈Ti,fαi,f,ℓ,khi,f,ℓ+ei,kst),(8)z_{i,f,k} = \operatorname{LN}\left(\sum_{\ell\in T_{i,f}} \alpha_{i,f,\ell,k} h_{i,f,\ell} + e^{\mathrm{st}}_{i,k}\right), \tag*{(8)}

where Ti,fT_{i,f} contains the non-padding positions. Each agent shares its slot reader across its static text components. We compute these slots once per example in a system forward pass and reuse them across the convolutional rounds.

In Inner training, each agent applies CiC_i once with a masked message and maps the KK resulting local messages to KK soft prefix tokens. Its frozen LLM reads the prefix and predicts the local reference tokens under teacher forcing. The NN losses in Eq. (11) are independent, so the agents can train concurrently.

Parallel Graph Matrix Convolution across Agents In Outer training, all agents can compute their local messages concurrently within a round. Stacking them yields a tensor of shape [B,N,K,D][B, N, K, D] for a minibatch of BB examples. We apply Eq. (7) as a batched graph operation on the BKBK matrices of shape N×DN \times D. When the graph and node masks are fixed, the same normalization can be reused.

The superscript (r)(r) now indexes states and prefixes that vary by round. Let Qi:RD→RHiQ_i : \mathbb{R}^{D} \to\mathbb{R}^{H_i} map a shared graph message to the input space of agent ii. It gives the recurrent feature at r>1r > 1 and the prefix at every round as

zi,msg,k(r)=Qi(mi,k(r−1)),pi,k(r)=Qi(mi,k(r)).(9)z^{(r)}_{i,\mathrm{msg},k} = Q_i\left(m^{(r-1)}_{i,k}\right), \qquad p^{(r)}_{i,k} = Q_i\left(m^{(r)}_{i,k}\right). \tag*{(9)}

Let ZstaticZ_{\mathrm{static}} collect the static slots and M(r)M^{(r)} collect the updated graph messages over all slots. We write C\mathcal{C} for the local operators applied to their respective agents, Q\mathcal{Q} for the corresponding QiQ_i applied to each graph row, and GA\mathcal{G}_{A} for the slot-wise graph update in Eq. (7). For r>1r > 1, the messages evolve as

M(r)=GA(C(Zstatic,Q(M(r−1)))).(10)M^{(r)} = \mathcal{G}_{A}\left(\mathcal{C}\left(Z_{\mathrm{static}},\mathcal{Q}\left(M^{(r-1)}\right)\right)\right). \tag*{(10)}

The first round uses the masked zero message. The recurrence requires only the cached static slots and the previous GCN output. As shown in the lower left of Figure 2, we can run the convolutional rounds in order before the scheduled LLM forwards and store the resulting KK-token prefix pi(r)=(pi,k(r))k=1Kp_i^{(r)} = \left(p_{i,k}^{(r)}\right)_{k=1}^{K} for each agent and round.

Learning Convolution as a Whole When Π\Pi invokes agent ii in round rr, its LLM reads the prefix pi(r)p_i^{(r)} before its chat input and consumes the latent states supplied by the schedule. For a transfer from ii to jj, the source InnerLink Ii\mathcal{I}_i and the edge-specific OuterLink Oi→j\mathcal{O}_{i\to j} map output hidden states to the receiver’s input space, yielding Vi→j(r)=Oi→j(Ii(Hi,out(r)))\mathbf{V}_{i\to j}^{(r)} = \mathcal{O}_{i\to j}\left(\mathcal{I}_i\left(\mathbf{H}_{i,\mathrm{out}}^{(r)}\right)\right). The schedule governs which states are read within a round and which are carried forward. Invocations with independent inputs can run concurrently. The latent links share parameters across rounds.

Each teacher-forced invocation obtains the reference-conditioned hidden states in one forward pass. A configurable token budget caps the length of each transferred sequence during training. The final output yields Lout\mathcal{L}_{\mathrm{out}} in Eq. (11). The stored prefixes retain their computation graph, so the final loss backpropagates through the graph-message recurrence, the frozen backbones, and the differentiable latent transfers.

Training Objectives The local and final token-level cross-entropy objectives are

Lin,i=CE⁡(Pi,yi⋆),Lout=CE⁡(Pout(R),y⋆).(11)\mathcal{L}_{\mathrm{in},i} = \operatorname{CE}(\mathbf{P}_i,y_i^\star), \qquad\mathcal{L}_{\mathrm{out}} = \operatorname{CE}(\mathbf{P}_{\mathrm{out}}^{(R)},y^\star). \tag*{(11)}

Here Pi\mathbf{P}_i and Pout(R)\mathbf{P}_{\mathrm{out}}^{(R)} are predicted vocabulary distributions at the local and final output positions. The corresponding targets are the reference token IDs yi⋆y_i^\star and y⋆y^\star. We average CE over supervised output tokens and then over examples. The Inner loss updates each agent’s slot reader, local operator, and prefix map. The Outer loss jointly updates these modules, the GCN, and the OuterLinks, with frozen backbones and InnerLinks.

Collaboration Patterns The same convolutional operators can be applied to sequential, mixture, distillation, and deliberation styles by constructing a communication graph appropriate to the underlying MAS. These collaboration styles also appear in RecursiveMAS [26]. Table 1 gives representative adjacency constructions without fixing agent roles or backbone models. In every case, the degree matrix follows from D~ii=1+∑jAij\tilde{D}_{ii} = 1 + \sum_j A_{ij}; it is derived from the adjacency. The execution schedule, output interface, and any pattern-specific supervision are supplied by the MAS, while the intra/inter-convolution definitions remain the same.

StyleAdjacency constructionDegree after adding self-loops
SequentialAi+1,i=1A_{i+1,i}=1, 1≤i<N1 \le i < ND~11=1\widetilde{D}_{11}=1; D~ii=2\widetilde{D}_{ii}=2 for i>1i>1
MixtureAo,j=wjA_{o,j}=w_j, j∈Bj \in\mathcal{B}D~oo=1+∑j∈Bwj\widetilde{D}_{oo}=1+\sum_{j\in\mathcal{B}}w_j; D~jj=1\widetilde{D}_{jj}=1 for j∈Bj\in\mathcal{B}
DistillationAsymmetric influence: Aij≠AjiA_{ij}\ne A_{ji} on selected pairsD~ii=1+∑jAij\widetilde{D}_{ii}=1+\sum_j A_{ij}
DeliberationReciprocal exchange: Aij,Aji>0A_{ij}, A_{ji}>0 on interacting pairsD~ii=1+∑jAij\widetilde{D}_{ii}=1+\sum_j A_{ij}

Table 1. Representative communication graphs for different collaboration styles. Rows of AA are receivers and columns are senders. Unspecified entries are zero. In the mixture construction, oo is a designated receiving node, B\mathcal{B} contains the remaining nodes, and wj>0w_j>0. These are abstract graph constructions.

Inference Stage At inference, we encode the static inputs once, initialize the graph message with a masked zero, and use the same recurrence to supply prefixes to Π\Pi. For each intermediate invocation, the InnerLink maps the last hidden state to the next continuous input. The OuterLinks route the resulting hidden states according to Π\Pi. At the final output interface, the model autoregressively decodes the answer.

Stability and Computational Complexity Analysis

Stability For a fixed graph on the active agents, SS is similar to the row-stochastic matrix D~−1A~\widetilde{D}^{-1}\widetilde{A}, so its spectral radius is one. A directed graph can yield ∥S∥2>1\lVert S\rVert_2>1. For fixed static slots and feature masks after initialization, let LCL_C, LQL_Q, LσL_\sigma, and LLNL_{\mathrm{LN}} bound the Lipschitz constants of the local operator in its message input, the shared-to-native map, GELU, and LayerNorm. Two trajectories of Eq. (10) satisfy

∥ΔM(r)∥F≤κ∥ΔM(r−1)∥F,κ=LLNLσ∥S∥2∥Wg∥2LCLQ.(12)\lVert\Delta M^{(r)}\rVert_F \le\kappa\lVert\Delta M^{(r-1)}\rVert_F,\qquad\kappa=L_{\mathrm{LN}}L_\sigma\lVert S\rVert_2\lVert W_g\rVert_2L_CL_Q. \tag*{(12)}

Graph-message perturbations contract when κ<1\kappa<1. For fixed teacher-forced references and latent sequence shapes under Π\Pi, suppose the retained execution states V(r)V^{(r)} satisfy

∥ΔV(r)∥≤a∥ΔM(r)∥F+b∥ΔV(r−1)∥(13)\lVert\Delta V^{(r)}\rVert\le a\lVert\Delta M^{(r)}\rVert_F+b\lVert\Delta V^{(r-1)}\rVert \tag*{(13)}

for uniform constants a,b≥0a,b\ge0. Then max⁡(κ,b)<1\max(\kappa,b)<1 is sufficient for both state perturbations to vanish over successive rounds.

Computational Complexity With JJ depthwise blocks of kernel width qq, the per-round forward costs of local message and prefix construction and dense graph propagation are

Clocal=O(BK∑i=1N[FHiD+JFqD+D2+DHi])(14)C_{\mathrm{local}}=\mathcal{O}\left(BK\sum_{i=1}^{N}\left[FH_iD+JFqD+D^2+DH_i\right]\right) \tag*{(14)}
Cgraph=O(BK[ND2+N2D]).(15)C_{\mathrm{graph}}=\mathcal{O}\left(BK\left[ND^2+N^2D\right]\right). \tag*{(15)}

The local terms cover feature projection, depthwise convolution, pooled channel transforms, and mapping to the native space. The graph terms cover channel projection and dense aggregation. The RR rounds cost R(Clocal+Cgraph)R(C_{\mathrm{local}}+C_{\mathrm{graph}}).

Let Ci(L;B)C_i(L;B) be the cost of an agent-ii backbone forward at length LL. Static encoding costs ∑i∑f=1F−1Ci(Li,f;B)\sum_i\sum_{f=1}^{F-1} C_i(L_{i,f};B) per system forward, and slot reading costs O(BK∑i,fLi,fHi)\mathcal{O}(BK\sum_{i,f}L_{i,f}H_i) over the same features. Teacher-forced collaboration adds ∑aCi(a)(La;B)\sum_a C_{i(a)}(L_a;B) over scheduled invocations aa with agent i(a)i(a) and input length LaL_a. At inference, QΠQ_\Pi intermediate invocations of TT latent steps each require QΠTQ_\Pi T latent forwards before final text decoding. Storing all round prefixes takes O(BRK∑iHi)\mathcal{O}(BRK\sum_i H_i) entries, in addition to cached feature slots and training activations.

Experiments

Experimental Setup

Datasets and metrics. We use the Sequential-Math and Sequential-Code training datasets released with RecursiveMAS [26] for mathematical reasoning and code generation, respectively. We evaluate mathematical reasoning on MATH-500 [9, 3] using final-answer accuracy and code generation on MBPP+ [10] using pass@1, the fraction of problems for which a single generated solution passes all benchmark tests. We report both metrics as percentages averaged over four random seeds.

Baselines and backbones. We compare ConvRSI with five baselines. The first two use the Sequential-Light configuration of RecursiveMAS [26]: Recursive-TextMAS exchanges intermediate outputs as text, while RecursiveMAS passes latent states between agents. Both use Qwen3-1.7B as the planner, Llama-3.2-1B-Instruct as the critic, and Qwen2.5-Math-1.5B-Instruct as the solver. The remaining baselines are ModularRSI [17], Hermes+ [19], and MASS [8]. We adapt all three to use the Sequential-Light solver backbone, Qwen2.5-Math-1.5B-Instruct [21], in place of the DeepSeek backbones used by ModularRSI and Hermes+ and the 27B Qwen backbone used by MASS.

Inference and evaluation. We evaluate ConvRSI, Recursive-TextMAS, and RecursiveMAS at recursion depths r∈{1,2,3}r \in\{1,2,3\}. Following RecursiveMAS [26], we use top-pp sampling with p=0.95p=0.95 on both benchmarks. For MATH-500, we set the temperature to 0.6 and the maximum generation length to 2,000 tokens. For MBPP+, we use a temperature of 0.2 and a maximum of 4,000 tokens. Within each benchmark, all methods receive the same problem statement in the input format required by each method and use the same decoding settings and scoring procedure. We measure inference efficiency on NVIDIA RTX 4090D GPUs and report total runtime (seconds) and the mean number of generated tokens per problem.

Main Results: Performance Across Recursive Depths

We evaluate ConvRSI on MATH-500 and MBPP+ at recursion depths r∈{1,2,3}r \in\{1,2,3\}. Table 2 reports MATH-500 accuracy, MBPP+ pass@1, total inference time on NVIDIA RTX 4090D GPUs, and generated-token counts. For the adapted ModularRSI, Hermes+, and MASS baselines, we use Qwen2.5-Math-1.5B-Instruct [21], the solver backbone in the Sequential-Light configuration. It replaces the DeepSeek backbones in ModularRSI and Hermes+ and the 27B Qwen backbone in MASS.

MethodMATH-500MBPP+
Acc. (%) ↑\uparrowTime (s) ↓\downarrowTokens ↓\downarrowPass@1 (%) ↑\uparrowTime (s) ↓\downarrowTokens ↓\downarrow
Recursion round r=1r = 1
Recursive-TextMAS (text-only)71.42254119530.414891163
RecursiveMAS (latent)70.1140955829.1776603
ConvRSI (Ours)71.6116247130.0431559
Recursion round r=2r = 2
Recursive-TextMAS (text-only)71.03761220130.030301879
RecursiveMAS (latent)70.9179948229.5982566
ConvRSI (Ours)72.4125546430.3549508
Recursion round r=3r = 3
Recursive-TextMAS (text-only)69.64721308829.135752548
RecursiveMAS (latent)71.4265855632.11249611
ConvRSI (Ours)75.0145946032.9695584

Table 2. Performance and inference efficiency across recursion depths on MATH-500 and MBPP+. All results are reproduced using NVIDIA RTX 4090D GPUs. Accuracy is reported as a percentage (%), time in seconds (s), and token usage as generated tokens.

Performance across recursion depths. On MATH-500, ConvRSI improves from 71.6% accuracy at r=1r=1 to 72.4% at r=2r=2 and 75.0% at r=3r=3. Its lead over the better of Recursive-TextMAS and RecursiveMAS grows from 0.2 to 1.4 to 3.6 percentage points across the three depths. Over the same range, RecursiveMAS improves from 70.1% to 71.4%, while Recursive-TextMAS declines from 71.4% to 69.6%. On MBPP+, Recursive-TextMAS leads at r=1r = 1 with 30.4% pass@1, 0.4 points above ConvRSI. ConvRSI overtakes both recursive baselines at r=2r = 2 and reaches 32.9% at r=3r = 3, 0.8 points above RecursiveMAS and 3.8 points above Recursive-TextMAS.

Inference efficiency. ConvRSI completes both benchmarks in less time and generates fewer tokens than either recursive baseline at every depth. At r=3r = 3, it completes MATH-500 in 1,459 s, compared with 2,658 s for RecursiveMAS and 4,721 s for Recursive-TextMAS, yielding 1.82×1.82\times and 3.24×3.24\times speedups, respectively. On MBPP+, the corresponding runtimes are 695 s, 1,249 s, and 3,575 s, yielding 1.80×1.80\times and 5.14×5.14\times speedups. At this depth, ConvRSI generates 17.3% fewer tokens on MATH-500 and 4.4% fewer on MBPP+ than RecursiveMAS.

Generalization Across Collaboration Patterns

We evaluate whether the gains from ConvRSI extend beyond the sequential planner–critic–solver configuration to a mixture in which a summarizer combines the outputs of code, science, and mathematics specialists. Table 3 lists the agents in each configuration. Within each configuration, we compare ConvRSI with the released RecursiveMAS checkpoints [26].

Collaboration PatternRoleModel Size & Version
Sequential Style (Light)PlannerQwen3-1.7B [20]
Sequential Style (Light)CriticLlama-3.2-1B-Instruct [2]
Sequential Style (Light)SolverQwen2.5-Math-1.5B-Instruct [21]
Mixture StyleCode SpecialistQwen2.5-Coder-3B-Instruct [4]
Mixture StyleScience SpecialistBioMistral-7B [6]
Mixture StyleMath SpecialistDeepSeek-R1-Distill-Qwen-1.5B [21]
Mixture StyleSummarizerQwen3.5-2B [20]

Table 3. Agent roles and model assignments for the two collaboration patterns evaluated with ConvRSI. Sequential-Light uses a planner, critic, and solver in sequence. In the mixture, a summarizer combines outputs from code, science, and mathematics specialists.

Table 4 shows that ConvRSI improves on RecursiveMAS under both collaboration patterns. In the sequential configuration, it gains 3.6 percentage points on MATH-500 and 0.8 points on MBPP+. The gains are larger in the mixture: MATH-500 accuracy rises from 60.6% to 65.8% (+5.2 points), and MBPP+ pass@1 rises from 47.4% to 50.3% (+2.9 points). Thus, the improvement observed with sequential collaboration also holds when a summarizer combines specialist outputs.

MethodSequential (Light) MATH-500Sequential (Light) MBPP+Mixture MATH-500Mixture MBPP+
RecursiveMAS71.432.160.647.4
ConvRSI75.032.965.850.3

Table 4. MATH-500 accuracy and MBPP+ pass@1 (%) by collaboration pattern. Bold marks the higher score in each column.

Comparison with Alternative Architectures

We compare ConvRSI with three alternative approaches to self-improvement. ModularRSI [17] uses successful and failed execution trajectories to improve individual modules of an agent’s harness, such as tool use and context management. Hermes+ [19] retains and updates memories and procedural skills for reuse on later tasks. MASS [8] searches over multi-agent workflows and fine-tunes its model on trajectories generated by those workflows. We also include Recursive-TextMAS [26] as a text-based comparison within the Sequential-Light configuration.

Table 5 shows that ConvRSI achieves the highest scores among the configurations evaluated with Qwen solvers, reaching 75.0% accuracy on MATH-500 and 32.9% pass@1 on MBPP+. The closest comparison is Recursive-TextMAS: with the same Sequential-Light team and three recursion rounds, ConvRSI gains 5.4 percentage points on MATH-500 and 3.8 points on MBPP+. MASS also improves from Level-0 to Level-1 on both benchmarks, gaining 5.9 and 5.2 points, respectively. At Level-1, it trails ConvRSI by 6.3 points on MATH-500 and 4.2 points on MBPP+.

MethodSolver or agent configurationMATH-500 accuracy (%)MBPP+ pass@1 (%)
Modular harness optimization
ModularRSIQwen3.5-4B67.132.1
Persistent memory and skills
Hermes+Sequential-Light solver64.628.6
Hermes+Qwen3.5-4B67.227.3
Multi-agent workflow optimization and self-training
MASS (Level-0)Qwen2.5-Math-1.5B-Instruct62.823.5
MASS (Level-1)Qwen2.5-Math-1.5B-Instruct68.728.7
Sequential multi-agent collaboration
Recursive-TextMAS (r=3r = 3)Sequential-Light team69.629.1
ConvRSI (r=3r = 3)Sequential-Light team75.032.9

Table 5. Comparison on mathematical reasoning and code generation, grouped by method family. The second column identifies the solver backbone or agent configuration used in our experiments. Bold marks the highest score in each benchmark column.

Efficiency Analysis

Performance at a comparable runtime. Figure 3 shows how much additional time each method spends as recursion depth increases and how its score changes. On MATH-500, three-round ConvRSI reaches 75.0% accuracy in 1,459 s. This is 4.9 percentage points above one-round RecursiveMAS (70.1%) for only 50 s of additional runtime over the full benchmark. On MBPP+, three-round ConvRSI reaches 32.9% pass@1 in 695 s, finishing sooner than either one-round baseline: RecursiveMAS reaches 29.1% in 776 s and Recursive-TextMAS reaches 30.4% in 1,489 s.

Figure 3. Performance versus total benchmark runtime. Along each line, points from left to right denote recursion depths r=1,2,3r = 1, 2, 3, with a filled marker at r=3r = 3. Points higher and further to the left indicate higher scores and shorter runtimes.

How inference cost grows with depth. Figure 4 compares each method with its own one-round configuration. On MATH-500, increasing the depth from one to three rounds raises the runtime of ConvRSI by 25.6%, compared with 88.6% for RecursiveMAS and 109.4% for Recursive-TextMAS. On MBPP+, the relative runtime increases for ConvRSI and RecursiveMAS are nearly identical (61.3% and 61.0%), but ConvRSI starts from a shorter one-round runtime and remains faster at three rounds. Generated-token counts change little for ConvRSI across these depths (−2.3% on MATH-500 and +4.5% on MBPP+), whereas they more than double for Recursive-TextMAS on both benchmarks.

Figure 4. Change in total runtime and mean generated tokens per problem from r=1r = 1 to r=3r = 3. Each percentage is relative to the same method’s one-round value on the same benchmark.

Conclusion

We presented ConvRSI, a framework that restructures multi-agent self-improvement through coupled intra-agent and inter-agent convolution. By jointly refining agent features and aggregating messages across a collaboration graph, ConvRSI supports individual refinement and collective evolution in latent space. Its matrix-based operations expose opportunities for parallel computation while accommodating different multi-agent collaboration patterns. Experiments show that ConvRSI improves task performance while reducing computational costs and latency across different multi-agent collaboration patterns. Future work will explore more diverse agent collaboration patterns and extend ConvRSI to large-scale agent swarms.

Author List

Core Contributors. Zheng Wang, Yuang Liu, Sachith Abeywickrama, Yangkai Ding, Tao Yu, Xinyu Zhang, Hongbo Wang, Qi Ye, Xuefeng Jin, Zhangchun Zhao

References

  1. [1]Yixing Chen, Yiding Wang, Siqi Zhu, Weixian Xu, Haofei Yu, Tao Feng, Muhan Zhang, Mostofa Patwary, and Jiaxuan You. Multi-agent evolve: Llm self-improve through co-evolution. In Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing, pages 39563–39593, 2026.arxiv.org/abs/2510.23595
  2. [2]Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. The llama 3 herd of models. arXiv preprint arXiv:2407.21783, 2024.arxiv.org/abs/2407.21783
  3. [3]HuggingFaceH4. Math-500 dataset. https://huggingface.co/datasets/HuggingFaceH4/MATH-500, 2024.
  4. [4]Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, et al. Qwen2.5-coder technical report. arXiv preprint arXiv:2409.12186, 2024.arxiv.org/abs/2409.12186
  5. [5]Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017. URL https://arxiv.org/abs/1609.02907.
  6. [6]Yanis Labrak, Adrien Bazoge, Emmanuel Morin, Pierre-Antoine Gourraud, Mickael Rouvier, and Richard Dufour. Biomistral: A collection of open-source pretrained large language models for medical domains. In Findings of the association for computational linguistics: acl 2024, pages 5848–5864, 2024.
  7. [7]Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. URL https://bottou.org/papers/lecun-98h.
  8. [8]Hyunin Lee, Jinglue Xu, Jeffrey Seely, Donghyun Lee, Somyeah Sojoudi, Matei Zaharia, and Yujin Tang. Recursive self-improvement through multi-agent self-supervision, 2026. URL https://arxiv.org/abs/2610.12176.
  9. [9]Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s verify step by step. In The Twelfth International Conference on Learning Representations, 2024. URL https://openreview.net/forum?id=v8L0pN6E0i.arxiv.org/abs/2305.20050
  10. [10]Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. Is your code generated by ChatGPT really correct? rigorous evaluation of large language models for code generation. In Advances in Neural Information Processing Systems, volume 36, pages 21558–21572, 2023. doi: 10.52202/075280-0943. URL https://proceedings.neurips.cc/paper_files/paper/2023/hash/43e9d647ccd3e4b7b5baab53f0368686-Abstract.html.DOI
  11. [11]Sumeet Ramesh Motwani, Chandler Smith, Rocktim Jyoti Das, Rafael Rafailov, Ivan Laptev, Philip Torr, Fabio Pizzati, Ronald Clark, and Christian Schroeder de Witt. MALT: Improving reasoning with multi-agent LLM training. In Second Conference on Language Modeling, 2025. URL https://openreview.net/forum?id=jXP9bgFack.
  12. [12]Chanwoo Park, Seungju Han, Xingzhi Guo, Asuman Ozdaglar, Kaiqing Zhang, and Joo-Kyung Kim. MAPoRL2: Multi-agent post-co-training for collaborative large language models with reinforcement learning. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 30215–30248. Association for Computational Linguistics, 2025. doi: 10.18653/v1/2025.acl-long.1459. URL https://aclanthology.org/2025.acl-long.1459/.
  13. [13]Andries Petrus Smit, Nathan Grinsztajn, Paul Duckworth, Thomas D. Barrett, and Arnu Pretorius. Should we be going MAD? A look at multi-agent debate strategies for LLMs. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pages 45883–45905. PMLR, 2024. URL https://proceedings.mlr.press/v235/smit24a.html.arxiv.org/abs/2311.17371
  14. [14]Zihan Tan, Leixin Sun, Zitong Shi, Yitao Liu, Jiajun Wu, Nathaniel Brooks, Jiaru Qian, Xiaoran Shang, Suyuan Huang, Yi Ding, et al. Metarsi/rsi2: A meta-recursive self-improving system for recursive self-improving systems themselves. arXiv preprint arXiv:2609.06396, 2026.arxiv.org/abs/2609.06396
  15. [15]Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, 2017. URL https://arxiv.org/abs/1706.03762.
  16. [16]Qibin Wang, Pu Zhao, Shaohan Huang, Fangkai Yang, Lu Wang, Furu Wei, Qingwei Lin, Saravan Rajmohan, and Dongmei Zhang. Learning to refine: Self-refinement of parallel reasoning in llms. In Findings of the Association for Computational Linguistics: ACL 2026, pages 25904–25921, 2026.arxiv.org/abs/2509.00084
  17. [17]Siwei Wu, Jincheng Ren, Yizhi Li, Haau-Sing Li, Chengran Yang, Xudong Ma, Yuxuan Zhang, Weicheng Gu, Jian Yang, Riza Batista-Navarro, Chuanyi Zhang, Xianglong Liu, Ming Zhou, Bryan Dai, and Chenghua Lin. Modularrsi: Modular and generalizable recursive harness self-improvement. arXiv preprint arXiv:2609.14857, 2026.arxiv.org/abs/2609.14857
  18. [18]Florian Valentin Wunderlich, Lars Benedikt Kaesberg, Jan Philip Wahle, Terry Ruas, and Bela Gipp. Multi-agent reasoning improves compute efficiency: Pareto-optimal test-time scaling. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 4: Student Research Workshop), pages 1–14. Association for Computational Linguistics, 2026. doi: 10.18653/v1/2026.acl-srw.1. URL https://aclanthology.org/2026.acl-srw.1/.DOI
  19. [19]Shuhan Xue, Zixin Ding, Yichen Shen, Yinjie Wang, Zhenfei Yin, Yingcheng Wu, Yuxin Chen, Mengdi Wang, and Ling Yang. Past-bench: Benchmarking the foundations of recursive self-improvement in personal agents. arXiv preprint arXiv:2608.04003, 2026.arxiv.org/abs/2608.04003
  20. [20]An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chenggen Huang, Chenxu Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388, 2025a.arxiv.org/abs/2505.09388
  21. [21]Qwen: An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. Qwen2.5 technical report, 2025b. URL https://arxiv.org/abs/2412.15115.
  22. [22]Zhaochen Yu, Yingcheng Wu, Zhenfei Yin, Kaiyuan Chen, Zhe Zhao, Mengdi Wang, Shuicheng Yan, and Ling Yang. Recursive experiential-working memory evolution for long-horizon agent harnesses. arXiv preprint arXiv:2608.24876, 2026.arxiv.org/abs/2608.24876
  23. [23]Siyu Yuan, Kaitao Song, Jiangjie Chen, Xu Tan, Dongsheng Li, and Deqing Yang. Evoagent: Towards automatic multi-agent generation via evolutionary algorithms. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 6192–6217, 2025.arxiv.org/abs/2406.14228
  24. [24]Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, et al. Aflow: Automating agentic workflow generation. In International Conference on Learning Representations, volume 2025, pages 34040–34077, 2025.arxiv.org/abs/2410.10762
  25. [25]Tong Zheng, Xidong Wu, Zheng Zhang, Zhankui He, Chaoyi Zhang, Benjamin Coleman, Ruoqiao Wei, Di Bai, Haolin Liu, Rui Liu, et al. Dream-rsi: Recursive self-improvement through evolving worlds. arXiv preprint arXiv:2609.14858, 2026.arxiv.org/abs/2609.14858
  26. [26]Jiaru Zou, Rui Pan, Ruizhong Qiu, Pan Lu, Shizhe Diao, Jindong Jiang, Hanghang Tong, Tong Zhang, Markus J. Buehler, Jingrui He, and James Zou. Recursive multi-agent systems. In The Fortieth Annual Conference on Neural Information Processing Systems, 2026. URL https://openreview.net/forum?id=MLOKFwGcPG.arxiv.org/abs/2604.25917

Paper details

vlnc:W_n6s2xjpt
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents