The Architecture of Collective Cognition: Transactive, Hierarchical, and Crawlable Memory in Multi-Agent Systems

Full report

On this page

The Paradigm Shift in Autonomous Agent Memory

The rapid proliferation and scaling of large language models (LLMs) has catalyzed a fundamental transition in artificial intelligence research and deployment. The field is moving decisively from isolated, stateless text generators toward autonomous, long-horizon agents capable of perceiving dynamic environments, wielding external tools, and executing complex, multi-step workflows. As these capabilities evolve, the deployment architecture is undergoing a corresponding shift from single-agent paradigms to complex, coordinated multi-agent systems (MAS). However, this transition has exposed a critical structural bottleneck: the management of state, context, and accumulated experience over extended periods and across distributed cognitive nodes. In these advanced networks, memory is no longer an optional retrieval mechanism but the foundational infrastructure for collective cognition, enabling heterogeneous agents to coordinate, specialize, and evolve dynamically1. Early implementations of agentic memory relied heavily on naive Retrieval-Augmented Generation (RAG). Traditional RAG pipelines treat memory as a flat, unstructured vector store containing isolated text chunks. While functional for single-turn, stateless factual queries, this approach precipitates systemic, cascading failures when deployed in dynamic, multi-agent environments. The performance delta between an agent operating with robust, structured memory and one operating without it often exceeds the performance gap between entirely different foundational LLM backbones4. Furthermore, empirical evaluations conducted across large-scale agent configurations demonstrate that when agents are deployed in independent networks lacking shared, governed context infrastructure, errors cascade rapidly. Specifically, independent multi-agent systems have been shown to amplify errors by a factor of 17.2 compared to single-agent baselines, whereas centralized coordination with shared context architecture contains this amplification to a factor of 4.45. This discrepancy represents the severe computational and operational cost of context isolation at scale. To resolve these profound architectural limitations, the frontier of agentic design is coalescing around multi-agent transactive memory, hierarchical graph-based storage, active crawlable memory reconstruction, and automated summarization routines. By formalizing agent memory as a continuous Write-Manage-Read loop tightly coupled with a Partially Observable Markov Decision Process (POMDP), modern architectures map raw, noisy experiences into structured, highly semantic representations2. This comprehensive analysis explores these emerging architectures in detail. It examines how transactive memory enables population-level experience sharing, how hierarchical knowledge graphs solve the context dilution problem through multi-level summarization, how deep-search mechanisms actively reconstruct knowledge trajectories, and how strict, systemic governance protocols are required to prevent catastrophic data corruption in fleet-scale multi-agent deployments.

The Taxonomic Evolution and Topology of Agentic Memory

The transition to advanced MAS necessitates decomposing memory into distinct temporal scopes, cognitive functions, and representational substrates. Borrowing heavily from cognitive psychology and neuroscience, modern agentic memory systems categorize stored information to optimize both retention and highly targeted retrieval4. The temporal and cognitive scopes of agentic memory can be formally categorized into distinct functional layers that dictate how an agent perceives and retains environmental interactions. Working memory serves as the immediate context window, effectively functioning as the RAM of the agent. It holds the active conversation history, system prompts, and transient tool outputs4. Because working memory is strictly constrained by token limits, it requires aggressive context-resident compression to prevent summarization drift and attention dilution. Episodic memory operates as the sequential log of specific events, recording interaction trajectories, tool invocations, and specific environmental outcomes. This layer enables "mental time travel," allowing an agent to review past failures and successes to optimize future strategies4. Semantic memory serves as the abstracted, distilled knowledge base. It contains generalized facts, domain rules, and long-term user preferences, stripping away the transient temporal context of episodic events to form crystallized, reusable insights4. Finally, procedural memory functions as the repository of learned skills, subroutines, and successful execution patterns, dictating how an agent should approach a specific class of problems based on historical performance4. Recent frameworks, such as EvoMem, explicitly draw upon Baddeley’s multi-component theory of working memory. In these designs, memory is divided into Constraint Memory (CMem), which functions analogously to the phonological loop by maintaining stable, verbalized rules across queries, and Query-feedback Memory (QMem), which acts as a visuospatial sketchpad, accumulating intermediate outputs and error signals during iterative self-correction loops10.

Beyond the cognitive categorization of memory, the physical and logical topology of how memory is distributed across a multi-agent system dictates its scalability and operational efficiency. Agent architectures deploy memory across local, shared, or hybrid topologies3. In a strictly local topology, each agent maintains a private repository of episodic, procedural, and transactive memory, ensuring high security and zero cross-agent contamination, but severely limiting collective learning. In a shared topology, all agents write to and read from a centralized memory store (such as a blackboard architecture), maximizing knowledge dissemination but introducing massive governance and synchronization challenges. Advanced deployments typically utilize hybrid topologies, wherein agents maintain private episodic memory for raw, unverified operational logs, but push verified, generalized procedural strategies to a shared semantic graph accessible by the entire fleet3.

