MAGMA: A Multi-Graph based Agentic Memory Architecture for AI Agents

📝 Paper Summary

Tree/graph-based memory Agentic memory architecture

MAGMA structures agent memory into four orthogonal graphs—semantic, temporal, causal, and entity—and uses an intent-aware policy to traverse these graphs for long-horizon reasoning.

Core Problem

Existing agent memory systems typically use monolithic vector stores that rely heavily on semantic similarity, entangling different types of relationships (time, cause, entity) and leading to poor reasoning on 'why' or 'when' questions.

Why it matters:

Monolithic vector stores retrieve 'what' happened but struggle to reason about 'why' due to lack of explicit causal structure
Standard retrieval methods often lose temporal context or object permanence across long interaction histories
Entangled representations limit interpretability and alignment between the user's query intent and the retrieved evidence

Concrete Example: When an agent is asked 'Why did the project fail?', a standard semantic retriever might fetch documents discussing 'project' and 'failure' generally. It misses the specific causal chain of events (e.g., 'Budget cut' -> 'Delay' -> 'Failure') because it lacks explicit causal edges linking these distinct events in memory.

Key Novelty

Multi-Graph Agentic Memory Architecture (MAGMA)

Represents every memory item simultaneously across four distinct graphs: Semantic (similarity), Temporal (chronology), Causal (logic/entailment), and Entity (object permanence)
Uses a dual-stream evolution process where a 'Fast Path' handles immediate ingestion and a 'Slow Path' uses an LLM to asynchronously infer and densify causal/entity connections
Retrieval is treated as a policy-guided graph traversal where the query intent (e.g., 'Why' vs 'When') determines which graph edges are prioritized

Architecture

The overall MAGMA architecture showing the three logical layers: Query Process, Data Structure, and Write/Update Process.

Evaluation Highlights

Outperforms state-of-the-art baselines (including MemoRAG and Hi-Mem) on LoCoMo and LongMemEval benchmarks
Reduces retrieval latency and token consumption compared to prior systems by pruning irrelevant graph regions during traversal
Achieves superior alignment between query intent and retrieved evidence through adaptive edge weighting

Breakthrough Assessment

8/10

Strong structural innovation by explicitly disentangling memory dimensions (causal vs. temporal) and coupling this with a dual-stream update mechanism. Addresses a critical bottleneck in agentic reasoning.

⚙️ Technical Details

Problem Definition

Setting: Long-horizon agentic reasoning where an agent must maintain and query a time-variant memory M_t evolving via a feedback loop

Inputs: User query q and current memory state G_t

Outputs: Generated response and updated memory state G_{t+1}

Pipeline Flow

Query Analysis: Decomposes query into intent, timestamps, and keywords
Anchor Identification: Finds entry nodes via RRF (Semantic + Lexical + Temporal)
Adaptive Traversal: Expands context via graph beam search weighted by intent
Narrative Synthesis: Linearizes the subgraph into a prompt for the LLM

System Modules

Intent-Aware Router

Classifies query intent (Why, When, Entity) and extracts temporal/keyword constraints

Model or implementation: Lightweight classifier (specific architecture not detailed)

Adaptive Topological Retriever

Traverses the multi-graph structure starting from anchor nodes, scoring edges based on query intent

Model or implementation: Heuristic Beam Search algorithm

Context Synthesizer

Linearizes the retrieved subgraph into a text prompt, applying topological ordering (chronological or causal)

Model or implementation: Deterministic linearization protocol

Novel Architectural Elements

Four-layer orthogonal graph structure (Semantic, Temporal, Causal, Entity) replacing monolithic vector stores
Intent-dependent edge weighting function phi(e, T_q) that dynamically biases traversal (e.g., prioritizing causal edges for 'Why' queries)
Dual-stream update architecture separating latency-sensitive ingestion from asynchronous causal inference (Slow Path)

Modeling

Base Model: Not explicitly reported in the paper (implies use of standard LLMs for the agent and consolidation, likely GPT-4 or Llama-3 class based on typical agent setups)

Compute: Not reported in the paper

Comparison to Prior Work

vs. A-MEM: MAGMA explicitly models causal and entity relations orthogonal to semantic similarity, whereas A-MEM relies on semantic links
vs. Nemori: MAGMA uses distinct relational graphs rather than a unified narrative structure, allowing precise traversal based on query intent
vs. GraphRAG: MAGMA focuses on agentic episodic memory (events/time) rather than general knowledge graph construction
+ 1 more
vs. MemGPT [not cited in paper]: MAGMA uses a graph-based structured memory rather than an OS-like paging system for context management

Limitations

Dependency on the capabilities of the 'Slow Path' LLM to correctly infer causal and entity relationships
Complexity of maintaining four simultaneous graph structures as memory scales
Specific latency overhead of the graph traversal step compared to simple vector retrieval is claimed to be lower but depends on graph density

Reproducibility

Code: https://github.com/FredJiang0324/MAMGA

Code is publicly available at https://github.com/FredJiang0324/MAMGA. The paper describes the algorithms for traversal and update in detail (Algorithms 1, 2, 3). Specific LLM backbones used for the experiments are not explicitly named in the text provided.

📊 Experiments & Results

Evaluation Setup

Long-horizon reasoning tasks requiring retrieval from extensive interaction history

Benchmarks:

LoCoMo (Long-Context Modeling / Reasoning)
LongMemEval (Long-term Memory Evaluation)

Metrics:

Reasoning Accuracy
Retrieval Latency
Token Consumption
Statistical methodology: Not explicitly reported in the paper

Main Takeaways

MAGMA consistently outperforms state-of-the-art systems on long-context benchmarks
The adaptive traversal policy effectively reduces token usage by pruning irrelevant graph regions compared to retrieving full chunks
The dual-stream update mechanism maintains system responsiveness while allowing for deeper structural organization of memory over time
Disentangling memory into four graphs allows for better interpretability of the reasoning path compared to monolithic embeddings

📚 Prerequisite Knowledge

Prerequisites

Knowledge of RAG (Retrieval-Augmented Generation) and MAG (Memory-Augmented Generation)
Understanding of graph data structures and traversals
Familiarity with vector databases and embeddings

Key Terms

MAG: Memory-Augmented Generation—systems where an agent maintains a persistent external memory to support long-context reasoning

RRF: Reciprocal Rank Fusion—a method to combine multiple ranked retrieval lists (e.g., keyword and semantic) into a single unified ranking

Topological Sort: A linear ordering of vertices in a directed graph such that for every directed edge from u to v, u comes before v in the ordering

Synaptic Ingestion: The 'Fast Path' in MAGMA's memory update process that performs low-latency operations like indexing and timestamping without heavy reasoning

Structural Consolidation: The 'Slow Path' where an LLM asynchronously infers complex relationships (causal, entity) to add edges to the memory graph

Zettelkasten: A knowledge management method using interlinked notes; used here to describe baseline memory organization styles

Beam Search: A search algorithm that explores a graph by keeping only the most promising 'k' paths at each step

LoCoMo: A benchmark for Long-Context Modeling, likely focusing on reasoning over extended sequences

LongMemEval: A benchmark specifically designed to evaluate long-term memory capabilities in AI agents