MAGMA: Splitting One Memory Graph into Four Orthogonal Relation Graphs

0. Search Disclosure

This review searched ACL Anthology 2026, EACL 2026, NeurIPS 2025 proceedings, the ICLR 2026 MemAgents workshop, arXiv cs.CL/cs.AI, and Agent-Memory-Paper-List several awesome-lists, screening over 25 candidates from August 2025 through July 2026.

Following the requested priority (top-conference main-track long papers > Findings/Workshop > arXiv preprints), the selection was MAGMA (ACL 2026 main-conference long paper). It meets all requirements: ACL 2026 Volume 1 Long Papers, arXiv v1 in January 2026 (within six months), accessible open-source code, and no overlap with previously covered MemGPT, A-MEM, Mem0, Memory-R1, MemAct, or AgeMem. A-MEM and MemoryOS appear only as predecessors. Covered subfields: memory architecture + memory retrieval.

1.1 Core work

1.2 Evaluation Benchmarks

1.3 Predecessor Papers

2.1 Abstract and Positioning

The paper's specific claim, rather than a generic summary: existing Memory-Augmented Generation (MAG) systems store memory in one monolithic repository indexed solely by semantic similarity, entangling temporal, causal, and entity information. MAGMA places each memory entry simultaneously in four orthogonal semantic, temporal, causal, and entity graphs and formalizes retrieval as policy-guided traversal over these relational views.

The significance is that it moves the memory bottleneck from what to store to which relations to store it under. Nemori asks what deserves retention, MemoryOS asks how long and in which tier, and A-MEM asks whether memories should be linked. MAGMA asks which kind of edge to create and which kind to follow at query time.

2.2 Motivation and Problem Evidence

Specific problems (§1): ① Distance-related attention degradation, or lost-in-the-middle, prevents longer context alone from solving long-term memory. ② A single semantic index loses relational structure; A-MEM-style similarity retrieval misses temporal and causal relations. ③ Object permanence breaks when the same entity appears across interrupted timeline fragments: semantic retrieval cannot join them into one object, directly motivating the entity graph.

How Are These Problems Quantified? The paper no provide separate diagnostic experiments quantifying the three problems; instead it uses an indirect argument: Full context (101K tokens) reaches only 55.0% on LongMemEval, whereas structured retrieval with 3.4K reaches 61.2%, demonstrating that longer context does not imply better memory.

However, case studies (Table 8 / §E.2) provide three verifiable qualitative examples:

What Is Novel: Novelty lies beyond using graphs, as GraphRAG and Zep already do, in refusing to collapse semantically different relations into one graph. Zep encodes time as edge attributes; GraphRAG places entities and communities at two levels of one graph; A-MEM uses homogeneous links. MAGMA bets that decoupling relation types itself helps because retrieval policies gain explicit choices.

2.3 The Paper's Argument

The paper follows a clear chain of reasoning:

2.4 Methodology and Mechanisms

2.4.1 Data Structures

2.4.2 Four Relation Graphs (§3.1)

2.4.3 Query Pipeline: Adaptive Hierarchical Retrieval (Algorithm 1, Four Stages)

Stage 1 — Query Analysis and Decomposition: Intent classification T_q ∈ {Why, When, Entity}; temporal parsing (relative expressions → absolute interval [τ_s, τ_e]); representation extraction (dense q⃗ + sparse keywords q_key).

Stage 2 — Multisignal Anchor Identification (Reciprocal Rank Fusion):

Stage 3 — Adaptive Traversal Policy (Heuristic Beam Search), with transition scoring combining structural alignment and semantic affinity:

Thus, the edge-type weight vector w is a function of intent T_q: Why questions increase causal weights, When questions increase temporal weights. Each step keeps the top-k nodes, with depth decay γ.

Stage 4 — Narrative Synthesis Through Graph Linearization:

2.4.4 Dual-Stream Memory Evolution

2.4.5 Hyperparameters (Appendix B) and Experimental Setup

The paper says these parameters were empirically optimized on LoCoMo, but provides no sensitivity curve or parameter-sweep table(see §2.7 B3).

