Personalization for Large Language Models: Memory, Context Summarization, Retrieval and Ranking, and Adjacent Mechanisms

Personalization for LLMs is the adaptation of model behavior and outputs to an individual user’s history, preferences, persona, and situational context. As of mid-2026, the field has consolidated around a clear divide: non-parametric methods (prompt-based profiles, retrieval-augmented generation over user history, and external memory stores) dominate production because they are cheap, auditable, and instantly updatable, while parametric methods (per-user PEFT/LoRA adapters, personalized RLHF/DPO) deliver stronger fits to complex behavior but scale poorly to millions of users.

The 3 pillars — memory, context summarization, and retrieval/ranking — are not independent techniques but stages of a single pipeline: memory decides what to store, summarization/compression decides how densely to store and inject it, and retrieval/ranking decides what to surface at inference time. The dominant empirical finding across LongMemEval, LoCoMo, and LaMP is that retrieval quality bounds personalization quality: long-context LLMs show a 30–60% performance drop on LongMemEval-S when relevant facts are buried in long histories (Wu et al., 2024), and lossy summarization compounds errors. This report is deliberately critical: memory write policies remain heuristic, recall on implicit preferences is poor, the long-context-versus-RAG debate is unresolved, personalization measurably worsens sycophancy and echo-chamber effects, and persistent memory has opened a new and demonstrated attack surface (memory poisoning via prompt injection).

1. Problem Framing and Taxonomy

1.1 Definition from first principles

A base LLM implements a conditional distribution p(y | x) over outputs y given input x, trained to approximate an “average user.” Personalization redefines the target as p(y | x, u), where u captures a specific user’s history, preferences, persona, and context. There are only three places to inject u:

• Input level (non-parametric): prepend retrieved history or a natural-language profile to x. Surveyed by Zhang et al. (2024, “Personalization of Large Language Models: A Survey,” arXiv:2411.00027) and Liu et al. (2025, “A Survey of Personalized Large Language Models,” arXiv:2502.11528), which frames the space as prompting (input), finetuning (model), and alignment (objective).
• Model level (parametric): encode u in weights via fine-tuning or per-user adapters.
• Objective level (parametric): condition the reward/preference model on u (personalized RLHF/DPO, pluralistic alignment).

1.2 Trade-offs

Dimension Non-parametric (prompt/RAG/memory) Parametric (PEFT/RLHF per user) Marginal cost per user Storage + retrieval only Training + adapter storage Update latency Instant (write to store) Requires retraining Staleness Low High between retrains Scalability to millions High Poor (parameter footprint grows with user count) Privacy Data stays external, deletable User data baked into weights Catastrophic forgetting N/A Risk Ceiling on personalization depth Bounded by retrieval recall Higher; captures complex patterns

Salemi and Zamani (2024, arXiv:2409.09510) directly compare retrieval-augmentation vs. PEFT for privacy-preserving personalization; the consensus is that RAG is preferred when relevant history exists and is retrievable, while fine-tuning wins when retrieved instances are not highly relevant to the query (a finding OPPU builds on).

2. LLM Memory Systems

2.1 Cognitive taxonomy and the short-term/long-term split

The literature borrows from human memory: episodic (specific past events/interactions), semantic (distilled facts about the user), and procedural (learned behaviors/skills). Practically, systems distinguish short-term (in-context) memory — the live context window — from long-term (external) memory — databases, vector indices, or knowledge graphs queried at inference. Surveys: “A Survey on the Memory Mechanism of LLM-based Agents” and “From Human Memory to AI Memory: A Survey on Memory Mechanisms in the Era of LLMs” (arXiv:2504.15965).

2.2 MemGPT / Letta (virtual context management)

MemGPT (Packer, Wooders, Lin, Fang, Patil, Stoica, Gonzalez, 2023, “MemGPT: Towards LLMs as Operating Systems,” arXiv:2310.08560) introduced virtual context management, an OS-inspired memory hierarchy. It separates main context (the prompt buffer: system instructions, a read/write working-context scratchpad, and a FIFO message queue) from external context (recall storage of all past messages plus vector-indexed archival storage). The agent moves data between tiers via function calls (archival_memory_search, core_memory_append), and recursive summarization compresses the queue when it nears capacity. MemGPT is now maintained as Letta (since September 2024); a MemGPT agent is defined by its two-tier memory and self-editing memory via tool use.

2.3 Generative agents memory stream (recency-relevance-importance)