Multi-Agent Transactive Memory: Infrastructure for Population-Level Experience Reuse

In human organizational theory, transactive memory refers to the shared cognitive system by which groups collectively encode, store, and retrieve knowledge, relying heavily on the principle of knowing "who knows what" to efficiently distribute cognitive load3. Applied to LLM-based multi-agent systems, Multi-Agent Transactive Memory (MATM) represents a profound paradigm shift from individual, isolated experiential learning to highly efficient, population-level experience sharing. Traditionally, memory systems in AI operate under the assumption that experience data is reused exclusively by the specific agent that generated it. This design flaw results in widespread "architectural amnesia" across a distributed fleet. When newly instantiated agents are spun up to handle tasks, they are forced to repeatedly rediscover existing solutions in total isolation, consuming vast amounts of computational resources, API tokens, and time13. MATM resolves this inefficiency by treating memory as a shared, structurally governed resource that heterogeneous agents can both contribute to and query. Under the MATM framework, agents operate fluidly in dual roles within a sophisticated two-sided marketplace of procedural knowledge. During task execution, "producer agents" generate interaction artifacts—specifically, highly structured action-observation trajectories. These trajectories are not mere text logs; they encode rich procedural structures detailing the exact sequence of reasoning steps, tool invocations, and environmental feedback that resulted in a successful or failed outcome. These artifacts are dynamically contributed to the shared MATM repository12. Conversely, "consumer agents" facing novel or highly complex tasks query this repository to retrieve these historical trajectories, leveraging the collective experience of the fleet to guide their immediate decision-making processes. Agent-generated interaction trajectories are fundamentally atypical documents. They differ drastically from human-written prose and cannot be effectively indexed or retrieved using standard semantic embeddings designed for natural language12. MATM addresses this structural challenge by implementing a state-conditioned key-value indexing scheme. Rather than retrieving a past trajectory based solely on the semantic similarity of the original task instruction, consumer agents retrieve actionable guidance conditioned precisely on their current, localized interaction state. Mathematically, given a specific sliding window size [Figure omitted from source export], for each interaction step [Figure omitted from source export], the retrieval key is defined by the recent interaction history: [Figure omitted from source export] The associated value stored in the index is the subsequent segment of the trajectory (e.g., the sequence from [Figure omitted from source export] to [Figure omitted from source export]). This acts as a forward-looking behavioral document that the agent utilizes at inference time to determine its next optimal move12. When an agent encounters a specific state within an environment, the trajectory retriever forms a search query to pull candidate trajectory chunks from the shared repository. To optimize the relevance of these retrieved artifacts, dense retrieval mechanisms are typically cascaded with lightweight Learning-to-Rank (LTR) rerankers. This two-stage pipeline aligns the retrieved procedural artifacts with the specific preferences, tool access, and cognitive capabilities of the consumer agent12. Extensive empirical experiments in highly interactive simulated environments, such as ALFWorld and WebArena, demonstrate that the implementation of MATM significantly improves downstream task effectiveness, dramatically reduces the number of interaction steps required for task completion, and operates efficiently without requiring explicit synchronous inter-agent coordination or computationally expensive joint model training13.

Hierarchical RAG and Multi-Level Summarization Architectures

While MATM excels at the dissemination of procedural action trajectories, maintaining coherent, long-term semantic knowledge from external documents and conversational histories requires an entirely different structural approach. Standard, flat RAG pipelines embed all documents into a single, unstructured vector space. This erases critical conceptual boundaries, destroys hierarchical relationships, and routinely leads to the retrieval of contextually incorrect snippets, thereby driving up hallucination rates17. To enable agents to synthesize massive, disparate corpora, developers are increasingly turning to Hierarchical Retrieval-Augmented Generation (HRAG) and dynamic summarization architectures. Hierarchical RAG describes a paradigm where external knowledge sources are organized and accessed using multi-level, structured representations. Rather than processing independent document chunks, HRAG orchestrates context construction through multi-layer graphs, decision trees, and community clusters18. A premier example of this methodology is RAPTOR (Recursive Abstractive Processing for Tree-Organized Retrieval). RAPTOR utilizes a bottom-up indexing approach that segments documents into textual chunks, embeds them, clusters the embeddings using community detection algorithms, and then utilizes an LLM to generate highly synthesized abstractive summaries of each cluster19. This process is applied recursively, forming a hierarchical tree structure where leaf nodes are raw textual facts and root nodes are broad, thematic summaries of entire document corpora. By imposing this explicit hierarchy, HRAG allows multi-agent networks to perform dynamic, granularity-aware routing. When a user issues a broad, thematic query, the orchestrator agent traverses the upper layers of the RAPTOR tree, retrieving comprehensive summaries that immediately provide high-level context. When a query demands highly specific, granular facts, the agent traverses down to the leaf nodes. This drastically reduces retrieval noise, preserves semantic coherence, and minimizes the token consumption required for multi-hop reasoning tasks18.