Experimental setup: Backbone gpt-4o-mini(retrieval reasoning, answer generation, and LLM-as-Judge; judge temperature 0.0); default embeddings all-MiniLM-L6-v2(384 dimensions), optionally text-embedding-3-small(1536 dimensions). LoCoMo 1,986 examples: single-hop 841 / adversarial 446 / temporal 321 / multi-hop 282 / open-domain 96; conversations average about 9K tokens. LongMemEval Average context >100K tokens, six question types. Primary metric: LLM-as-a-Judge [0,1]; auxiliary metrics: token-level F1 and BLEU-1.

3.1 Main Result A: LoCoMo (Paper Table 1, LLM-Judge Scores)

Gain over the strongest baseline (calculated here)

3.2 ⚡ A Phase-Transition Finding: 98.98% of the 18.6% Overall Gain Comes from Unanswerable Adversarial Questions

This is the most persuasive and most unsettling quantitative evidence—absent from the paper's discussion, but calculated from its tables.

LoCoMo Overall is a sample-weighted micro-average. Applying category counts to Table 1 reproduces MAGMA (0.7003 vs reported 0.700), A-MEM (0.5804 vs 0.580), and MemoryOS (0.5525 vs 0.553). Decomposing MAGMA's total difference from Nemori by category gives:

This does not negate MAGMA's value: Raising abstention calibration from 0.325 to 0.742 is highly practical engineering progress, plausibly driven by <ref:n_i.id> provenance labels and structured subgraphs: finding no relevant node after four causal hops is more decisive evidence than uniformly low vector similarities. But framing this as consistent superiority on long-horizon reasoning conflicts with the paper's own data: On the 1,540 questions requiring answers, MAGMA and Nemori are statistically indistinguishable.

3.3 ⚠️ Two Table 1 Rows Do Not Reconcile

Three rows agree precisely (error <0.0005), while two differ by 0.013–0.016. These are exactly the two rows likely quoted from the original Nemori paper rather than rerun(Nemori and Full Context typically appear together there). If so, the table mixes two judging protocols.

3.4 Main Result B: LongMemEval (Paper Table 2, Accuracy %)

The Same Issue Reappears (Calculated Here)

Two Implications:① The reported Average is not the arithmetic mean of the six listed categories, implying sample-count weighting; however, per-category sample counts are undisclosed, preventing verification. ② More importantly, excluding single-session-preference lets Full Context (65.30) overtake MAGMA (63.80). MAGMA loses on three of six categories: assistant −5.4pp, knowledge-update −11.5pp, and user −5.7pp.

The candid LongMemEval conclusion is therefore: MAGMA uses about 96% fewer tokens(0.7–4.2K vs 101K) to achieve roughly comparable, slightly better mean accuracy, with a large advantage on preferences. This is an impressive efficiency result rather than a capability result.

3.5 Ablations (Paper Table 4, LoCoMo)

Leave-One-Out Marginal Contributions (Calculated Here)

3.6 Single-Graph Ablations (Paper Table 5, LoCoMo)

Three Verifiable Observations (Calculated Here):

1. One graph already matches the strongest baseline. Causal Only's 0.590 equals Nemori's reported 0.590. A causal graph plus intent routing reaches Nemori; all four graphs add the remaining 0.110.
2. “Orthogonal” Conflicts with the Data. The sum of LOO drops is 0.063+0.056+0.053+0.034 = 0.206, whereas full graph minus best single graph is 0.700−0.590 = 0.110. The former is 1.87 times the latter. If contributions were additive or independent, these should be close. The 1.87× superadditivity indicates strong functional entanglement: representational orthogonality of disjoint edge sets does not imply independent effects.
3. The Diagonal Is Clean: Temporal Only leads on Temporal (0.620), Causal Only on Adversarial (0.680), and Entity Only on Open-Domain (0.460 among single graphs). This is strong evidence that the graphs serve distinct functions.

3.7 System Efficiency (Paper Table 3)

Relative differences (calculated here): MAGMA's 1.47s query latency is faster than Nemori by 43.2%, A-MEM by 35.0%, and MemoryOS by 95.5%, and even 15.5% faster than Full Context with 60.5% fewer input tokens. Construction is costlier: 0.39h is slower than Nemori by 34.5%; 3.37K tokens/query exceeds A-MEM by 28.6%.

