RGMem: Renormalization Group-inspired Memory Evolution for Language Agents

AI summary

Overview

Research area: Long-term memory and personalization for LLM-based conversational agents, sitting at the intersection of retrieval-augmented generation, explicit memory systems, and ideas borrowed from theoretical physics (the renormalization group).

Technical level: Advanced. The paper combines formal notation (effective Hamiltonians, order parameters, renormalization operators) with systems engineering; the underlying intuition is graspable, but the formalism is dense.

Scope: The paper proposes and evaluates a self-evolving, multi-scale memory framework (RGMem) that organizes an agent's long-term conversational memory into layers of increasing abstraction, and tests it on two long-term memory benchmarks.

What This Paper Is About

Conversational agents built on LLMs are expected to remember users across many sessions, but interaction histories grow without bound while the model's context window does not, and static model parameters cannot be updated incrementally. Existing memory and retrieval systems mostly work at the fact level, so they are dominated by keyword overlap and recency bias and struggle to distill stable, higher-level user traits from evolving and sometimes contradictory dialogue. RGMem's goal is to model long-term memory as a multi-scale evolutionary process in which fast-changing episodic evidence is progressively compressed into slowly varying user traits.

Key Contributions

1. A renormalization-group lens for conversational memory. The authors frame long-term personalization as a multi-scale problem and adapt renormalization group (RG) concepts — hierarchical coarse-graining, rescaling, and flow — as an engineering principle rather than a physical model. They state four guiding insights: effective information density is maximized via hierarchical coarse-graining; user profile updates exhibit phase-transition-like dynamics; separating slow and fast variables resolves the stability–plasticity dilemma; and long-term profiles exhibit macroscopic invariance beyond fact-level stability. They also provide formal analytics for these insights in Appendix D (Propositions D.1–D.3).

2. A concrete multi-scale memory architecture (L0–L2). RGMem separates the memory state into discrete episodic units (denoted D_L0) and a dynamic hierarchical knowledge graph (G = (V, E)), with graph nodes split into abstract concepts, general events, and instance events, and edges split into static classification relations and dynamic event relations.

3. Scale-aware evolution operators with thresholded updates. Three operators drive profile evolution: R_K1 (relation-level incremental integration), R_K2 (node-level abstraction, decomposed into projection–selection and synthesis–rescaling, producing an order parameter Σ and a correction term Δ), and R_K3 (hierarchical flow that propagates child-level summaries to parent nodes via a dirty-flag mechanism). R_K1 and R_K2 fire only when accumulated evidence passes thresholds θ_inf and θ_sum.

4. Empirical validation on two benchmarks with a published code release. Experiments on LOCOMO and PersonaMem against baselines including RAG, LangMem, Mem0, Zep, A-Mem, Memory OS, Full-Context, and a vanilla LLM. The paper reports improvement of 7.08 points on LOCOMO and 8.98 points on PersonaMem over the best baseline, and the code is available at https://github.com/fenhg297/RGMem.

Main Findings

• RGMem leads the benchmark tables. On PersonaMem with a GPT-4o-mini backbone, RGMem reaches 63.87 average versus the second-best baseline, Memory OS, at 54.23 (a +7.08 gain). With a GPT-4.1 backbone it reaches 74.01 average versus Memory OS at 65.03 (a +8.98 gain). In parentheses, the paper reports per-category gains; on GPT-4o-mini the largest are +7.22 on the "Evol." column and +5.84 on "Reasons".

• Strong temporal and multi-hop performance on LOCOMO. Under LLM-as-a-judge evaluation with GPT-4o-mini, RGMem averages 78.92 versus Zep at 75.14, Mem0 at 66.88, LangMem at 58.10, RAG at 38.10, and Full-Context at 71.41. With GPT-4.1-mini, RGMem averages 86.17 versus Zep at 79.09, LangMem at 78.05, Mem0 at 62.47, RAG at 51.62, and Full-Context at 87.52 — so in that single setting Full-Context scores higher than RGMem, while RGMem exceeds every listed memory baseline.

• There is an optimal context scale, not a monotonic "more context is better" effect. On LOCOMO, reasoning performance improves as retrieved context grows from approximately 3k to 3.8k tokens, then saturates and degrades with further context. The authors argue this reflects scale selection rather than brute-force context expansion.

• A sharp performance peak at a single threshold value. Performance as a function of the evolution threshold θ_inf is non-monotonic, peaking sharply at θ_inf = 3 on both LOCOMO and PersonaMem. Below 3 (subcritical regime) the system is overly sensitive to transient noise; above 3 (supercritical regime) updates are excessively suppressed and the profile becomes rigid. The authors call θ_inf a control parameter and task performance an observable order parameter, and highlight the shared critical threshold across two different benchmarks as evidence of universality.

• RGMem lies beyond the baseline stability–plasticity Pareto frontier. On PersonaMem, most baselines trade off Recall Facts against Latest Preference. RGMem is reported to perform better on both simultaneously, which the authors interpret as separating slow-varying traits from fast-changing observations rather than forcing all information to evolve at one scale.

• Ablations and sensitivity checks support the design. The paper reports that removing any core component of the multi-scale memory design consistently degrades performance even when more context is retrieved, and that RGMem remains stable across a broad range of retrieval budgets and evolution thresholds with a clear optimal regime. It also reports that under consistent long-term evidence, profile representations rapidly converge and stabilize, exhibiting attractor-like behavior.

• Two emergent dynamical regimes. Under consistent reinforcing evidence, higher-level profile representations stabilize and updates from new interactions diminish. When accumulated evidence becomes strong and inconsistent with the current profile, higher-level representations restructure in a coordinated way, producing a rapid shift rather than incremental adjustment.

Methodology in Plain English

