Multi-Network Memory Graphs in MAS

• Multi-Network Memory Graphs is a hierarchical memory architecture that integrates interaction, query, and insight graphs for LLM-powered multi-agent systems.
• It employs bi-directional memory traversal, embedding-based retrieval, and role-specific customization to improve dynamic memory retrieval and knowledge transfer.
• Empirical evaluations indicate performance improvements up to 20.89% on benchmarks, underscoring its scalability and efficiency over flat memory approaches.

Multi-Network Memory Graphs (also known as hierarchical, agentic memory graph systems) constitute a graph-centric memory architecture designed for LLM-powered Multi-Agent Systems (MAS). This approach explicitly models cross-trial knowledge, agent-specific memory, and fine-grained interaction histories using an intertwined, three-tier graph structure. The G-Memory system, introduced for MAS and inspired by organizational memory theory, formalizes this methodology to support dynamic, scalable, and role-aware memory retrieval and update—outperforming prior flat or monolithic memory approaches in both embodied and knowledge-intensive benchmarks (Zhang et al., 9 Jun 2025).

1. Three-Tier Multi-Network Graph Architecture

G-Memory organizes MAS memory into three stratified, interconnected graph networks, each capturing a distinct granularity of historical system experience:

• Interaction Graph (Utterance Graph):

For a single query $Q$, the interaction graph $G_{\mathrm{inter}}^{(Q)} = (U^{(Q)}, E_u^{(Q)})$ encodes agent utterances and their dependencies for that query. Each node $u_i = (A_i, m_i)$ pairs an agent $A_i$ with their message $m_i$; directed edges $(u_j \rightarrow u_k) \in E_u^{(Q)}$ indicate that utterance $u_k$ was explicitly inspired by $u_j$. This level preserves temporally ordered, fine-grained inter-agent dialogue.

• Query Graph:

The global query graph $G_{\mathrm{query}} = (Q, E_q)$ aggregates all prior queries and their associated trajectories. Each node $q_i = (Q_i, \Psi_i, G_{\mathrm{inter}}^{(Q_i)})$ encodes the user query $Q_i$, execution outcome $\Psi_i \in \{\text{Failed, Resolved}\}$, and the corresponding interaction subgraph. Edges $E_q$ link queries based on semantic similarity, workflow dependencies, or sub-task overlap, supporting analogical retrieval for new user tasks.

• Insight Graph:

The insight graph $G_{\mathrm{insight}} = (I, E_i)$ abstracts high-level, distilled lessons of the MAS. Nodes $\iota_k = (\kappa_k, \Omega_k)$ capture generalized insights ($\kappa_k$) and the supporting query set $\Omega_k \subseteq Q$. Hyperedges $(\iota_m, \iota_n, q_j) \in E_i$ represent that insight $\iota_m$ contextualizes $\iota_n$ via query $q_j$, formalizing cross-trial, generalizable strategic knowledge.

2. Formal Framework and Traversal Algorithms

The hierarchical graph system is supported by a suite of embedding, retrieval, and update mechanisms:

2.1 Embedding and Similarity

User queries are mapped by $v(\cdot)$ (e.g., MiniLM) to dense vectors. Retrieval over the query graph identifies the $k$ most similar historical queries by cosine similarity:

$$Q^S = \arg\max_{q_i \in Q,\, |Q^S|=k} \frac{v(Q) \cdot v(q_i)}{\|v(Q)\| \|v(q_i)\|}$$

2.2 Bi-Directional Memory Traversal

The retrieval process executes a coarse-to-fine, cross-graph traversal:

1. Coarse Retrieval + Hop Expansion: $Q^S$ (top-$k$ semantically similar queries) and their graph neighbors $\tilde{Q}$ form the candidate pool.
2. Upward Traversal to Insight Graph: $$I^S = \{\, \iota_k \in I \mid \Omega_k \cap \tilde{Q} \neq \emptyset \,\}$$ collects all insights with supporting queries in $\tilde{Q}$.
3. Downward Traversal to Interaction Graph: Each candidate $q_j$ receives a relevance score $R_{\mathrm{LLM}}(Q, q_j)$. The top-$M$ are selected; their interaction subgraphs are sparsified via LLM-prompted routines $S_{\mathrm{LLM}}$, yielding $\hat{G}_{\mathrm{inter}}^{(Q_j)}$—the subset of utterances relevant to $Q$.
4. Role-Specific Allocation: For each agent $$C_i=(\text{Base}_i, \text{Role}_i, \text{Mem}_i, \text{Plugin}_i)$$, memory $$\text{Mem}_i \gets \Phi(I^S, \{\hat{G}_{\mathrm{inter}}^{(Q_j)}\}_{j=1..M}; \text{Role}_i, Q)$$ is instantiated, customizing the selected insights and sub-trajectories to agent role and current query.

2.3 Hierarchical Memory Update

Upon completion of query $Q$, the system updates all three graph tiers:

• The new $G_{\mathrm{inter}}^{(Q)}$ is appended to the memory store.
• Query graph node $$q_{\text{new}} = (Q, \Psi, G_{\mathrm{inter}}^{(Q)})$$ and appropriate semantic/workflow links are added.
• Insights are distilled via an LLM summarizer $J(G_{\mathrm{inter}}^{(Q)}, \Psi)$ to generate new insight nodes $\iota_{\text{new}}$. Supporting sets and contextual edges are updated accordingly.

3. Cross-Tier Interoperation and Specialization

The multi-network approach enables complex, bidirectional information flow:

• Retrieval Path:

New queries first identify semantically similar trials in the query graph, then extract high-level, generalizable insights via upward traversal, and finally obtain fine-grained, role-relevant dialogue snippets by downward traversal through the interaction graph.

• Customization:

The $\Phi$ function ensures memory is filtered and distilled according to the specific agent role and task requirements, supporting diverse agent specializations even within a single MAS instance.

• Update Path:

Upon task conclusion, new data propagate through all graph layers—utterance histories augment interaction graphs, new task experiences form query nodes, and emergent strategies are formalized as new or refined insights. This cyclical, joint update nurtures progressive team evolution and continual knowledge accumulation across agent teams and trials.

4. Algorithmic Workflow

The core routines for retrieval and update can be abstracted by the following high-level structures:

def RetrieveMemory(Q): QS = top_k_cosine(v(Q), {v(q_i)}) Q_tilde = QS ∪ neighbors(QS in G_query) IS = {ι in I | Ω_ι ∩ Q_tilde ≠ ∅} for q_j in top_M by R_LLM(Q,·) over Q_tilde: G_inter_hat[Q_j] = S_LLM(G_inter[Q_j], Q) for agent C_i: Mem_i = Φ(IS, {G_inter_hat[Q_j]}; Role_i, Q) return {Mem_i} def UpdateMemory(Q, Ψ, {u_t}): G_inter[Q] = build_graph({u_t}) q_new = (Q, Ψ, G_inter[Q]) N_conn = top_M_queries ∪ ⋃_{ι∈IS} Ω_ι add q_new to Q; add edges (n→q_new) for n in N_conn ι_new = (J(G_inter[Q], Ψ), {q_new}) for ι in IS: Ω_ι = Ω_ι ∪ {q_new} add edge (ι→ι_new via q_new) add ι_new to I persist G_inter[Q], G_query, G_insight

The traversal and updating phases are explicitly designed for efficient role-aware memory initialization and continual, multi-level system evolution.

5. Experimental Evaluation and Impact

Extensive experimentation on well-established MAS benchmarks and frameworks demonstrates the empirical effectiveness of the multi-network graph approach:

• Benchmarks:

ALFWorld, SciWorld (embodied), PDDL (planning games), HotpotQA, FEVER (knowledge QA).

• Frameworks and Models:

Tested on AutoGen, DyLAN, MacNet; with LLM backbones including Qwen-2.5-7b, Qwen-2.5-14b, GPT-4o-mini.

• Performance Gains:
  • On ALFWorld, using Qwen-14b with MacNet, success rates rose from 58.21% to 79.10% ($+20.89\%$).
  • On HotpotQA and FEVER, accuracy improved by up to approximately 10%.
  • Ablation experiments verified the necessity of both the insight and interaction graph tiers, as removing either leads to performance drops in the 3–4% range.
  • The architecture achieves these gains with only modest token overhead, demonstrating strong token-efficiency and over twofold performance gains relative to baseline memory augmentation strategies.

Benchmark	Framework	LLM Backbone	Baseline Score	+G-Memory Score	Δ (%)
ALFWorld	MacNet	Qwen-2.5-14b	58.21	79.10	20.89
HotpotQA	AutoGen/DyLAN	Qwen/GPT-4o-mini	N/A	+up to 10.12	~10
FEVER	MacNet	Qwen-2.5-7b	N/A	+up to 10.12	~10

A plausible implication is that multi-network memory graphs provide substantial improvements for MAS in both agent collaboration and knowledge transfer, without requiring architectural changes to foundational frameworks (Zhang et al., 9 Jun 2025).

6. Significance and Prospective Directions

G-Memory’s multi-network memory graphs represent a shift toward principled, explicitly structured memory systems in LLM-based MAS. By integrating cross-trial generalization, agent-specific customization, and fine-grained trajectory preservation, this framework supports both intra- and inter-trial reasoning at scale.

Key features distinguishing this approach include:

• Scalability: Hierarchical graph storage accommodates growth in tasks, agents, and trial histories.
• Role Awareness: Customizable memory views aligned with agent specialization and task context.
• Resource Efficiency: Hierarchical, filtered retrieval delivers substantial gains with minimal additional token consumption.
• Empirical Robustness: Results indicate that hierarchy and cross-trial memory are critical for advancing MAS reasoning beyond naïve context concatenation or single-network memory injection.

While current deployments assume LLM-powered agents within established MAS platforms, this architectural motif is extensible to broader agentic and decentralized AI contexts. A plausible implication is that future research may generalize these stratified graph methodologies for cross-domain continual learning, agent-level meta-learning, or explainable agent collaboration.