💬 NLP

AdaMem: Learning What to Remember for Personalized Long-Horizon LLM Agents

The paper introduces AdaMem, an adaptive memory system that learns role-specific write policies from user feedback to filter irrelevant information, thereby reducing memory bloat and significantly improving long-horizon QA accuracy compared to uniform memory baselines.

Original authors: Xingyu Chen, Rui Wang, Zhaopeng Tu, Liefeng Bo

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Xingyu Chen, Rui Wang, Zhaopeng Tu, Liefeng Bo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a personal assistant who talks to you every day for months. At first, they are great at remembering what you said. But as time goes on, they start acting a bit overwhelmed. Why? Because they are trying to remember everything.

They remember your favorite coffee order, but they also remember the weather you complained about on a Tuesday, the name of a stranger you briefly met, and every single "hello" and "goodbye." Their brain (or digital memory) is getting so full of this "noise" that they can't find the important stuff when you ask a question. This is called memory bloat.

The paper introduces a new system called AdaMem (Adaptive Memory) to fix this. Here is how it works, using simple analogies:

1. The Problem: The "Hoarding" Assistant

Most current AI assistants act like a digital hoarder. They have a rule: "Save every fact."

The Result: Over weeks, their memory bank gets crowded with useless trivia. When you ask, "What did we decide on my vacation schedule?" the AI has to dig through thousands of irrelevant messages about the weather or casual jokes. The important answer gets buried, and the AI gets the answer wrong.

2. The Solution: The "Smart Editor" (AdaMem)

AdaMem changes the rule. Instead of saving everything, it asks: "What does this specific user actually care about?"

Think of AdaMem as a Smart Editor who learns your personal taste.

If you are a busy manager: The editor learns to keep only meeting deadlines and business decisions, throwing away small talk.
If you are a fitness enthusiast: The editor learns to keep workout schedules and diet goals, ignoring your complaints about the traffic.

The system doesn't guess this once and forget it. It learns what to keep by watching how you react to its answers.

3. How It Learns: The Weekly "Patch"

The system runs on a weekly cycle, like a teacher grading homework and then updating the lesson plan:

The Week: The AI talks to you daily, saving memories based on its current "rules" (called a Memory Policy).
The Test: At the end of the week, it answers questions about what happened.
The Mistake: If it gets an answer wrong, it doesn't just say "Oops." It looks at why it failed.
- Did it forget something important? (The rule was too strict).
- Did it get confused by a useless detail? (The rule was too loose).
The Patch: The AI writes a tiny "software patch" (a small update) to its rules. It says, "Next week, I will remember only schedules and forget the weather."
The Safety Net: Before applying the new rule, it checks: "Will this new rule break anything I got right before?" If the new rule makes things worse, it rolls back to the old rule. This prevents the AI from going crazy with bad ideas.

4. The Results: Less Clutter, Better Answers

The researchers tested this on a simulated environment where an AI talked to different "characters" for 10 weeks.

The Old Way (Uniform Memory): The AI remembered everything. By week 10, its accuracy dropped because it was drowning in noise.
The AdaMem Way: The AI remembered less (about 9% less data), but it remembered the right things.
The Outcome: The AI got 9% more questions right than the old way. It was like cleaning out a messy closet: by throwing away the old socks and keeping only the shirts you actually wear, you can find your favorite shirt much faster.

5. The Catch: It Needs Clear Feedback

The paper found one interesting limitation.

Explicit Feedback: If you tell the AI, "You were wrong! Remember that I care about schedules," the AI learns very fast and gets the rules perfect.
Implicit Feedback: If you just say "That answer is wrong" without explaining why, the AI struggles to figure out what you actually care about. It's like a student who knows they got a test wrong but doesn't know which rule they broke.

Summary

AdaMem is a system that stops AI agents from trying to remember everything. Instead, it acts like a personalized filter that learns, week by week, exactly what information is valuable to you and what is just noise. By keeping the memory small and focused, it helps the AI stay accurate and helpful over long periods of time.

Technical Summary: AdaMem

Problem Statement

Long-horizon interactions for Large Language Model (LLM) agents face a critical conflict between the desire for comprehensive personalization and the constraints of production environments. Existing memory systems (e.g., Mem0, MemoryBank) typically operate under a "remember everything" paradigm, uniformly extracting factual statements from dialogue to maximize context retention. However, in real-world deployment, this approach collides with hard constraints: finite context budgets and inference costs.

As interactions span weeks or months, uniform extraction leads to memory bloat. The memory bank accumulates irrelevant trivia (e.g., casual greetings, minor scheduling details) that crowds out high-value information during retrieval. This degradation steadily erodes Question-Answering (QA) accuracy over time. The core problem identified is that agents lack write control; they fail to distinguish between information a specific user cares about and noise, treating all facts as equally important regardless of the user's role or preferences.