4.1 Assessment of Value

The Substantive Contribution. MAGMA reframes agent-memory retrieval from a metric-learning problem(embedding queries and memories in one space) into a policy problem(choosing among relations with known semantics). The value is that retrieval becomes interpretable, controllable, and composable. Failed vector retrieval mainly prompts embedding changes; failed relational traversal can be localized to missing causal edges or incorrect intent classification.

Four Independently Reusable Designs

1. Dual-stream writing (fast/slow path separation)—independent of four-graph decomposition. Any memory system requiring LLM structural inference on writes can synchronously build rule-based skeletons and asynchronously infer richer relations. MemoryOS's 32.68s illustrates the alternative.
2. Intent-to-edge-weight routing (φ(r, T_q) = w_{T_q}ᵀ·𝟙_r)—usable whenever memory has multiple edge types, regardless of their semantics. It has the largest individual ablation contribution (−0.063).
3. Topologically ordered context linearization—place causes before effects in causal-query prompts. Almost free and orthogonal to retrieval design.
4. <ref:id> Provenance labeling—a plausible mechanism behind the adversarial jump from 0.325 to 0.742, letting the model see its lack of evidence.

Implications for Future Work. Replacing φ, currently a handcrafted weight table, with a learned policy is the most direct next step. Currently, w_{T_q} is manually set (entity 2.5–6.0 / temporal 0.5–4.0 / causal 3.0–5.0), with only three intent categories. This is precisely where MemRL / Memory-R1's RL line can connect: MAGMA supplies the action space; RL supplies the learning signal.

4.2 Limitations A: Acknowledged by the Paper (§6)

1. Dependence on LLM Reasoning Fidelity. Graph quality depends on the LLMs used for asynchronous consolidation. Erroneous or missing relations can propagate into retrieval; structured prompts and conservative thresholds only mitigate this risk.
2. Storage and Engineering Complexity from Multiple Graphs. Multiple relational views and dual-stream processing add implementation and memory overhead, limiting suitability in constrained environments.
3. Narrow Evaluation. The authors acknowledge that most agent-memory systems, including theirs, are evaluated only on long-context dialogue benchmarks such as LoCoMo and LongMemEval, excluding multimodal and heterogeneous observation streams.

4.3 Limitations B: Independent Criticisms

B1 · Argument Gap: The Core Claim Conflicts with the Data (Most Serious)

The paper claims consistent superiority on long-horizon reasoning. Yet the §3.2 decomposition attributes 98.98% of the overall advantage over Nemori to adversarial abstention. On the remaining 1,540 examples, MAGMA scores 0.6882 versus 0.6869, a difference of +0.13pp. Multi-hop directly contradicts consistency (0.528 vs 0.569, −7.2%). A more accurate claim is substantially improved abstention calibration and much lower latency at comparable reasoning accuracy.

B2 · Experimental Design: Four Graphs Claimed, Only Three Ablated

The paper repeatedly emphasizes four orthogonal semantic/temporal/causal/entity graphs, but Table 4 removes only causal, temporal, and entity graphs: there is no w/o Semantic. Table 5 likewise has only Causal Only, Temporal Only, and Entity Only: there is no Semantic Only. Semantic Only is precisely the null hypothesis: approximately vector RAG with beam search. Without it, the core claim that relational decoupling helps is never tested against its own null. This is the essential missing cell.

B3 · Experimental Design: Promised Hyperparameter Study Supplies Only Ranges

Appendix B lists λ₂ ∈ [0.3, 0.7], θ_sim=0.75, δ=0.6, beam=8, and γ=0.85, describing empirical optimization on LoCoMo, but provides no sensitivity curves or sweep tables. Thus (i) the share of the 0.700 score attributable to benchmark tuning is unknown (θ_sim and δ control graph density and have high leverage), and (ii) transfer retuning costs are unknown. This materially limits a system centered on threshold-based graph construction.

B4 · Metric Validity: Two Overall Rows Cannot Be Reconstructed