This hierarchical summarization methodology has proven particularly revolutionary in the domain of automated literature synthesis and deep research. The SurveyG framework, for instance, utilizes a multi-agent architecture to construct comprehensive academic surveys by embedding research papers into a hierarchical citation graph. The graph is formally defined as [Figure omitted from source export], where nodes represent academic papers and edges capture both explicit citation dependencies and implicit semantic similarities derived from abstract embeddings20. Crucially, SurveyG organizes this graph into three distinct temporal and structural layers: the Foundation layer (seminal, high-impact works), the Development layer (incremental advances and methodological refinements), and the Frontier layer (emerging directions and novel applications). To generate a comprehensive survey, specialized agents perform horizontal summarization searches within specific layers using community detection algorithms (e.g., the Leiden algorithm) to identify coherent research sub-topics. Simultaneously, other agents execute vertical, depth-first traversals across the layers via weighted breadth-first search (WBFS) to trace the historical evolution of specific methodologies20. This orchestrated combination of horizontal clustering and vertical traversal allows the multi-agent system to generate highly structured, multi-aspect summaries that vastly outperform naive RAG concatenation, producing academic literature reviews that are rigorously faithful to the underlying knowledge taxonomy of the field.

Graph-Based Memory and the Decoupling of Episodic Consolidation

While HRAG excels at organizing static, external knowledge bases, managing the internal, continuously evolving memory of an autonomous agent operating over weeks or months requires specialized graph-based architectures. Standard stream-based memory systems that continuously append new conversational observations directly into a unified context are extremely vulnerable to interference from transient noise. The human brain manages this through the process of sleep-dependent memory consolidation, where temporary, labile memory traces are selectively rehearsed and integrated into long-term neocortical storage without overwriting critical prior knowledge24. Modern agentic memory architectures replicate this neuroscientific phenomenon by decoupling the encoding of memory from its long-term consolidation.

The GAM Framework: Buffering and Semantic Shifts

The Hierarchical Graph-based Agentic Memory (GAM) framework structurally mitigates memory interference by physically separating immediate conversational buffering from permanent knowledge integration25. In the GAM architecture, ongoing dialogues, transient tool interactions, and immediate sensory observations are isolated within local "Event Progression Graphs." This serves as a highly protective episodic buffering phase, capturing real-time dependencies and raw observational data without permanently polluting the agent's core semantic knowledge base. Information is only integrated into the global "Topic Associative Network" upon the detection of a concrete semantic shift20. By replacing arbitrary, fixed-time or fixed-token consolidation triggers with rigorous semantic divergence detection, GAM ensures that permanent memory updates occur strictly at semantically complete narrative boundaries. This design prevents the systemic "memory blindness" and hallucination loops that inevitably occur when fragmented, incomplete conversational thoughts are permanently indexed4. During the retrieval phase, GAM utilizes a Graph-Guided Multi-Factor Retrieval strategy, integrating temporal recency, semantic confidence scores, and role-based signals into a structured top-down traversal. This allows the agent to pull highly precise, granular episodic details that are securely grounded in overarching semantic themes, significantly outperforming state-of-the-art baselines in long-horizon reasoning accuracy and computational efficiency25.

Amory: Constructing the Narrative Memory

Cognitive science has long established that human recall does not function as a database of isolated, scattered facts; rather, humans recollect contextual information tied to specific, narrative-driven experiences8. The Amory framework translates this profound cognitive insight into a computational working memory architecture by actively constructing narrative structures during the agent's offline processing intervals27. Instead of treating memory formation as mere storage with basic redundancy checking, Amory performs a sophisticated, three-step active construction process. First, through episodic binding, raw conversational fragments and interaction logs are bound into coherent episodic narratives, strictly preserving temporal sequences and causal relationships. Second, through momentum-aware consolidation, these episodic memories are consolidated into structured plots and subplots. This consolidation is explicitly guided by "conversational momentum," which tracks the underlying trajectory and evolving intent of a user's interaction over time. Finally, through a process of semanticization, peripheral, context-independent facts are strategically stripped from the episodic narrative and formalized into a highly compressed semantic memory store8. At retrieval time, Amory fundamentally abandons superficial embedding similarity searches. Instead, it employs coherence-driven reasoning over these constructed narrative structures. This narrative-centric retrieval approach yields memory coverage that is vastly superior to standard embedding retrievers, particularly for complex, multi-hop queries where the required information is distributed across weeks of historical interactions8. By offloading the computationally intensive heavy lifting of narrative construction to offline processing intervals, Amory cuts real-time response latency by up to 50% while matching the reasoning performance of full-context, uncompressed baselines27.

Mitigating the Mega-Hub Effect with GAAMA