Methodology: AdaMem

The authors propose AdaMem (Adaptive Memory), a framework that shifts memory management from static consolidation to an active, preference-guided write-control process. AdaMem operates on the insight that "what is worth remembering" is subjective and role-dependent (e.g., a manager's agent should track business decisions, while a fitness buddy's agent should track workout schedules).

Core Components

Structured Memory Policy ( $P$ ):
Instead of a generic extraction rule, AdaMem maintains a JSON-based policy mapping characters ( $C_i$ ) to natural language extraction preferences ( $T_i$ ). For example, a policy might instruct: "Only extract final business decisions and deadlines; ignore daily chit-chat."
Closed-Loop Weekly Cycle:
The system runs a four-step cycle over weekly horizons:
- Daily Extraction: Memories are stored under the current active policy. Relative temporal references (e.g., "tomorrow") are resolved into absolute dates via a Time Anchoring step to prevent ambiguity.
- Weekly Evaluation: The agent is probed via QA tasks based on the accumulated memory.
- Policy Reflection: The system diagnoses errors in incorrect answers ( $W_t$ $W_{t}$ ) as either:
  - Recall Failure: The policy was too restrictive (missed relevant info).
  - Precision Failure: The policy was too permissive (retrieved noisy info).
    Based on this, the agent generates a policy patch ( $\Delta P_t$ ) to update the extraction rules.
- Failure Rollback: To ensure stability, the updated policy is validated against historical QA pairs. If performance degrades, the update is rejected, and the policy reverts to the previous version.
Rendering:
The active policy is compiled into custom instructions for the extractor's prompt, guiding the LLM on what specific information to retain for each persona.

Key Contributions

Reframing Memory as Write-Control: The paper reframes long-horizon memory for industrial deployment not as a retrieval problem, but as a write-control problem. It argues that agents must actively manage what is written to memory based on user preferences rather than consolidating dialogue wholesale.
AdaMem Framework: A lightweight, patch-style self-reflection mechanism that learns role-specific memory policies from feedback. It integrates into existing RAG stacks without requiring model retraining.
AdaMem-Bench: A new benchmark simulating weeks of interaction with week-by-week QA. It features:
- Multi-persona tracking with distinct information preferences.
- Golden-memory annotations for ground-truth evaluation.
- Scenarios with high semantic overlap to test interference handling.

Results

Evaluated across two extraction models (DeepSeek-V4-Flash, Gemini-3.5-Flash) and two feedback modes (Explicit and Implicit), AdaMem demonstrates significant improvements over the uniform Mem0 baseline:

QA Accuracy: AdaMem improves accuracy by up to +9.0% (85.2% vs. 76.2% on DeepSeek with explicit feedback).
Memory Efficiency: It reduces memory volume by 9% (e.g., 371 vs. 430 memories) while maintaining higher accuracy, resulting in a superior Memory Efficiency Ratio (MER).
Category-Specific Gains: Improvements are concentrated in "soft preference" categories:
- Emotion/Attitude: +15.9%
- Schedule/Time: +9.9%
- Decision/Conclusion: +9.0%
- (Fact/Number categories showed minimal gains, as these are easily captured by standard extractors).
Retrieval Dynamics: Over a 10-week horizon, AdaMem maintains stable Recall@5 and Mean Reciprocal Rank (MRR), whereas the uniform baseline suffers from retrieval degradation due to clutter.

Bottleneck Analysis:
The study identifies policy inference (learning preferences from feedback) as the primary bottleneck, rather than policy adherence.

Explicit Feedback: Agents successfully converge to ground-truth preferences (88.3% alignment).
Implicit Feedback: Agents struggle to reverse-engineer preferences from correctness signals alone, with policy alignment stalling between 53.3% and 63.3%.

Significance and Claims

The paper claims that AdaMem offers direct industrial value by addressing the trade-off between context budget and personalization. By keeping memory compact and user-aligned, it lowers retrieval and inference overhead while improving accuracy. The "patch-style" reflection allows for continuous improvement of memory policies without retraining the underlying LLM.

The authors conclude that while modern LLMs reliably follow structured instructions (policy adherence), the ability to infer complex user preferences from weak (implicit) feedback remains a key frontier for personalized agents. The work suggests that future progress in long-horizon agents depends on solving this policy inference challenge.

Limitations Acknowledged:
The authors note that their evaluation relies on synthetic data, which may not fully capture real-world linguistic diversity. Additionally, the evaluation scale is limited by API costs (5 stories, 10 weeks), and the reliance on LLM-as-a-judge introduces potential biases. Finally, under implicit feedback, the patch mechanism risks over-fitting to single failures, though the rollback mechanism mitigates this.