As §3.3 shows, MAGMA/A-MEM/MemoryOS reconcile from category scores (|Δ|<0.0005), but Nemori (Δ=+0.0157) and Full Context (Δ=+0.0126) do not. Correcting Nemori lowers the lead from +18.6% to +15.6%. Those rows are also the likeliest external quotations, suggesting mixed evaluation protocols.

B5 · Terminology Exceeds the Evidence: “Orthogonal” Is Overloaded

The LOO-drop sum of 0.206 is 1.87 times the full-versus-best-single gap of 0.110 (§3.6). Genuine independence would make them close; 1.87× suggests strong functional coupling. Orthogonal means only disjoint edge sets at the representation level, while the prose implies decomposable contributions at the effect level. This could mislead subsequent modular pruning efforts into expecting much stronger results than they obtain.

B6 · Missing Key Comparisons: No Graph-Structured Baseline

Table 1 uses Full Context, A-MEM, MemoryOS, and Nemori, with no graph-memory baseline, despite discussing GraphRAG and Zep. Zep reports up to +18.5% LongMemEval accuracy and −90% latency. A claim that multiple graphs are needed requires at least one single-graph baseline such as Zep or GraphRAG to isolate the difference. Current comparisons establish structured > unstructured, not multiple graphs > one graph—the actual contribution claim.

B7 · A Failing Subtask and a Structural Explanation

MAGMA's 0.528 on multi-hop trails Nemori's 0.569 by 4.1pp (−7.2%). This is counterintuitive because multi-graph traversal should excel at multiple hops. A testable hypothesis is premature pruning with beam width 8 and maximum depth 4–5. Table 5's multi-hop scores—Causal Only 0.470, Entity Only 0.485, full 0.528—suggest strong dependence on cross-graph combinations, whose candidates may be lost during layerwise pruning. The paper does not discuss this. Nemori instead pre-encodes cross-event relations in narrative compression, avoiding traversal pruning.

B8 · What If Abstention and Reasoning Were Evaluated Separately?

LoCoMo makes 22.5% of examples unanswerable, then combines correct answers and correct refusals into one LLM-judge Overall. This aggregation favors conservative abstention: always refusing earns perfect adversarial performance and 0.225 Overall. Future work should report two separate numbers: non-adversarial accuracy for capability and adversarial abstention for calibration, analogous to precision/recall. Under this protocol, MAGMA's story becomes equal capability and much better calibration—a more informative conclusion.

B9 · Limitations of This Analysis

• I cannot prove that Table 1 Overall is a sample-weighted micro-average. Exact reconstruction of three rows is strong evidence, not proof.
• LongMemEval category counts are undisclosed, so §3.4's preference-exclusion calculation uses an unweighted arithmetic mean. Large differences in actual weights could change its direction, although Full Context winning in three of six categories remains true.
• I did not run FredJiang0324/MAGMA to reproduce any numbers. All conclusions rely on internal consistency checks.
• of reported values. Slow-path LLM call counts are undisclosed, so §3.7's TCO criticism is mechanism-based inference, not measurement.

These works trace how one problem is progressively unpacked: pageable text → linked notes → a hierarchical lifecycle → a temporal knowledge graph → selected narratives → MAGMA's relation-separated, intent-routed graphs.

5.1 GraphRAG (Edge et al., arXiv 2404.16130, v1 2024-04, v2 2025-02)

Problem addressed. Naive RAG locates passages mentioning an entity but struggles with corpus-wide synthesis. GraphRAG uses LLMs to build entity graphs and precompute community summaries, then generates local answers from those summaries and merges them. In one sentence: the retrieval unit moves from chunks to graph communities.

Unresolved problem. GraphRAG is a static corpus index designed for one-time construction and repeated queries. It lacks incremental writes, temporal validity, and distinct relation types, using broadly co-occurrence or association edges. All three limit agents with continuous interaction and changing facts.

MAGMA's Response. It inherits LLM structure extraction in the slow path's Φ_reason but changes it from offline batch processing to online asynchronous streaming and splits one edge type into four. Community summaries correspond to MAGMA's salience-based budgeting.