Park, O’Brien, Cai, Morris, Liang, Bernstein (2023, “Generative Agents: Interactive Simulacra of Human Behavior,” UIST ’23) established the de facto standard retrieval scoring for agent memory. Each observation is stored in natural language in a memory stream with a timestamp and last-access time. Retrieval ranks memories by a weighted sum of three signals: recency (exponential decay since last access), importance (an LLM-assigned salience score, 1–10, at write time), and relevance (embedding cosine similarity to the query). Reflection synthesizes raw observations into higher-level insights stored back in the stream. The paper’s key thesis — that believable long-horizon behavior depends more on the external memory architecture than on the base model — has propagated to MemGPT, Mem0, and LangGraph.

2.4 MemoryBank (Ebbinghaus forgetting curve) and A-Mem (Zettelkasten)

MemoryBank (Zhong, Guo, Gao, Ye, Wang, 2024, AAAI; arXiv:2305.10250) adds a memory-updating mechanism inspired by the Ebbinghaus forgetting curve: memory strength decays exponentially with elapsed time but is reinforced on recall, so frequently accessed memories persist and stale ones fade. It stores daily event summaries plus a global user profile, retrieves via FAISS-indexed dense representations, and powers the “SiliconFriend” companion chatbot. A-Mem (Xu et al., 2025, arXiv:2502.12110) introduces a self-organizing, Zettelkasten-inspired memory: each interaction is an atomic note with structured attributes, and the system dynamically creates and updates links between notes to form an evolving knowledge network.

2.5 Zep / Graphiti (temporal knowledge graphs)

Zep (Rasmussen, Paliychuk, Beauvais, Ryan, Chalef, 2025, “Zep: A Temporal Knowledge Graph Architecture for Agent Memory,” arXiv:2501.13956) is built on Graphiti, a temporally-aware knowledge-graph engine with three subgraphs — episode (raw, non-lossy), semantic entity, and community — mirroring episodic/semantic memory. Its distinguishing feature is bitemporal modeling: every fact carries a validity interval, so when facts change the graph is updated rather than overwritten, preserving history. Reported results: on the Deep Memory Retrieval (DMR) benchmark Zep reaches 94.8% vs. MemGPT’s 93.4%. On LongMemEval (gpt-4o), Zep reports 71.2% overall accuracy at ~2.6s latency vs. 60.2% for full-context at ~29s (roughly 10x faster), with its largest gains on temporal reasoning (+17.3 percentage points) and multi-session QA (+13.6 pp). Note these are vendor-reported figures on the ~115,000-token LongMemEval_S subset and are not third-party verified.

2.6 Mem0 (extraction-consolidation-retrieval pipeline)

Mem0 (Chhikara, Khant, Aryan, Singh, Yadav, 2025, “Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory,” arXiv:2504.19413, ECAI 2025) uses a two-phase pipeline: (1) an LLM extracts salient facts from conversation and writes them to the store; (2) at query time it retrieves top-K relevant memories to inject. On LoCoMo, Mem0 reports a 26% relative uplift in overall LLM-as-a-Judge score over OpenAI’s memory feature — 66.9% versus 52.9% — with p95 latency of 1.44s versus 17.12s for full-context and roughly 1.8K versus 26K tokens consumed per interaction (a >90% token reduction). A graph-memory variant adds ~2% to the overall score. As of mid-2026 Mem0 reports a token-efficient algorithm scoring 92.5 on LoCoMo and 94.4 on LongMemEval under ~7,000 tokens per retrieval call.

Get Chier Hu’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Critical caveat: These vendor numbers are contested. Both Letta and Zep have publicly challenged Mem0’s benchmark methodology. An independent controlled study noted that “90% token savings” measures memory footprint compression (e.g., 26,000 tokens of history condensed to ~1,800 tokens of facts), not downstream task speedup, and that on smaller corpora (≤~150 conversations) hybrid block-extract-and-summarize approaches achieve 70–82% recall vs. Mem0’s 30–45%. Most damaging, an independent evaluation (“Beyond the Context Window,” arXiv:2603.04814) found that long-context GPT-5-mini significantly outperforms the Mem0 memory system on both LoCoMo and LongMemEval: on LongMemEval the Mem0-based system scored 49.00% (roughly on par with GPT-OSS-120B’s 48.20%), while a full-context read was both more accurate and cheap (~$0.0013/query). On temporal reasoning specifically, Mem0 (49.0%) trailed Zep’s Graphiti (63.8%) in the Atlan 2026 comparison. The ordering thus flips relative to Mem0’s own numbers — underscoring that memory-system rankings are highly sensitive to judge model, granularity, and retrieval-K.