A pervasive, structural problem in dense knowledge graphs is the "mega-hub effect." When standard entities (such as a user's name, a primary company project, or a core software tool) are repeatedly referenced across thousands of interactions, they become connected to almost every memory node in the graph. When PageRank or standard spreading activation algorithms are applied during retrieval, the signal is massively diluted by these hubs, making precise, context-specific retrieval nearly impossible30. The GAAMA (Graph Augmented Associative Memory for Agents) architecture bypasses this critical failure mode by constructing a concept-mediated knowledge graph utilizing four distinct, strictly typed nodes: episodes, facts, reflections, and concepts. By routing retrieval traversals specifically through concept nodes utilizing an edge-type-aware Personalized PageRank (PPR) scoring function, GAAMA provides specific, cross-cutting traversal paths that surgically isolate specific contexts without getting trapped in dense entity hubs. Furthermore, GAAMA introduces a post-retrieval corrective layer—GRAFT (Graph Repair by Augmenting Facts & Topology)—which actively diagnoses retrieval failures and dynamically repairs the knowledge graph's topology on the fly, yielding continuous performance improvements as dialogue length increases30.

Deep Search and Crawlable Memory: Active Reconstruction

The traditional operating model for memory-augmented agents relies on a highly rigid "retrieve-then-reason" pipeline. In this sequential paradigm, the agent generates a query, the system retrieves a static block of text from the database, and the agent attempts to reason over the result. If the initial, single-shot retrieval misses the critical information, the downstream reasoning chain is permanently compromised. Advanced memory architectures are rapidly discarding this passive retrieval model in favor of active memory reconstruction, iterative deep search, and agentic MapReduce paradigms.

MRAgent and the Cue-Tag-Content Graph

Cognitive neuroscience conceptualizes human memory retrieval not as a passive read-out of a hard drive, but as an active, associative reconstruction process initiated by contextual cues31. The Memory Reasoning Architecture for LLM Agents (MRAgent) successfully implements this paradigm by integrating the LLM's core reasoning loop directly into the memory access layer. MRAgent represents the agent's memory as a sophisticated Cue-Tag-Content graph. In this unique structure, associative "tags" serve as semantic bridges that connect fine-grained "cues" to highly detailed memory "contents"32. Rather than executing a blind, single-shot vector retrieval, the LLM iteratively traverses this associative graph. The tags explicitly expose potential retrieval directions to the agent, allowing it to evaluate the logical relevance of a pathway before committing computational resources to an expensive read of the underlying content. As the agent gathers intermediate evidence, it dynamically prunes irrelevant branches and iteratively updates its search strategy based on the highest potential information gain. This active reconstruction process completely prevents the combinatorial explosion typically associated with unconstrained graph expansion, while simultaneously empowering the agent to synthesize deeply buried, multi-hop insights that passive retrieval policies routinely miss34.

A-MapReduce for Wide Search Execution

While frameworks like MRAgent excel at targeted, highly vertical deep reasoning, tasks that require exhaustive, breadth-oriented information gathering (wide search) completely overwhelm traditional sequential agent frameworks. When tasked with synthesizing thousands of documents, standard agents become trapped in expansive search loops and suffer from severe long-horizon execution degradation. To address large-scale, breadth-oriented retrieval, the A-MapReduce (Agentic MapReduce) framework recasts wide search as a distributed, horizontally structured computation problem36. Inspired by the highly successful MapReduce processing paradigms pioneered in database systems, A-MapReduce leverages a multi-agent network to execute the parallel processing of massive retrieval targets. The framework utilizes a top-level orchestrator to break a complex, wide-search query into an explicit MapReduce decision matrix. During the execution of the "Map" phase, the task is decomposed into atomic retrieval sub-tasks, which are executed simultaneously by dozens of specialized worker agents in parallel37. The map function is referentially transparent, and the outputs are strictly commutative and associative, ensuring that intermediate results can be safely cached and ordered dynamically38. During the "Reduce" phase, the disparate findings from the mapping agents are aggressively aggregated, deduplicated, and synthesized into a unified, coherent output37. Crucially, A-MapReduce utilizes an experiential memory module to continuously evolve its query-conditioned task allocation over time, learning which decomposition strategies yield the best results for specific types of queries. Extensive empirical benchmarking demonstrates that A-MapReduce achieves state-of-the-art performance on wide-search benchmarks, delivering absolute improvements in Item-level F1 scores of 5.64% to 27.62%, while simultaneously reducing computational runtime by 45.8% and saving an average of $1.10 in API costs per task36.

Fleet-Memory Governance: Scope, Provenance, and Security Protocols

As multi-agent systems transition from experimental sandboxes into production enterprise environments, the nature of memory shifts drastically. It ceases to be merely an optimization problem for information retrieval and becomes a highly sensitive, governed distributed-systems problem39. When multiple heterogeneous agents continuously read and write to a shared substrate, the entire system is exposed to race conditions, severe security breaches, and insidious data corruption.

The MemClaw Framework and the Four Failure Modes

To systematically manage these profound complexities, memory architectures must formally define the "fleet-memory problem." The MemClaw framework represents a milestone in this effort, mathematically defining a shared multi-agent memory system as a quintuple: [Figure omitted from source export]. In this formulation, [Figure omitted from source export] represents the specific agents in the fleet, [Figure omitted from source export] represents the shared memory substrate, [Figure omitted from source export] defines the governance and policy layer, [Figure omitted from source export] denotes the critical provenance metadata, and [Figure omitted from source export] establishes the temporal ordering and supersession semantics required for state transitions41. By rigorously treating shared memory as governed operational state rather than a passive archive, systems engineers have identified four catastrophic failure modes that are entirely unique to multi-agent environments39:

To counteract these systemic failures, the MemClaw framework enforces strict, systems-level computing primitives. Scoped retrieval ensures that a critical mathematical invariant, [Figure omitted from source export], is perpetually maintained: an agent is only permitted to retrieve a memory unit if the retrieval operation definitively satisfies the Boolean policy constraints attached to that specific row of data41. Furthermore, temporal supersession replaces traditional, immutable append-only logs with active, manageable state transitions. When a contradiction is detected by the system, older records are not deleted; they are marked as outdated and linked to the current, validated version via structural supersession pointers. However, live, empirical evaluations of these systems using harnesses like ArgusFleet reveal the immense, practical difficulty of enforcing continuous governance at scale. In baseline production tests, the MemClaw service initially exhibited a staggering 43.9% search leak rate. This was traced to a bypassed scope check on a direct GET-by-id request pathway, underscoring the reality that elegant conceptual governance designs frequently fail at the implementation pipeline level43. Furthermore, pipeline-ordering conflicts routinely arise in these highly parallel systems; for instance, a synchronous near-duplicate filtering gate may mistakenly reject a contradictory write prior to the asynchronous contradiction detector properly logging the state change and triggering the necessary supersession protocols41.

Red-Teaming and Security Vulnerabilities (FragFuse and ARMs)

The introduction of long-term memory into LLM agents creates entirely novel, highly sophisticated attack surfaces. Traditional safety alignment and access-control mechanisms are designed to evaluate and block policy-violating requests within a single, contiguous prompt. However, malicious actors can exploit the memory substrate to bypass these controls. The FragFuse attack methodology demonstrates how prohibited content can be systematically fragmented across multiple, seemingly benign interactions. These fragmented pieces are stored independently in the agent's long-term memory in a form that easily evades initial access-control filters. Subsequently, the attacker utilizes marker carrier queries to force the memory retrieval system to reconstruct the prohibited content dynamically during inference, entirely bypassing the safety mechanisms because the explicit violation never appeared in the final user query45. To counter these emerging threats, researchers are deploying advanced red-teaming agents to proactively probe memory vulnerabilities. Frameworks such as RedCodeAgent utilize adaptive memory modules to dynamically select and combine jailbreak tools tailored to specific queries, systematically identifying vulnerabilities in code-generation agents47. Similarly, the ARMs (Adaptive Red-teaming Multimodal) framework utilizes an agentic, reasoning-enhanced multi-step orchestration pipeline to optimize diverse attack strategies against Vision-Language Models (VLMs). By utilizing a layered memory system with an epsilon-greedy attack algorithm, ARMs generates highly diverse, sophisticated red-teaming instances that successfully elicit harmful outputs from constitutionally aligned models, revealing the critical need for memory-aware safety alignment48.

Credibility Assignment, Consensus, and the Self-Confirmation Trap

The vulnerability of shared multi-agent memory is perhaps most apparent when examining the internal mechanics of data corruption and hallucination contagion. When an autonomous agent executes a flawed trajectory but internally evaluates it as a success, that hallucination is formally written to the shared memory substrate. Subsequent agents traversing the graph or querying the database retrieve this trajectory and inherit the flawed reasoning, assuming it to be verified institutional knowledge. This devastating feedback loop is formally termed the "Self-Confirmation Trap"50. Rigorous sensitivity analyses reveal that injecting merely 10% erroneous memories into an agent's baseline context causes a massive 5.3 percentage point drop in task accuracy. This is not a static failure; it is a compounding error that actively degrades the overall system's performance over successive training epochs, as the single-agent baseline stagnates or declines while the contaminated memory pool grows50. To mitigate this catastrophic failure mode, advanced frameworks are implementing multi-agent consensus verification protocols. The Execute-Distill-Verify (EDV) framework introduces a strict structural fix. Instead of allowing executing agents to write directly to shared memory, EDV enforces a tripartite separation of powers. In the Execute stage, multiple heterogeneous agents tackle the task in parallel. In the Distill stage, a designated third-party agent—one that was entirely excluded from the execution phase to break the self-referential loop—drafts candidate experiences based on the parallel outputs. Finally, in the Verify stage, the entire execution group votes on the distillation. Unanimous approval writes the verified experience to the shared, global memory; partial approval limits it to the approving agent's private, local memory; and outright rejection purges the artifact entirely50. By interposing this asynchronous, democratic verification layer before memory commits, EDV successfully curtails the systemic contamination that plagues naive shared substrates, improving the Pass@1 rate on the complex [Figure omitted from source export]\-bench from 83.5% to 86.6%50. Similarly, Stochastic Interaction Architectures (SIA) tackle the problem of agent persuasion and debate domination. In open debate formats, highly persuasive but factually incorrect agents can push a team toward a false consensus. SIA implements Credibility Assignment mechanisms, distinguishing an agent's sheer volume of contribution from its actual factual credibility. Utilizing Shapley values or LLM-as-a-Judge methodologies, the system actively weights the influence of agents based on their historical accuracy and their impact on peer beliefs, ensuring that highly communicative but historically inaccurate agents do not corrupt the shared memory pool51.

Infrastructure, Scaling Laws, and Cost Optimization

As organizations attempt to scale MAS capabilities, a strategic tension inevitably arises between scaling horizontally (adding more specialized agents to a network) and scaling temporally (enhancing the lifelong learning and memory capabilities of existing agents). The LLMA-Mem framework explores this exact intersection, defining a conceptual scaling space that jointly evaluates network team size against memory depth. Empirical evaluations conducted across complex coding, research, and database environments reveal a highly counterintuitive, non-monotonic scaling landscape52. Simply increasing the raw number of agents in a network does not linearly correlate with better long-term performance. In fact, due to the quadratic escalation of communication overhead, the heightened risk of state fragmentation, and the sheer token cost of passing context between nodes, massive agent teams with poor memory infrastructure rapidly degrade in both efficiency and accuracy52. Conversely, smaller, tightly integrated agent teams equipped with advanced memory systems—specifically those that clearly separate episodic task logs, procedural strategy extraction, and transactive capability tracking—consistently outperform larger teams. By effectively retaining and reusing past experiences, a small team utilizing the LLMA-Mem framework not only achieves superior long-horizon performance but also dramatically reduces API token consumption by margins ranging from 9.4% to 71.7%52. This highlights a fundamental, foundational principle of MAS architecture: highly structured memory design is a direct economic and computational substitute for sheer model volume or agent headcount. Optimized experience reuse is unequivocally the most practical and sustainable path toward scalable, cost-efficient agentic ecosystems. At the physical infrastructure level, maintaining these expansive, individualized memory states for hundreds of agents creates massive GPU memory pressure. Each agent maintains private GPU-resident states, including specific model weights, prefix caches, and adapters. To handle this, systems like ScaleSim are being deployed for memory-efficient LLM serving. ScaleSim leverages the sparse activation patterns and estimable invocation order of multi-agent simulations to enable proactive prefetching and priority-based eviction of memory states, achieving significant speedups over standard serving engines like SGLang while preventing Out-of-Memory (OOM) crashes in massive simulations57. Similar large-scale, emergent behavior simulations are being heavily studied using frameworks like NetLogo, where LLMs serve as mutation operators in Genetic Programming (GP) to evolve complex, multi-agent behaviors, highlighting the absolute necessity of robust, efficient memory management for the future of agentic research58.

Conclusion

The architectural evolution of memory in large language model multi-agent systems has decisively moved beyond the simplistic paradigm of flat, localized text retrieval. As autonomous agents are tasked with increasingly complex, long-horizon workflows across diverse, dynamic environments, their operational effectiveness is bounded not merely by their internal parametric knowledge or reasoning capabilities, but by the structural integrity, governability, and specific topology of their external memory substrates. The transition toward Multi-Agent Transactive Memory establishes a highly collaborative, economically efficient ecosystem where procedural knowledge and execution trajectories are treated as communal assets, drastically reducing the computational redundancy of isolated learning. Simultaneously, the deployment of Hierarchical Graph-based Agentic Memory (GAM) and narrative-driven frameworks (Amory) successfully resolves the pervasive issue of context dilution by intelligently decoupling transient sensory buffering from long-term semantic consolidation. Furthermore, frameworks like MRAgent and A-MapReduce fundamentally redefine information retrieval as an active, crawlable, and highly parallelized reconstruction process, enabling agents to execute deep, multi-hop reasoning over massive datasets without succumbing to combinatorial explosion or token exhaustion. However, the realization and secure deployment of these advanced cognitive architectures are entirely contingent on the rigorous application of distributed-systems governance and consensus protocols. As demonstrated by the severe fleet-memory failure modes identified in the MemClaw framework, the insidious fragmentation attacks outlined in FragFuse, and the contamination vulnerabilities successfully addressed by the EDV framework, uncontrolled shared memory inevitably leads to unauthorized leakage, contradiction persistence, and compounding hallucination loops. Ultimately, the most successful, scalable multi-agent architectures will be those that treat memory not merely as a passive storage peripheral, but as a deeply governed, hierarchical, and actively reasoned collective cognitive infrastructure.

Works cited

1. \[2603.10062\] Multi-Agent Memory from a Computer Architecture Perspective: Visions and Challenges Ahead \- arXiv, https://arxiv.org/abs/2603.10062
2. Memory for Autonomous LLM Agents:Mechanisms, Evaluation, and Emerging Frontiers \- arXiv, https://arxiv.org/pdf/2603.07670
3. Memory in LLM-based Multi-agent Systems: Mechanisms, Challenges, and Collective Intelligence \- TechRxiv, https://www.techrxiv.org/doi/pdf/10.36227/techrxiv.176539617.79044553
4. A Practical Guide to Memory for Autonomous LLM Agents | Towards Data Science, https://towardsdatascience.com/a-practical-guide-to-memory-for-autonomous-llm-agents/
5. Multi-Agent Scaling: The Context Gap That Breaks AI Systems \- Atlan, https://atlan.com/know/multi-agent-scaling/
6. Graph-Based Agent Memory: A Complete Guide to Structure, Retrieval, and Evolution, https://shibuiyusuke.medium.com/graph-based-agent-memory-a-complete-guide-to-structure-retrieval-and-evolution-6f91637ad078
7. Rethinking Memory Mechanisms of Foundation Agents in the Second Half: A Survey \- arXiv, https://arxiv.org/html/2602.06052v2
8. Amory: Building Coherent Narrative-Driven Agent Memory through Agentic Reasoning \- arXiv, https://arxiv.org/pdf/2601.06282
9. agent\_memory\_architect.txt \- ai-boost/awesome-prompts \- GitHub, https://github.com/ai-boost/awesome-prompts/blob/main/prompts/agent\_memory\_architect.txt
10. EvoMem: Improving Multi-Agent Planning with Dual-Evolving Memory \- arXiv, https://arxiv.org/html/2511.01912v2
11. ShanglinWu/MAS\_lifelong\_learning · GitHub \- LLMA-Mem, https://github.com/ShanglinWu/MAS\_lifelong\_learning
12. Multi-Agent Transactive Memory \- arXiv, https://arxiv.org/html/2606.19911v1
13. Multi-Agent Transactive Memory \- arXiv, https://arxiv.org/pdf/2606.19911
14. A Hierarchical Multi-Agent Architecture with Autonomous Persistent and Ephemeral Agents and Persistent Evolving Knowledge \- TechRxiv, https://www.techrxiv.org/doi/pdf/10.36227/techrxiv.177211798.85464735
15. Paper page \- Multi-Agent Transactive Memory \- Hugging Face, https://huggingface.co/papers/2606.19911
16. \[2606.19911\] Multi-Agent Transactive Memory \- arXiv, https://arxiv.org/abs/2606.19911
17. Hierarchical RAG Explained: Knowledge Bases for Long-Term Agents \- DEV Community, https://dev.to/christian\_mikolasch/hierarchical-rag-explained-knowledge-bases-for-long-term-agents-27pi
18. Hierarchical RAG: Multi-level Retrieval \- Emergent Mind, https://www.emergentmind.com/topics/hierarchical-retrieval-augmented-generation-hierarchical-rag
19. Multi Agent RAG with Interleaved Retrieval and Reasoning for Long Docs | Pathway, https://pathway.com/framework/blog/multi-agent-rag-interleaved-retrieval-reasoning
20. SurveyG: A Multi-Agent LLM Framework with Hierarchical Citation Graph for Automated Survey Generation \- arXiv, https://arxiv.org/html/2510.07733v2
21. A Multi-Agent LLM Framework with Hierarchical Citation Graph for Automated Survey Generation \- arXiv, https://arxiv.org/html/2510.07733
22. SurveyG: A Multi-Agent LLM Framework with Hierarchical Citation Graph for Automated Survey Generation | alphaXiv, https://www.alphaxiv.org/overview/2510.07733v1
23. SurveyG: A Multi-Agent LLM Framework with Hierarchical Citation Graph for Automated Survey Generation \- ChatPaper, https://chatpaper.com/paper/197754
24. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents | Request PDF \- ResearchGate, https://www.researchgate.net/publication/403824352\_GAM\_Hierarchical\_Graph-based\_Agentic\_Memory\_for\_LLM\_Agents
25. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents \- arXiv, https://arxiv.org/html/2604.12285v1
26. GAM: Hierarchical Graph-based Agentic Memory for LLM Agents \- ACL Anthology, https://aclanthology.org/2026.acl-long.1600.pdf
27. Amory: Building Coherent Narrative-Driven Agent Memory through Agentic Reasoning, https://arxiv.org/html/2601.06282v1
28. Amory: Building Coherent Narrative-Driven Agent Memory through Agentic Reasoning \- ACL Anthology, https://aclanthology.org/2026.eacl-long.183.pdf
29. \[2601.06282\] Amory: Building Coherent Narrative-Driven Agent Memory through Agentic Reasoning \- arXiv, https://arxiv.org/abs/2601.06282
30. GAAMA: Graph Augmented Associative Memory for Agents \- Takara TLDR, https://tldr.takara.ai/p/2603.27910
31. MEMORY IS RECONSTRUCTED, NOT RETRIEVED: GRAPH MEMORY FOR LLM AGENTS \- OpenReview, https://openreview.net/pdf/061241ca5a30c124478594f14b2e19955327b0c0.pdf
32. Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents \- arXiv, https://arxiv.org/html/2606.06036v1
33. Paper page \- Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents, https://huggingface.co/papers/2606.06036
34. Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents | OpenReview, https://openreview.net/forum?id=xRVWftS3ES
35. \[2606.06036\] Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents, https://arxiv.org/abs/2606.06036
36. Executing Wide Search via Agentic MapReduce \- arXiv, https://arxiv.org/html/2602.01331v1
37. A-MapReduce: Executing Wide Search via Agentic MapReduce | alphaXiv, https://www.alphaxiv.org/abs/2602.01331
38. Creating Views (MapReduce) | IBM Cloud Docs, https://cloud.ibm.com/docs/Cloudant?topic=Cloudant-creating-views-mapreduce
39. Governed Shared Memory for Multi-Agent LLM Systems \- arXiv, https://arxiv.org/pdf/2606.24535
40. Governed Shared Memory for Multi-Agent LLM Systems \- arXiv, https://arxiv.org/html/2606.24535v1
41. \[Revisión de artículo\] Governed Shared Memory for Multi-Agent LLM Systems, https://www.themoonlight.io/es/review/governed-shared-memory-for-multi-agent-llm-systems
42. MemClaw: Governed Shared Memory for LLM Fleets \- Emergent Mind, https://www.emergentmind.com/topics/memclaw
43. Three teams in seven weeks converge: the hard part of multi-agent shared memory is governance (scope, provenance, supersession), not capacity. And the freshest, vendor-authored one's own eval leaked, a 44% search-probe leak rate and a cross-fleet read bug it patched mid-study. : \- Reddit, https://www.reddit.com/r/EdgeOfAINotes/comments/1uef1dd/three\_teams\_in\_seven\_weeks\_converge\_the\_hard\_part/
44. \[2606.24535\] Governed Shared Memory for Multi-Agent LLM Systems \- arXiv, https://arxiv.org/abs/2606.24535
45. \[2606.15609\] FragFuse: Bypassing Access Control of Large Language Model Agents via Memory-Based Query Fragmentation and Fusion \- arXiv, https://arxiv.org/abs/2606.15609
46. FragFuse: Bypassing Access Control of Large Language Model Agents via Memory-Based Query Fragmentation and Fusion | USENIX, https://www.usenix.org/conference/usenixsecurity26/presentation/rao
47. ICLR Poster RedCodeAgent: Automatic Red-teaming Agent against Diverse Code Agents \- ICLR 2026, https://iclr.cc/virtual/2026/poster/10010244
48. Zhaorun Chen, University of Chicago, https://billchan226.github.io/
49. ARMs: Adaptive Red-Teaming Agent against Multimodal Models with Plug-and-Play Attacks, https://openreview.net/forum?id=PT7PKmBv4M\&referrer=%5Bthe%20profile%20of%20Bo%20Li%5D(%2Fprofile%3Fid%3D\~Bo\_Li19)
50. EDV Framework Curbs AI Agent Memory Contamination with Consensus \- AI Weekly, https://aiweekly.co/alerts/edv-framework-curbs-ai-agent-memory-contamination-with-consensus
51. An Adversary-Resistant Multi-Agent LLM System via Credibility Scoring \- Computer Science, https://www.cs.uic.edu/\~asudeh/files/MA\_LLM\_AACL2025\_Slides.pdf
52. Scaling Teams or Scaling Time? Memory Enabled Lifelong Learning in LLM Multi-Agent Systems \- arXiv, https://arxiv.org/html/2604.03295v1
53. Scaling Teams or Scaling Time? Memory Enabled Lifelong Learning in LLM Multi-Agent Systems \- Hugging Face, https://huggingface.co/papers/2604.03295
54. Multi-Agent Architecture Guide (March 2026\) \- Openlayer, https://www.openlayer.com/blog/post/multi-agent-system-architecture-guide
55. \[2604.03295\] Scaling Teams or Scaling Time? Memory Enabled Lifelong Learning in LLM Multi-Agent Systems \- arXiv, https://arxiv.org/abs/2604.03295
56. 9 New Approaches to Multi-Agent Systems \- Turing Post, https://www.turingpost.com/p/9masmethods
57. Large Language Model-driven Multi-Agent Simulation for Fake News Diffusion Under Different Network Structures | Request PDF \- ResearchGate, https://www.researchgate.net/publication/403996755\_Large\_Language\_Model-driven\_Multi-Agent\_Simulation\_for\_Fake\_News\_Diffusion\_Under\_Different\_Network\_Structures
58. LEAR: LLM-Driven Evolution of Agent-Based Rules, https://ccl.northwestern.edu/2025/lear\_gurkan.pdf
59. Multi-agent systems powered by large language models: applications in swarm intelligence \- PMC, https://pmc.ncbi.nlm.nih.gov/articles/PMC12135685/