Transfer of key designs. The LLM-as-graph-builder paradigm carries over, while precomputed summaries become intent-driven query-time traversal—a shift from precomputation to on-demand routing.

5.2 MemGPT (Packer et al., 2023; Cited by MAGMA as ACL 2023 Companion)

Problem addressed. Introduces the operating-system virtual-memory metaphor: main context is physical memory, external storage is disk, and the LLM pages between them through function calls. In one sentence: let the model manage what belongs in context.

Unresolved problem. Paging operates on unstructured text blocks. MemGPT solves capacity but not relations among stored items. Retrieval still relies on similarity, and decisions depend on brittle, nonlearnable prompt heuristics.

MAGMA's Response. Yes Integration Rather Than Opposition: Keep persistent external storage and on-demand loading, but replace unstructured blocks with events bearing four relations, and prompt-based loading decisions with intent classification plus weighted traversal.

Transfer of key designs. The nonblocking fast path and asynchronous slow path recut MemGPT's foreground interaction/background memory management along latency boundaries.

5.3 A-MEM (Xu et al., NeurIPS 2025 main conference, arXiv 2502.12110)

Problem addressed. Inspired by Zettelkasten, memories grow their own network: New memories become structured notes with contextual descriptions, keywords, and tags; the system links them to historical memories, and new entries trigger updates to older representations through memory evolution. The original critique is that basic storage/retrieval lacks sophisticated organization, while fixed operations and structures restrict adaptability. In one sentence: memories should be linked, with both links and content evolving.

Unresolved problem. A-MEM's links are homogeneous: every edge indicates semantic relatedness, still based on embedding similarity. Temporal and causal relations must remain implicit; retrieval remains vector search, with links expanding rather than guiding recall. Table 1 reflects this: A-MEM scores only 0.474 on LoCoMo Temporal, second lowest.

MAGMA's Response. This is Direct Challenge: MAGMA's premise is that homogeneous A-MEM-style links are insufficient. It splits one edge type into four and incorporates type into φ(type(e_ij), T_q). Temporal rises from 0.474 to 0.650 (+37.1%, calculated here).

Transfer of key designs. Generating structured metadata A_i—entities, temporal cues, and context descriptors—at write time directly inherits A-MEM's note format. Memory evolution becomes slow-path confidence updates for causal edges and merging of redundant semantic clusters.

5.4 MemoryOS (Kang et al., EMNLP 2025 Main, Oral, arXiv 2506.06326)

Problem addressed. Organizes memory by lifecycle: short-, mid-, and long-term personal storage with four operators—store, update, retrieve, generate. On LoCoMo with GPT-4o-mini, it reports relative F1 +48.36% and BLEU-1 +46.18%. In one sentence: memory needs explicit hierarchical management and paging policies, beyond a repository.

Unresolved problem. Its hierarchy follows recency and heat rather than relation type: where memories belong and when they are promoted or evicted, rather than how they relate. Serializing four operators synchronously is expensive: Table 3 gives query latency of 32.68 s, which is 22.2 times MAGMA's (calculated here), making interactive use impractical.

MAGMA's Response. Under along two orthogonal axes: Four graphs supply the missing relation axis, while dual streams move expensive operators off the critical path, reducing latency to 1.47s. MemoryOS remains the strongest Open-Domain baseline at 0.504, only 2.6% behind MAGMA, suggesting independent value from hierarchical management.

Transfer of key designs. The principle that different memory operations deserve different treatment remains, but classification changes from temporal tiers to synchronicity through fast/slow paths—a clean repartitioning.

5.5 Zep / Graphiti (Rasmussen et al., arXiv 2501.13956, v1 2025-01-20)

Problem addressed. The first agent-memory system making temporal validity a first-class concept: Graphiti maintains both event time and record time, representing facts that were once true but later superseded. Reported results include DMR 94.8% versus MemGPT 93.4%, up to +18.5% LongMemEval accuracy, and up to 90% lower latency. In one sentence: facts in agent memory have lifetimes, and graphs must represent expiration.

