中文

G-Memory: Tracing Hierarchical Memory for Multi-Agent Systems · Guibin Zhang

2026-06-21 · A faithful, transcript-grounded reading by PodLens

Source paper:https://arxiv.org/pdf/2506.07398

multi-agent systems (MAS)hierarchical memorygraph databasesself-evolutioncontext compressionepistemic environments

What This Paper Is About

This paper targets the missing self-adaptive and self-evolving capacity in LLM-driven multi-agent systems (MAS), arguing that the root bottleneck is the lack of a memory mechanism designed specifically for multi-agent collaboration [Abstract]. Existing approaches either use only memory local to a single session, or simply port over single-agent memory designs wholesale — both of which break down when faced with collaboration trajectories up to 10× longer than single-agent tasks, due to context overload or the loss of role-specific information [Introduction].

To address this, the authors propose G-Memory, a plug-and-play hierarchical agent memory system. Inspired by organizational memory theory, G-Memory uses a three-tier graph structure to manage sprawling collaboration history: the Utterance Graph (preserving fine-grained dialogue trajectories), the Query Graph (preserving historical task metadata and relationships), and the Insight Graph (preserving general-purpose lessons abstracted across tasks) [§3]. When a new task arrives, G-Memory performs semantic retrieval and topological diffusion along the Query Graph, traverses upward into the Insight Graph to extract high-level strategic guidance, traverses downward into the Utterance Graph to extract LLM-compressed fine-grained execution traces, and finally injects each into an agent's context tailored to that agent's specific role [§4]. Experiments show that, without modifying any underlying framework, G-Memory improves the success rate of AutoGen, DyLAN, and MacNet on benchmarks like ALFWorld, SciWorld, and PDDL by up to 20.89%, while significantly reducing token consumption [§5].

Paper Skeleton

Core Arguments List

  1. Directly porting single-agent memory architectures (such as vector-retrieval-based RAG) to multi-agent systems is engineeringly infeasible. Because multi-agent systems involve multi-round, multi-agent interaction, their trajectory token count is an entire order of magnitude higher than single-agent tasks, easily triggering context overflow and noise contamination in the LLM. - §1 Introduction, p.2: "up to 10× more tokens, as demonstrated by Figure 1 (Left)" - Fact
  2. A multi-agent memory mechanism must have "agent-specific customization." In complex collaborative tasks, crudely stuffing the same global historical trajectory into every role wastes a huge number of tokens and also dilutes the functional division of labor between roles, degrading collaboration efficiency. - §1 Introduction, p.1; §4.2, p.6 - View
  3. Retrieving semantically related tasks via "1-hop topological diffusion" is more robust than relying purely on vector cosine similarity. Pure semantic vector retrieval can introduce noise from superficial feature similarity, while hop-diffusion along topological edges in the Query Graph (edges connecting tasks that historically jointly triggered some success) captures the underlying structural similarity of tasks more accurately. - §4.1, p.5: Equation (5) - Fact
  4. "Bi-directional traversal" lets the system capture both macro-level strategic guidance and micro-level execution cases. Traversing upward into the Insight Graph extracts high-level rules (such as "don't put unwashed items in the microwave"); traversing downward into the Interaction Graph extracts specific code or action logs — neither is dispensable. - §4.2, p.5-6; Figure 2 - View
  5. The "institutionalization" of collective experience depends on an asynchronous closed loop of multi-level graph updates. Feedback on task success or failure cannot just be cached locally — it must be deposited as a new node in the Query Graph, edges to related queries, and used to cluster and revise Insight Graph nodes via the J operator, forming the continuous self-evolution of the agent team. - §4.3, p.6: Equations (9)-(11) - Fact

Plain English Explanation

Imagine you have a team of several AI specialists collaborating like robots — one handles searching for information, one handles moving objects, one handles final review. If, every time you assign them new work, you simply photocopy every single piece of chatter they've exchanged over the past several dozen days — sometimes hundreds of thousands of words — and hand an unfiltered copy to each AI, they'll inevitably get "dizzy" from the sheer volume, and may even forget what their own job was supposed to be [Introduction]. This explains why many advanced multi-agent systems, after repeated rounds of doing the same task, don't get smarter — they collapse instead, because their memory becomes increasingly bloated [Introduction].

G-Memory is like equipping this AI team with an extremely smart "institutional memory archive" [§3]. Instead of crudely storing chat logs, it organizes memory into three layers:

The first layer is the Utterance Graph (the bottom layer), which records only the most granular conversational actions [§3, Interaction Graph]; the second layer is the Query Graph (the middle layer), which treats every past task as a node, and draws a line between two tasks if their solution approach was similar [§3, Query Graph]; the third layer is the Insight Graph (the top layer), which stores the plain-language lessons distilled from past experience — for example, "when you encounter two people with the same name, always search to confirm whether they're the same person" [§3, Insight Graph].

When the AI team is assigned a new task (say, "put the clean towel into the washbasin"), G-Memory first searches the second-layer Query Graph for similar past tasks (say, "put the clean eggs into the microwave") [§4.1]. Once found, it strikes in both directions: first it "looks up," pulling the core lesson tied to that task from the top-layer Insight Graph ("always wash first, then place — the order matters"); then it "looks down," using an LLM to "dehydrate and compress" the bottom-layer interaction logs, extracting the few most critical steps of dialogue from that collaboration (e.g., "the ground agent reminded the solver agent to wash first") [§4.2].

Finally, G-Memory delivers these condensed memories tailored to each AI's specific job — sending only the washing-related steps to the AI responsible for cleaning, and the placement path to the AI responsible for moving objects, never sending either any extraneous junk [§4.2]. Once the task is done, the system, depending on whether it succeeded or failed, re-weaves the dialogue, the task type, and the newly distilled lesson back into all three layers of the graph, automatically upgrading the memory archive [§4.3].

The experimental results are genuinely exciting: this hierarchical memory retrieval approach raised success rates for robots finding objects at home and running experiments in a science lab by as much as 20% or more — and because the memory has been compressed to its essence, token consumption actually went down compared to before, achieving the rare combination of getting smarter while spending less [§5].

Glossary

Before and After This Paper

Before This Paper

After This Paper

Sections Most Worth Reading in the Original

Resonances with past episodes

Tensions with past episodes

A faithful reading and plain-language retelling of the paper, generated by PodLens.

This is one source-grounded reading, not a replacement for the original. Every point is anchored to its source, so you can check it yourself — and corrections are welcome.