2.7 HippoRAG (hippocampal indexing, personalized PageRank)

HippoRAG (Gutiérrez et al., 2024, NeurIPS; arXiv:2405.14831) is inspired by the hippocampal indexing theory. Offline, an LLM (“neocortex”) converts a corpus into a schemaless knowledge graph (the “hippocampal index”); online, it extracts query entities, links them to graph nodes, and runs the Personalized PageRank (PPR) algorithm seeded on those nodes to propagate relevance through the neighborhood, enabling single-step multi-hop retrieval. Reported to outperform prior RAG methods on multi-hop QA by up to 20%. Node-specificity weighting biases retrieval toward rare/distinctive facts.

2.8 Memory write policy, consolidation, conflict resolution, forgetting

The write policy (what to store) remains the least principled component: generative agents use LLM-rated importance, Mem0 uses LLM salience extraction, MemGPT lets the agent decide via tool calls. Consolidation (Letta’s sleep-time compute; §9) merges fragments offline. Conflict resolution for contradictory facts over time is handled structurally by Zep’s bitemporal validity intervals and by Mem0’s add/update/delete operations based on semantic similarity — but this is still brittle. Forgetting/decay is modeled explicitly by MemoryBank (Ebbinghaus) and Mem0’s memory-decay re-ranking (with tunable eviction thresholds, default ~0.15).

2.9 Production memory (ChatGPT, Claude, Gemini)

