If AI agents on a team randomly swapped memories with each other, would they eventually land on a smarter shared strategy?
Can stochastic memory movement converge to better team strategies?
This explores whether randomly passing or shuffling memories between agents in a team could, over repeated rounds, settle into a better shared strategy.
This explores whether randomly passing or shuffling memories between agents in a team could, over repeated rounds, settle into a better shared strategy. The corpus has no study of random memory movement itself, so it can't say yes or no. What it does have is evidence on the ingredients: memory as a way to learn, randomness as a source of useful variety, and what goes wrong when information spreads through a team unchecked.
Memory is a real learning channel. Can agents learn continuously from experience without updating weights? shows an agent improving its policy entirely through memory operations, with no weight updates. Can agents learn from failure without updating their weights? does the same with written self-diagnoses, and Can agents learn new skills without forgetting old ones? shows a library of stored skills compounding without forgetting. If memory can carry learning for one agent, moving it between agents is a plausible way to spread learning through a team. The corpus stops short of showing that it does.
Variety can help, but it doesn't help on its own. Can agents learn cooperation by adapting to diverse partners? found that agents trained against many different partners drift toward cooperation, because each one is exposed to being exploited and has to adapt. That is the best case for randomness: unpredictable encounters push a group toward a shared strategy. Does cognitive diversity alone improve multi-agent ideation quality? gives the caution. Diverse teams without real expertise did worse than one competent agent, because stimulation without substance caused process losses. Shuffling memories only pays off if the memories being shuffled are good.
The main risk to convergence is that bad memories spread as easily as good ones. In Why do multi-agent systems fail to coordinate at scale?, agents accepted neighbours' information without checking it, so errors propagated, and coordination got worse as the network grew. Does one misaligned agent harm a team in adversarial settings? shows that one misaligned agent hurts a team by exploiting the trust among allies. A corrupted memory moving through a team would exploit the same trust, and random movement gives no protection against it.
So convergence would need something that filters what moves. The corpus has a few candidates. Should successful and failed episodes be processed differently? keeps successes as concrete demonstrations and turns failures into abstracted lessons. Can agents learn from failure without updating their weights? finds that a clear success-or-failure signal keeps agents from rationalizing. Can multi-agent teams automatically remove their weakest members? drops team members that add nothing, which applies selection pressure at the level of the team. What gets passed around also matters. Can agents compress their own memory without losing critical details? and Can agents reconstruct memory on demand instead of retrieving it? suggest that structured or reconstructed memory holds up better than raw dumps. The motivation for a team in the first place is in Do single agents always hit organizational limits?: some tasks exceed what any single agent loop can organize. The open question is whether random memory movement plus a verification filter beats deliberate routing, and no note in the corpus tests that.
Sources 12 notes
AgentFly formalizes agent learning as a Memory-augmented MDP with three memory modules (case, subtask, tool) that enable credit assignment and policy improvement entirely through memory operations. The approach achieved 87.88% on GAIA validation without modifying LLM parameters.
Reflexion demonstrates that unambiguous environmental feedback (success/failure) enables agents to write useful self-diagnoses and improve across episodes without parameter updates. The binary signal prevents rationalization, and keeping reflections uncompressed preserves their usability.
VOYAGER demonstrates that storing executable skills in an embedding-indexed library and composing complex skills from simpler ones allows agents to learn continuously while avoiding the forgetting that occurs with weight-update-based methods. Environmental feedback refines skills while an automatic curriculum drives continual exploration.
Sequence model agents trained against diverse co-players develop in-context best-response strategies that naturally resolve into cooperation. Mutual vulnerability to exploitation creates pressure that drives cooperative mutual adaptation without hardcoded assumptions or timescale separation.
Multi-agent teams substantially outperform solo ideation, but only when members possess genuine senior knowledge. Diverse teams without expertise underperform even a single competent agent, because cognitive stimulation without expertise triggers process losses instead of insight.
Show all 12 sources
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Research shows that shifting one agent's objective worsens team performance in inherently adversarial games, an effect amplified by asymmetric information and specialized roles. The harm survives because misalignment exploits trust among allied agents rather than violating competitive expectations.
SkillRL demonstrates that treating successful episodes as concrete demonstrations and failures as abstracted lessons achieves state-of-the-art performance on complex tasks while using substantially less context than uniform approaches. The asymmetry mirrors human expert reasoning and avoids the degradation seen in uniform consolidation methods.
DyLAN's three-step importance scoring mechanism (propagation, aggregation, selection) quantifies individual agent contributions and automatically removes uninformative agents during inference, optimizing team composition without task-specific tuning.
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Useful Memories Become Faulty When Continuously Updated by LLMs
- Towards a Science of Scaling Agent Systems
- AgentFly: Fine-tuning LLM Agents without Fine-tuning LLMs
- SkillRL: Evolving Agents via Recursive Skill-Augmented Reinforcement Learning
- ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory
- Know It, Act on It: Investigating Memory Utilization in LLM Personalization
- SkillClaw: Let Skills Evolve Collectively with Agentic Evolver
- Learning "Partner-Aware" Collaborators in Multi-Party Collaboration