RGMem treats a user's memory as a layered system that is continuously compressed as it moves upward, much like summarizing a long book by repeatedly condensing chapters into themes.

Building the raw material (L0). Incoming dialogue is segmented and synthesized into individual "episodic" memory units, each carrying an objective event-level fact plus a set of user-related conclusions, split into directly grounded interpretations and high-salience signals. These units are organized into a dynamic knowledge graph whose nodes come in three kinds — concrete instance events, general recurring events, and abstract user concepts — and whose edges separate static classification relations from dynamic event relations.

Evolving the profile (L1). Three operators do the work. The first merges repeated evidence about the same relation (for example, a recurring preference) into a stable relation-level summary, but only once enough evidence has accumulated to pass a threshold, so isolated observations do not trigger abstraction. The second operator works one level up: for an abstract concept node, it filters mixed-scale evidence (favoring already-aggregated summaries over raw observations), then synthesizes an updated representation consisting of an "order parameter" that captures dominant recurring patterns and a "correction term" that preserves salient but non-universal signals — explicitly representing internal tension or conflicting behavior. The third operator pushes summaries upward through the static concept hierarchy from child nodes to parents, scheduled with a dirty-flag mechanism so updates stay incremental.

Retrieving and answering (L2). Given a query, the system structures it into entity queries, retrieves episodic evidence from L0 with BM25 and graph-based context from L1, formats both into one context, and passes that to the LLM. This lets simple fact questions draw on fine-grained evidence while broader questions draw on aggregated profile-level structure within a bounded context.

Conceptual objective. The authors describe an "effective Hamiltonian" combining penalties for internal contradictions, deviation from accumulated evidence, and redundant or fragmented representations. They stress it is not explicitly optimized — it is a design compass, since optimizing directly over high-dimensional textual memory is intractable. RGMem is a heuristic approximation of minimizing it across abstraction levels.

Why This Matters

Impact on research. The paper argues that robust long-term personalization comes from principled multi-scale organization rather than larger context windows or fact accumulation. It provides a vocabulary — coarse-graining, thresholded phase transitions, slow versus fast variables, macroscopic invariants — for studying memory evolution as a dynamical system, and reports a critical threshold shared across two different benchmarks, which invites further work on whether such critical points are intrinsic to multi-scale memory.

Real-world applications:

• Long-running personal assistants that must remember a user's stable preferences over months while adapting when those preferences genuinely change.
• Customer-support or coaching agents that need consistent, auditable user profiles across many sessions and must not be derailed by a single contradictory remark.
• Companion or health-adjacent conversational agents where traced, rollback-able memory is preferable to opaque latent memory.
• Multi-hop and temporal question answering over long personal or organizational dialogue archives.

Industry relevance. The framework is model-agnostic and works with both GPT-4o-mini and GPT-4.1 as backbones, meaning it can be layered on closed-source APIs without fine-tuning. Because it externalizes memory in an explicit graph with thresholds and dirty-flag updates, it offers auditability and controlled, incremental cost — an important property for product teams who cannot retrain models per user. The reported context saturation around 3k–3.8k tokens is directly relevant to inference cost planning.

Future Directions

• Understanding why θ_inf = 3 is critical. The same threshold performed best on both LOCOMO and PersonaMem; whether this value is intrinsic to the dynamics or an artifact of the evaluated models and data remains an open question the paper explicitly frames as universality.
• Extending beyond two benchmarks and two backbones. Validation is limited to LOCOMO and PersonaMem (128k-token setting) with GPT-4o-mini and GPT-4.1-style backbones; generalization to other domains, languages, and model families is untested in the presented content.
• Making the phase-transition claim testable. The theoretical results (Propositions D.1–D.3) support the insights analytically, but the paper notes the effective Hamiltonian is not optimized directly; developing measurable proxies for it could sharpen both theory and system design.
• Handling abrupt preference shifts and computational cost. The appendix lists analyses of robustness to abrupt profile mutations and preference shifts (B.7) and computational cost and efficiency (B.9), alongside error isolation case studies (Appendix C) — directions whose reported details fall outside the provided content and that suggest natural follow-up work on reliability and scaling.

Target Audience

Researchers and practitioners working on LLM agent memory, long-term dialogue personalization, and retrieval-augmented generation who are comfortable with formal modeling; also relevant to engineers designing persistent user-profile systems for production agents, and to readers interested in cross-disciplinary transfers from statistical physics into machine learning. Readers seeking a quick implementation recipe will find the algorithmic description concrete, but the full theoretical justification and detailed experimental protocols live in appendices that are only referenced in the provided content.

Authors’ abstract

Personalized and continuous interactions are critical for LLM-based conversational agents, yet finite context windows and static parametric memory hinder the modeling of long-term, cross-session user states. Existing approaches, including retrieval-augmented generation and explicit memory systems, primarily operate at the fact level, making it difficult to distill stable preferences and deep user traits from evolving and potentially conflicting dialogues.To address this challenge, we propose RGMem, a self-evolving memory framework inspired by the renormalization group (RG) perspective on multi-scale organization and emergence. RGMem models long-term conversational memory as a multi-scale evolutionary process: episodic interactions are transformed into semantic facts and user insights, which are then progressively integrated through hierarchical coarse-graining, thresholded updates, and rescaling into a dynamically evolving user profile.By explicitly separating fast-changing evidence from slow-varying traits and enabling non-linear, phase-transition-like dynamics, RGMem enables robust personalization beyond flat retrieval or static summarization. Extensive experiments on the LOCOMO and PersonaMem benchmarks demonstrate that RGMem consistently outperforms SOTA memory systems, achieving stronger cross-session continuity and improved adaptation to evolving user preferences. Code is available at https://github.com/fenhg297/RGMem