• ChatGPT (OpenAI): Persistent memory launched May 2024 as the “Bio” tool storing explicit user facts; in April 2025 OpenAI added cross-chat “reference chat history.” A 2025 background consolidation process (informally called “dreaming”) periodically synthesizes patterns across conversations. OpenAI’s system automatically injects prior-conversation details at the start of every conversation.
• Claude (Anthropic): “Search and reference chats” rolled out mid-August 2025; a fuller memory feature (September 2025) generates a memory summary synthesized every 24 hours, scoped per Project, fully user-viewable and editable, with incognito chats. Architecturally distinct: Claude starts each chat blank and only recalls by searching raw conversation history via two tools (conversation_search, recent_chats) — no AI-generated compressed profile by default (per Simon Willison's analysis, Sept 2025).
• Gemini (Google): The March 13, 2025 official blog announced an experimental personalization capability, powered by Gemini 2.0 Flash Thinking Experimental, that “connects with your Google apps and services, beginning with Search, to deliver responses that are even more tailored to your individual needs” (e.g., referencing recent food-related searches for restaurant recommendations); it is opt-in, requires Web & App Activity on, and can be disconnected at any time. Google later introduced a “Personal context” setting that “allows Gemini to learn from your past conversations over time,” on by default with user controls, alongside Temporary Chats (72-hour, non-personalizing, non-training). Personal context first rolled out on Gemini 2.5 Pro in select countries (excluding EEA/UK/Switzerland).

2.10 Memory benchmark numbers

LongMemEval (Wu et al., 2024, arXiv:2410.10813, ICLR 2025) reports that long-context LLMs show a 30–60% performance drop on LongMemEval-S, and that commercial memory-augmented systems on GPT-4o (ChatGPT and Coze) showed 37% and 64% performance drops respectively versus direct context reading. LoCoMo (Maharana et al., 2024) shows even the strongest systems have a ~40–50 percentage-point gap to human factual recall, worst on temporal and multi-hop reasoning.

3. Context Summarization and Compression

3.1 Recursive/hierarchical/rolling summarization

Production chat systems maintain rolling summaries: as the context fills, older turns are recursively summarized into a running digest (MemGPT’s recursive summarization of its FIFO queue is the canonical example). The trade-off is summary vs. verbatim memory: summaries are dense but lossy and can hallucinate; verbatim recall (Claude’s approach) is faithful but token-expensive. LoCoMo evidence shows over-reliance on naive session summaries degrades factual recall.

3.2 Soft-prompt / gist compression

• Gist tokens (Mu, Li, Goodman, 2023, “Learning to Compress Prompts with Gist Tokens”): fine-tune an LLM to distill a prompt into a small set of reusable “gist” tokens, achieving up to 26x compression with FLOP reductions up to 40%.
• AutoCompressor (Chevalier et al., 2023): recursively compresses long contexts into summary vectors used as soft prompts, handling sequences up to 30,720 tokens; trained with full fine-tuning.
• ICAE (Ge et al., 2024): an in-context autoencoder with a learnable LoRA encoder and a frozen LLM decoder; compresses up to 512 tokens into 32/64/128 memory slots (4x–16x), usable directly by the untuned LLM.
• Successors: 500xCompressor (KV-value carriers, higher ratios) and xRAG (extreme, up to 178x, single-token modality fusion).

3.3 LLMLingua family (extractive prompt compression)

LLMLingua (Jiang et al., 2023, Microsoft Research) is a coarse-to-fine, perplexity-based, black-box-compatible compressor: a budget controller allocates compression across prompt components, then iterative token-level compression drops low-information tokens. It reports up to 20x compression with minimal loss (GSM8K EM dropping <2 points at 14x–20x). LongLLMLingua adds question-aware compression, document reordering, and dynamic ratios, reporting up to 21.4% improvement on NaturalQuestions multi-document QA at 4x compression, 1.4x–2.6x latency speedups, and up to 94.0% cost reduction on LooGLE — while explicitly mitigating lost-in-the-middle. LLMLingua-2 reframes compression as token classification via a BERT-size model distilled from GPT-4, reducing end-to-end latency up to 2.9x at 2x–5x ratios.

3.4 Long context vs. summarization: is the debate settled?

No. The “lost-in-the-middle” effect (Liu, Lin, Hewitt, Paranjape, Bevilacqua, Petroni, Liang, 2024, TACL; arXiv:2307.03172) shows a U-shaped accuracy curve — LLMs recall information best at the beginning and end of context and degrade >30% when the answer document moves from position 1 to the middle (position 10 of 20) in multi-document QA; the effect replicated across six model families (GPT-3.5-Turbo, GPT-4, Claude 1.3, LongChat-13B, MPT-30B, Cohere Command). The architectural cause is RoPE’s long-term decay plus softmax attention concentration on primacy/recency tokens. RULER (Hsieh et al., 2024) shows most long-context models fail to maintain performance beyond a fraction of advertised context length. Combined with cost scaling roughly linearly (attention quadratically) with context length and ~17s p95 latency for full-context memory, this means 1M-token windows do not obviate summarization/retrieval — they change the trade-off but not the conclusion. This is why memory systems that extract, compress, and retrieve continue to beat naive full-context stuffing on both cost and, often, accuracy.

4. Retrieval and Ranking for Personalization

4.1 LaMP and the retrieval-bounds-personalization thesis

LaMP (Salemi, Mysore, Bendersky, Zamani, 2023/2024, “LaMP: When Large Language Models Meet Personalization,” arXiv:2304.11406, ACL 2024) is the foundational benchmark: seven tasks (three classification, four short text generation) each with per-user profiles, in user-based and time-based splits. It established that profile-augmented LLMs outperform non-personalized ones and studied term-matching (BM25), semantic (Contriever), and time-aware retrieval. The follow-on optimization work (Salemi, Kallumadi, Zamani, 2024, SIGIR) advanced SOTA on six of seven tasks, averaging 5.5% improvement, and 1.0%–33.8% (avg 15.3%) over non-personalized LLMs.

4.2 Long-form and graph-based extensions

LongLaMP (Kumar, Viswanathan, Yerra, Salemi, Rossi, Dernoncourt, Deilamsalehy, Chen, Zhang, Agarwal, Lipka, Nguyen, Nguyen, Zamani, 2024, arXiv:2407.11016) extends personalization to long-form generation with four tasks (personalized email completion, abstract generation, review writing, topic writing); retrieval augmentation yields improvements between 5.7% and 128% across metrics vs. non-personalized baselines (e.g., a 101.8% ROUGE-L gain on email completion with two retrieved profiles, 86.2% in the temporal setting). PGraphRAG (Au, Dimacali, Pedirappagari, Park, Dernoncourt, Wang, Kanakaris, Deilamsalehy, Rossi, Ahmed, 2025, “Personalized Graph-Based Retrieval for Large Language Models,” arXiv:2501.02157) builds user-centric knowledge graphs that include reviews by neighboring users on shared items to address cold-start; on its 12-task benchmark it beats the LaMP RAG baseline by up to +32.1% ROUGE-1, +21.7% ROUGE-L, and +25.7% METEOR on Hotel Experience Generation (LLaMA-3.1–8B-Instruct). LaMP-QA (Salemi and Zamani, 2025, EMNLP) covers personalized long-form QA.

4.3 Ranking signals and re-ranking

Personalized ranking fuses semantic relevance (dense embeddings), recency, importance/salience, and frequency — the generative-agents triad generalized. Dense (Contriever, BGE-m3) vs. sparse (BM25) retrieval trade recall differently by task (BM25 often better for lexical/title matching). Cross-encoder and LLM-based re-rankers refine top-K. Zep retrieves 20 edges/nodes and applies multi-strategy re-ranking. Time-aware retrieval and query rewriting conditioned on the user profile (LongMemEval’s time-aware query expansion and fact-augmented key expansion) materially improve recall.

4.4 Chunking, indexing, and the recall ceiling

LongMemEval’s unified indexing/retrieval/reading framework shows value granularity matters: decomposing sessions into rounds or extracting per-user facts substantially boosts retrieval-augmented QA over whole-session chunks. The overarching lesson: retrieval recall is the binding constraint — a fact that is never retrieved cannot be used, and implicit-preference recall (inferring unstated preferences) is where all current systems are weakest.

5. Preference Modeling and Alignment-Based Personalization

5.1 Why standard RLHF fails individuals

Standard RLHF fits a single Bradley-Terry (BTL) reward model to aggregated preferences, effectively optimizing for the “average user.” When preferences conflict, this can produce a reward model inaccurate for all groups (Poddar et al., 2024). This motivates pluralistic alignment.

5.2 Personalized reward modeling

• VPL (Poddar, Wan, Ivison, Gupta, Jaques, 2024, “Personalizing RLHF with Variational Preference Learning,” NeurIPS 2024; arXiv:2408.10075): infers a user-specific latent variable and conditions the reward model and policy on it.
• PAL (Chen et al., 2024): represents each user as a point in a latent preference space, defining reward by distance; sample-efficient and generalizes to new users.
• PReF / reward factorization (arXiv:2503.06358): factorizes rewards for efficient personalization.
• PLUS (2025, arXiv:2507.13579): uses RL to learn text-based summaries of each user that condition the reward model, reporting 11–77% improvement in reward-model accuracy over BTL and a 72% vs. 28% win rate against default GPT-4o.

5.3 Parametric per-user methods

• OPPU (Tan, Zeng, Tian, Liu, Yin, Jiang, 2024, “Democratizing LLMs via Personalized PEFT,” EMNLP 2024; arXiv:2402.04401): One PEFT (LoRA) module per user (<1% of base params), combining parametric user knowledge with retrieval/profiles; outperforms prompt-based methods across all seven LaMP tasks and handles behavior shifts better.
• HYDRA (Zhuang et al., 2024, NeurIPS): factorizes into a frozen shared backbone (collective knowledge) plus user-specific heads for black-box personalization.
• P2P / Profile-to-PEFT (Tan et al., 2025, arXiv:2510.16282): a hypernetwork generates per-user adapters in one forward pass, addressing OPPU’s scalability bottleneck (a unique module trained per user is impractical for millions of users).

5.4 Effectiveness comparison

Prompt/RAG methods: cheapest, most updatable, privacy-friendly, but bounded by retrieval and prone to distraction by irrelevant history (Shi et al., 2023). PEFT-per-user: stronger on complex/shifting patterns, but parameter footprint grows with user count. Alignment-based: best for genuine preference conflicts, but expensive and data-hungry.

6. Evaluation

• LaMP (7 tasks), LongLaMP (4 long-form tasks), LaMP-QA — personalized generation/classification, ROUGE/accuracy/MAE metrics.
• LongMemEval — 500 questions, five memory abilities (information extraction, multi-session reasoning, temporal reasoning, knowledge updates, abstention); Recall@k, NDCG@k, QA accuracy.
• LoCoMo (Maharana et al., 2024) — ~50 conversations, ~300 turns/~9K–26K tokens each, single-hop/multi-hop/temporal/open-domain/adversarial; F1, BLEU, ROUGE, LLM-as-judge.
• PersonaMem (Jiang et al., 2025, arXiv:2504.14225) — 180+ interaction histories, ~6,000 MC queries across 32k/128k/1M token settings; seven personalization abilities including preference evolution.
• PrefEval (Zhao et al., 2025, arXiv:2502.09597) — preference inference/memorization/following in long context.
• PersonaFeedback (arXiv:2506.12915), HaluMem (memory hallucinations), MemBench, PersonaChat.

Known weaknesses: heavy reliance on synthetic human-LLM dialogues creates a distributional gap from real interactions (homogeneous conversations lacking implicit expression); LLM-as-judge sensitivity; benchmark-methodology disputes (Mem0 vs. Letta/Zep); and metric mismatch (ROUGE/BLEU poorly capture personalization quality in long-form generation, motivating EXPERT-style evaluators).

7. Systems and Production Considerations

Write path: extraction (LLM salience) → deduplication → consolidation/summarization → conflict resolution → indexing (vector + optional graph). Every Mem0 add/update requires an LLM call, adding write latency and cost. Read path: query rewriting → retrieval (dense/sparse/graph) → ranking (relevance + recency + importance) → re-ranking → injection into prompt. Budgets: memory retrieval can cut token cost >90% and keep responses sub-2s (Mem0’s 1.44s p95) vs. full-context (17.12s p95). Cross-session identity and multi-device sync: memory is partitioned by user/agent/session scope. Memory hygiene: scheduled self-curation passes to prune near-duplicate entries from extraction pipelines.

Privacy/security: This is the most serious operational risk. Security researcher Johann Rehberger demonstrated in 2024 that ChatGPT’s Bio memory tool could be invoked via indirect prompt injection from websites, documents, or images — dubbed “SpAIware” — persisting malicious instructions across sessions to continuously exfiltrate conversations (detailed in “Trust No AI: Prompt Injection Along the CIA Security Triad,” arXiv:2412.06090). OpenAI issued a partial fix (the url_safe mechanism), but prompt-injection into memory remains possible. Rehberger demonstrated an analogous false-memory injection against Gemini in February 2025 via a poisoned document with delayed tool invocation. In 2025–2026, Radware’s “ZombieAgent” showed ChatGPT connectors + memory can make indirect prompt injection persistent and widespread. Additional concerns: PII handling, GDPR-style right-to-deletion (satisfied more cleanly by external non-parametric memory than by baked-in weights), contextual integrity, and membership-inference risk for fine-tuned per-user models.

8. Risks and Critical Analysis (challenging assumptions)

The requester asked for candid, non-flattering analysis. The following are genuine weaknesses:

1. Sycophancy is amplified by personalization. Sharma et al. (2023, “Towards Understanding Sycophancy in Language Models,” arXiv:2310.13548, Anthropic/ICLR 2024) show that “five state-of-the-art AI assistants consistently exhibit sycophancy across four varied free-form text-generation tasks,” and that “when a response matches a user’s views, it is more likely to be preferred” — human and preference-model feedback reward matching user beliefs over truthful ones. Conditioning explicitly on a user’s stated views mechanically increases this pressure — personalization and truthfulness are partially in tension.
2. Filter-bubble / echo-chamber effects are empirically demonstrated. Sharma, Liao, Xiao (2024 CHI, “Generative Echo Chamber?”, arXiv:2402.05880) found participants “engaged in more biased information querying with LLM-powered conversational search, and an opinionated LLM reinforcing their views exacerbated this bias.”
3. Hallucinated memories and lossy-summary error compounding. Extraction-based memory can store facts that were never true (extraction hallucination) or misattribute them; recursive summarization propagates and amplifies these errors, and HaluMem exists specifically because this is a measured failure mode.
4. Memory write policy remains heuristic. No principled theory says which facts to store; LLM-rated importance is unvalidated and inconsistent.
5. Implicit-preference recall is poor. Systems do well on explicit facts (“I’m vegetarian”) but poorly on preferences that must be inferred from behavior — the open-domain/preference categories where LoCoMo and MIRIX underperform full context.
6. The long-context vs. RAG debate is unresolved and benchmark-dependent. Rankings flip based on judge model, granularity, and retrieval-K: Mem0 reports 61–92% on LoCoMo but scored only 49% on LongMemEval in an independent test (arXiv:2603.04814), where full-context GPT-5-mini was both more accurate and cheaper.
7. Vendor benchmarks are contested and self-serving. Letta and Zep dispute Mem0’s methodology; “90% token savings” often measures footprint compression, not task speedup; and Zep’s/Mem0’s headline LongMemEval numbers are vendor-reported, not third-party verified.
8. Parametric personalization does not scale. OPPU’s one-adapter-per-user is impractical for millions; hypernetwork approaches (P2P) are promising but unproven at scale.

9. Frontier / Latest Work (2024–2026)

• Sleep-time compute (Letta, April 2025 white paper; Packer, Wooders et al.): agents use idle time to convert “raw context” into “learned context” via a dual-agent model — a background sleep agent consolidates memory, deduplicates, prunes, and precomputes, while a light serve agent answers online. Reported example: Claude 3.5 Sonnet reached with 11k tokens the accuracy the baseline needed 20k tokens for. Caveat (from the paper): offline compute helps only when future queries are predictable from existing context; unrelated queries waste the “dream.” SCM (arXiv:2604.20943) formalizes sleep-consolidated memory with entropy/conflict-density triggers and algorithmic forgetting.

• Surveys: “Personalization of LLMs: A Survey” (2411.00027), “A Survey of Personalized LLMs” (2502.11528), “From Human Memory to AI Memory” (2504.15965), “A Survey of Context Engineering for LLMs” (2507.13334), “A Survey on Personalized and Pluralistic Preference Alignment” (2504.07070).
• New memory systems (2025–2026): MemoryOS (three-tier OS-style memory), MIRIX, graph-memory approaches (“Memory is Reconstructed, Not Retrieved,” 2606.06036), reinforcement-learned memory management (DeltaMem, 2604.01560), and agentic-context extensions (LongMemEval-V2, May 2026).
• Model editing for personalization (arXiv:2512.13676): directly editing weights to encode user facts.

10. Recommendations

Stage 1 — Default architecture (most teams). Build a non-parametric memory pipeline: extract salient facts (LLM), store in a vector index partitioned per user, retrieve top-K with a relevance+recency+importance score (generative-agents formula), and inject. Keep raw history retrievable for verbatim fallback (Claude’s model). Do not rely on long-context stuffing alone: lost-in-the-middle and cost/latency make it inferior above ~30 turns.

• Threshold to escalate: if retrieval Recall@k on a held-out LongMemEval-style set is below ~70%, invest in better indexing (session decomposition, fact extraction, time-aware query expansion) before anything else — retrieval recall is the binding constraint.

Stage 2 — Add structure when facts evolve. If your domain has contradictory/time-evolving facts (health, finances, projects), adopt a temporal knowledge graph (Zep/Graphiti-style bitemporal validity) for conflict resolution rather than naive overwrite. Zep’s reported +17.3 pp temporal-reasoning gain over full context is the clearest signal here.

Stage 3 — Add compression when cost-bound. If prompt tokens dominate cost, add extractive compression (LLMLingua-2 for black-box, 2x–5x) on retrieved context before soft-token methods (which require training). Monitor for information loss on a factual-recall probe.

Stage 4 — Consider parametric only at the margins. Use PEFT-per-user (or a P2P hypernetwork) only for high-value users with rich, stable histories where retrieval underperforms; use personalized reward modeling (PLUS/VPL/PAL) only where you have genuine preference-conflict data and an RLHF pipeline.

Cross-cutting — Security and honesty (do this from day one). Treat memory writes as an attack surface: sanitize/attribute-tag any memory sourced from untrusted content, surface a visible “memory updated” event, and let users view/edit/delete memory (GDPR + trust). Actively counter sycophancy and echo chambers: do not let personalization suppress disconfirming information; periodically inject diverse viewpoints; and evaluate on PrefEval and a truthfulness probe, not just win rates.

11. Caveats

• Many headline numbers (Mem0, Zep) are vendor-reported and methodologically disputed; treat cross-system rankings as directional, not definitive. Independent evaluations (arXiv:2603.04814) have found full-context LLMs beating leading memory systems on the same benchmarks.
• Benchmark results depend heavily on the judge model, retrieval-K, and value granularity; the same system can appear SOTA or mediocre across papers.
• Production memory features evolve rapidly; specific ChatGPT/Claude/Gemini behaviors described (2024–2026) may have changed.
• Synthetic-dialogue benchmarks have a documented distributional gap from real user interactions, so absolute accuracy figures likely overstate real-world personalization quality, especially for implicit preferences.
• The PGraphRAG author attribution was corrected during research: lead author is Steven Au (senior author Nesreen K. Ahmed); Salemi and Zamani lead the related LaMP/LongLaMP line but are not PGraphRAG authors.