Unresolved problem. Zep makes only A dimension—time—explicit, leaving causality and coreference in shared edge and node attributes. More importantly, retrieval does not change its traversal by question type: It is a smarter graph with a fixed retrieval pipeline.

MAGMA's Response. MAGMA generalizes first-class time into first-class relations, each with its own graph, then adds a layer missing from Zep: query intent determines which graph to traverse. MAGMA can thus be viewed as expanding Zep across dimensions and adding routing.

Transfer of key designs. The temporal skeleton E_temp, an immutable chain strictly ordered by τ, simplifies Zep's timeline. Relative-expression normalization into [τ_s, τ_e] likewise parallels Zep.

5.6 Nemori (Ma, Nan, Wu, Chen; arXiv 2508.03341, v1 August 2025, Retitled in v4 April 2026)

Problem addressed. Addresses what deserves retention, previously handled by designer heuristics, using prediction error as value: predictable interactions need not be stored; failed predictions indicate new knowledge. Its two components turn interactions into structured narratives and extract insights by predictability. In one sentence: write thresholds should depend on surprise rather than manual rules.

Unresolved problem. Nemori concentrates on content selection, after which organization remains structured narrative text and retrieval returns to semantic matching. One concrete failure is Table 1's adversarial score of 0.325, lowest except Full Context. A plausible explanation is that coherent distilled narratives nearly always offer something apparently relevant, encouraging answers despite missing evidence—high-quality compression weakens the visibility of insufficient evidence.

MAGMA's Response. This is the source of §3.2's 98.98%. MAGMA's structured subgraphs and <ref:id> provenance make failure to find evidence a decidable structural fact, such as exhausting causal traversal depth without a relevant node, instead of an ambiguous low similarity. Adversarial rises from 0.325 to 0.742 (+128%, calculated here).

Yet This Is Also Where MAGMA Falls Short. Nemori's narrative compression still leads on multi-hop (0.569 vs 0.528): pre-encoding cross-event relations is more reliable than query-time beam-search assembly.

Transfer of key designs. Nemori is MAGMA's main comparator rather than a technical source. They form a clean contrast: write-time compression (Nemori) versus query-time assembly (MAGMA)—itself a valuable next experiment.

6.1 A Nonlinear Evolution Tree

6.2 Underlying Logic

The driving pattern repeats: each generation makes explicit something previously hidden in similarity or heuristics, introducing a new object that must be managed.

7.1 Theory

7.1.1 Relational Orthogonality Needs a Measurable Definition (High Value, Low Barrier)

§3.6's LOO sum is 1.87× the full-versus-best-single gap, indicating functional coupling, while orthogonality currently means only disjoint edges. Concrete proposal: Use variance decomposition to separate main effects and pairwise interactions across all 2⁴=16 graph subsets on LoCoMo. Construction is needed only once, keeping cost manageable. The resulting interaction matrix would identify redundant and complementary graph pairs—an experiment absent from the field.

7.1.2 Separate Abstention and Capability at the Metric Level (High Value, Low Barrier)

LoCoMo aggregates 22.5% unanswerable and 77.5% answerable examples into one score, allowing a wholly conservative system 0.225 for free. Concrete proposal: Report (Acc_answerable, AbstentionRate_unanswerable) as a pair, then sweep the abstention threshold to plot their trade-off. No new data are needed, only different reporting, but existing rankings could change, as §3.2 illustrates.

7.1.3 Formalizing Write-Time Compression vs Query-Time Assembly

Nemori and MAGMA form a clean contrast. Information-theoretically, the question is where to pay the distortion cost: compression fixes distortion irreversibly at writing; query-time assembly defers it but adds traversal cost. What to Keep, What to Forget has begun applying rate–distortion theory to memory compression, but the timing of compression remains unmodeled. Concrete proposal: Derive distortion lower bounds under a fixed token budget and predict the query distributions at which the strategies cross over.

7.2 Engineering and Applications

7.2.1 Add the Missing Semantic-Only and Zep Baselines (Decisive, Very Low Barrier)

This report considers it the most urgent gap. The multiple-graph superiority claim lacks both its own Semantic-Only null and external single-graph representatives such as Zep/GraphRAG. Concrete proposal: Under In the open-source repository, disable three graphs for Semantic Only and add a Graphiti baseline with identical judge and backbone. This modest experiment could decide the core claim. Until then, multiple graphs > one graph remains unverified.

