ConvRSI introduces parallel self‑improvement for multi‑agent systems
A new framework called ConvRSI parallelizes multi‑agent self‑improvement using convolution.
Source: Grafy Research LabMulti‑agent self‑improvement has traditionally relied on sequential updating, a bottleneck that can amplify mistakes and inflate compute budgets. A new pre‑print from the Grafy Research Lab, titled From Recursion to Convolution: Parallel Self‑Improvement for Multi‑Agent Systems (arXiv 2611.20891, 2026‑11‑17), proposes ConvRSI – a convolution‑based framework that enables agents to improve together in parallel. The paper argues that parallelism, coupled with joint feature refinement, can unlock more reliable and scalable coordination among interacting agents.
What is ConvRSI and why does it matter?
ConvRSI stands for Convolutional Recursive Self‑Improvement. According to the authors, the framework replaces the classic recursive loop—where one agent refines itself, then passes its output to the next—with a convolution operation that simultaneously updates a set of related features across multiple agents. By doing so, the approach tackles two well‑known pain points:
- Error propagation – sequential pipelines let a mistake in an early agent cascade through later stages.
- Limited parallelism – each refinement round must wait for the previous one, inflating latency and compute cost.
The authors contend that a convolution‑style update respects the dependencies among agents while allowing all of them to evolve together, a shift that could change how large‑scale AI ecosystems are built.
How does ConvRSI parallelize multi‑agent self‑improvement?
At its core, ConvRSI treats the collection of agents as a multi‑dimensional tensor. A convolution kernel slides over this tensor, aggregating information from neighboring agents and from the internal features of each agent. The operation produces a new tensor that represents the jointly refined state of the system. Because convolution is inherently parallelizable on modern hardware (GPUs, TPUs, and even specialized AI accelerators), the entire update can be executed in a single compute step rather than a cascade of sequential calls.
The paper describes the process in three stages:
- Feature stacking – each agent’s relevant representations (e.g., policy vectors, knowledge embeddings) are stacked along a shared dimension.
- Kernel application – a learned kernel performs weighted sums across both intra‑agent and inter‑agent axes, yielding a blended representation .
- Projection – the blended tensor is projected back into each agent’s native format, completing one self‑improvement iteration.
Because the kernel is applied uniformly, the same computational graph can be reused across many iterations, dramatically reducing the overhead of model loading and data movement.
What are intra‑agent and inter‑agent convolutions?
ConvRSI distinguishes two complementary convolutional pathways:
- Intra‑agent convolution focuses on refining a single agent’s multiple internal features together. For example, a language model might jointly adjust its token‑level attention weights, memory slots, and policy logits, ensuring that changes remain internally consistent.
- Inter‑agent convolution captures cross‑agent dependencies. When agents collaborate—such as a planning module sharing intent with a perception module—the kernel blends their representations, allowing the system to discover coordination patterns that would be invisible if each agent were updated in isolation.
The authors report that coupling these two pathways yields a richer, more coherent improvement step than either alone, because agents can both align their internal structures and synchronize with one another.
Potential benefits and trade‑offs for developers and researchers
Benefits
- Reduced latency – Parallel updates cut the number of sequential passes, which can be especially valuable in real‑time or interactive applications.
- Lower compute cost – A single convolution operation can be amortized across many agents, avoiding repeated model invocations.
- Better error resilience – By aggregating information from multiple sources, the framework can dampen outlier predictions that would otherwise dominate a chain.
- Explicit coordination – The inter‑agent kernel provides a learnable mechanism for agents to negotiate shared goals, a feature that is difficult to engineer manually.
Trade‑offs
- Kernel design complexity – Choosing the right kernel size and stride requires understanding the topology of agent interactions, which may add a layer of hyper‑parameter tuning.
- Memory footprint – Stacking many high‑dimensional feature maps can increase RAM usage, especially for large fleets of agents.
- Interpretability – Convolution blends signals in a way that can be harder to trace back to individual agents, potentially complicating debugging.
Researchers interested in scaling multi‑agent systems will need to weigh these considerations against the gains in speed and robustness.
Applying ConvRSI concepts with Graf Grafy tools
While ConvRSI is presented as a research framework, its core ideas map naturally onto several Grafy applications:
- Grafy Reader – Use the Reader app to ingest the full pre‑print, ask follow‑up questions, and extract the exact mathematical formulation of the convolution kernels. The interactive PDF interface makes it easy to jump between sections and verify equations.
- Grafy Graph – The Graph app can visualize the flow of features before and after a convolutional update. By constructing a branching graph of prompts that represent intra‑agent and inter‑agent states, creators can experiment with different kernel configurations without leaving the workspace.
- Grafy Code – For developers who want to prototype ConvRSI, the Code studio provides an AI‑assisted coding environment that can generate PyTorch or JAX implementations of the described convolution pipeline, complete with unit‑test scaffolding.
A practical workflow might look like this: load the paper in Reader, extract the kernel definition, sketch a prompt‑graph in Graph that models the agents’ feature tensors, then switch to Code to turn the graph into runnable code. This end‑to‑end loop lets researchers iterate quickly on design choices while keeping the underlying theory in view.
Outlook and next steps
ConvRSI opens a new avenue for scaling collaborative AI, but the framework is still at the prototype stage. The authors plan to evaluate the approach on benchmark suites for multi‑agent reinforcement learning and on real‑world coordination tasks such as distributed robotics and autonomous traffic management. Future work will likely explore adaptive kernels that change shape based on the current state of the system, as well as hybrid schemes that blend convolutional updates with occasional sequential fine‑tuning.
For practitioners, the immediate takeaway is that parallel convolution offers a concrete method to reduce the latency of multi‑agent pipelines without sacrificing the nuanced dependencies that make coordination valuable. By leveraging Grafy’s multimodal workspace—especially Reader, Graph, and Code—teams can experiment with ConvRSI ideas today, even before the framework is packaged into a library.
Source: https://arxiv.org/abs/2611.20891
To explore this yourself, open Reader: read, search and question PDFs and papers with AI.