7.2.2 Report Total Slow-Path Compute, Not Just Query Latency

§3.7 shows that dual streams systematically favor MAGMA in latency and query-token columns. Concrete proposal: All asynchronously consolidated memory systems should report the (query latency, query tokens, background LLM calls per stored event, background tokens per stored event) four-tuple, restoring comparability to low-latency claims.

7.2.3 Investigate Multi-Hop Pruning Failures Directly

MAGMA trails Nemori by 7.2% on multi-hop, supposedly the strength of multiple graphs. Concrete proposal: Sweep beam width × depth (4/8/16 × 3/4/5/6), examining only multi-hop. Unsaturated monotonic improvement supports pruning as the cause, fixable with compute. Otherwise the problem lies in the score's φ interval's cross-graph comparability, with edge types on unnormalized scales—a more substantive modeling defect.

7.2.4 Dynamic Use and Graph Aging

MAGMA's graph grows; slow-path merging removes semantic redundancy, but there is no forgetting or downweighting mechanism. Over months, causal edges may accumulate LLM extraction errors. SSGM already argues that evolving-memory errors accumulate and persist. Concrete proposal: Update causal confidence using later retrieval utility: increase it when retrieved evidence yields correct answers, decrease it after errors. This is a gradient-free precursor to §7.3.1's learned policy.

7.3 Emerging Directions

7.3.1 Learned Traversal Policies (The Most Direct Next Step)

In φ(r, T_q) = w_{T_q}ᵀ·𝟙_r, w could become an RL-learned policy rather than manual settings, while intent moves from {Why, When, Entity} three classes to a continuous representation. MAGMA supplies the action space, and the MemRL line supplies the learning signal. Concrete proposal: Use traversal trajectories as episodes and final-answer judge scores as GRPO rewards—Supersede already raises small-model memory updating from 9.0% to 16.7% with GRPO, demonstrating trainability of memory-operation policies.

7.3.2 Reversible Relational Compression

Salience-based budgeting compresses less relevant nodes into shorthand, irreversibly: mistaken compression cannot be undone. R³Mem is exploring reversible compression. Concrete proposal: Make shorthand expandable during traversal when a branch becomes important, allowing retrieval of original text and revocable compression decisions.

7.3.3 Multiple Views and Multimodality

Four graphs naturally extend to multimodal settings: visual observations carry timestamps and entities but lack directly comparable semantic embeddings. Relative graph importance should therefore change sharply, with stronger temporal/entity weights—exactly where learned weights may beat handcrafted ones.

7.3.4 Security of Relational Graphs

Four graphs create four attack surfaces. Causal edges inferred asynchronously by an LLM receive no human or rule-based verification, making them especially vulnerable: a fabricated causal edge can redirect Why queries toward attacker-chosen nodes. SSGM 's four-dimensional failure taxonomy—Stability, Validity, Efficiency, Safety—offers a framework, but no concrete attack-surface analysis yet targets multi-graph memory. Concrete proposal: Build a causal-edge-poisoning benchmark measuring Why-query hijacking after injection of k fabricated edges.

Three Trends in the Table

1. The Performance Ladder Is Real but Concentrated in Specific Abilities. LoCoMo Overall—A-MEM 0.580 → MemoryOS 0.553 → Nemori 0.590 → MAGMA 0.700—suggests upward progress. But §3.2 attributes almost the entire 2025→2026 jump to abstention calibration; non-adversarial reasoning is nearly unchanged at 0.687→0.688. The field may be on a reasoning plateau concealed by aggregation.
2. Latency Differences Exceed Accuracy Differences. 32.68s (MemoryOS) → 2.59s (Nemori) → 1.47s (MAGMA) spans 22×, while Overall spans only 0.55–0.70. Engineering usability currently differentiates systems more strongly than accuracy but is systematically understated in paper narratives.
3. Formal Publication Is Becoming More Common. Early-2025 work mainly appeared as arXiv technical reports (Zep, GraphRAG), followed by NeurIPS/EMNLP main-track papers in late 2025 (A-MEM, MemoryOS), and ACL long papers in 2026 (MAGMA). The field is moving from engineering communities into mainstream academia.

MemEvolve: Meta-Evolution of Agent Memory Systems (2025-12, ICML 2026)

Optimizes not memory content but the memory system's architecture: EvolveLab decomposes 12 representative systems into encode/store/retrieve/manage modules, then uses agent meta-evolution to adapt architectures, improving SmolAgent/Flash-Searcher by up to 17.06%. If learned policies are next (§7.3.1), this is a comprehensive precursor.
arXiv | Code

MemRL: Self-Evolving Agents via Runtime Reinforcement Learning on Episodic Memory (2026-01, arXiv)

Uses RL for runtime evolution of episodic memory without weight updates. Two-stage retrieval filters noise then identifies useful strategies, surpassing SOTA on HLE, BigCodeBench, ALFWorld, and LifelongAgentBench. It provides a ready technical foundation for learning MAGMA traversal.
arXiv | Code

Supersede: Diagnosing and Training the Memory-Update Gap in LLM Agents (2026-06, arXiv)

Treats failure to retain updated facts as an isolated, measurable gap: LongMemEval knowledge-update falls from 92% with full context to 77% with bounded self-maintained memory (gpt-5.4, p=0.0033), and larger memory does not restore performance(28%→28%), indicating a policy rather than capacity issue. GRPO fine-tuning Qwen2.5-3B raises held-out accuracy from 9.0% to 16.7%. A particularly clean demonstration that memory operations are trainable, directly supporting §7.3.1.
arXiv

How Memory Management Impacts LLM Agents: An Empirical Study of Experience-Following Behavior (2026-07, ACL 2026 Main Conference, Long Paper)

Identifies experience following: more similarity between retrieved memory and current input produces more similar outputs. This yields error propagation and mismatched experience replay; using future task outcomes as retrospective quality labels for stored experience improves long-term performance. Complementary to MAGMA: how to retrieve versus the quality of retrieved material.
ACL Anthology

H-MEM: Hierarchical Memory for High-Efficiency Long-Term Reasoning in LLM Agents (2026-03, EACL 2026 Long)

Using semantic abstraction level organizes memory hierarchically; higher-level vectors encode positional indexes to lower-level memories, enabling layerwise routing without exhaustive similarity computation. A contemporary alternative in structured retrieval: MAGMA organizes horizontally by relation, H-MEM vertically by abstraction. In principle, they combine.
ACL Anthology

From Recall to Forgetting: Benchmarking Long-Term Memory for Personalized Agents (Memora) (2026-04, arXiv)

A benchmark spanning weeks of conversations, including consolidation and mutation, with FAMA metrics that penalize reliance on outdated information. Memory agents achieve aggregate FAMA 119.45 for remembering versus LLMs' 65.60–65.80, but only 27.55 for reasoning versus 12.37–13.92—remembering is easier than reasoning, consistent with this report's §3.2 finding.
arXiv

ForgetBench: Benchmarking Forgetting Dynamics of Long-Term Parametric Memory (2026-07, arXiv)

On the parametric-memory side, this work evaluates retention under sequential knowledge edits. AlphaEdit reaches 0.92 editing success on Qwen-2.5 7B but has a memory half-life of only 452 steps; stability-oriented WISE succeeds below 0.12. The retention-versus-effectiveness trade-off parallels compression versus decidability in external memory.
arXiv

Governing Evolving Memory in LLM Agents: the SSGM Framework (2026-03, arXiv)

Memory governance and security: a four-dimensional Stability / Validity / Efficiency / Safety taxonomy argues for decoupling memory evolution from execution, adding validation gates and temporal decay. The claim that evolving-memory errors accumulate and persist directly targets MAGMA's unguarded slow-path causal inference (§7.3.4).
arXiv

What to Keep, What to Forget: A Rate–Distortion View of Memory Compaction (2026-07, arXiv)

A rate–distortion framework for memory compression, directly related to §7.1.3's timing question: it models how much to compress, but not when to compress.
arXiv