LLM-based agents increasingly rely on long-term memory to support multi-session reasoning and interaction, yet current systems provide little control over what information is retained. In practice, agents either accumulate large volumes of conversational content, including hallucinated or obsolete facts, or depend on opaque, fully LLM-driven memory policies that are costly and difficult to audit. As a result, memory admission remains a poorly specified and weakly controlled component in agent architectures. To address this gap, we propose Adaptive Memory Admission Control (A-MAC), a framework that treats memory admission as a structured decision problem. A-MAC decomposes memory value into five complementary and interpretable factors: future utility, factual confidence, semantic novelty, temporal recency, and content type prior. The framework combines lightweight rule-based feature extraction with a single LLM-assisted utility assessment, and learns domain-adaptive admission policies through cross-validated optimization. This design enables transparent and efficient control over long-term memory. Experiments on the LoCoMo benchmark show that A-MAC achieves a superior precision-recall tradeoff, improving F1 to 0.583 while reducing latency by 31% compared to state-of-the-art LLM-native memory systems. Ablation results identify content type prior as the most influential factor for reliable memory admission. These findings demonstrate that explicit and interpretable admission control is a critical design principle for scalable and reliable memory in LLM-based agents.
Figures & tables
Figure 1: Overview of A-MAC. Candidate memories are extracted from conversation history and evaluated using five complementary signals capturing usefulness, reliability, redundancy, temporal relevance, and persistence. A learned linear admission policy aggregates these signals into a score S(m) and applies a threshold θ to determine whether to admit, update, or reject a candidate.
Method
Prec.
Recall
F1
Lat.(ms)
Random
0.278
0.278
0.278
< 1
MemGPT
0.316
0.333
0.324
2765 †
MemoryBank
0.368
0.583
0.452
2843 †
Equal Weights
0.362
0.694
0.476
2916 †
A-mem
0.371
1.000
0.541
3831 †
A-MAC (Ours)
0.417
0.972
0.583
2644 †
Table 1: Performance comparison on LoCoMo test set (N=225). Latency marked with † includes LLM API calls. Best F1 in bold.
Figure 2: Precision-recall tradeoff comparison. A-MAC achieves the best balance between precision and recall, occupying the upper-right region of the curve. Dashed lines indicate F1 iso-contours.
Feature
F1 w/o
Δ F1
Full Model
0.583
–
Type Prior ( T )
0.476
− 0.107
Novelty ( N )
0.555
− 0.028
Utility ( U )
0.560
− 0.023
Confidence ( C )
0.568
− 0.015
Recency ( R )
0.570
− 0.013
Table 2: Ablation study showing performance impact of removing each feature. Type Prior ( T ) is the dominant contributor.
Threshold θ
Prec.
Recall
F1
Admitted
0.30
0.360
1.000
0.529
100
0.40
0.360
1.000
0.529
100
0.50
0.376
0.972
0.543
93
0.55
0.410
0.944
0.571
83
0.60
0.395
0.833
0.536
76
0.65
0.368
0.583
0.452
57
Table 3: Threshold sensitivity analysis. F1 peaks at θ∗=0.55 . Lower thresholds maximize recall at the cost of precision; higher thresholds become overly selective.
Component
Latency (ms)
Percentage
Utility U (LLM)
2580
97.6%
Confidence C (ROUGE-L)
18
0.7%
Novelty N (SBERT)
32
1.2%
Recency R (Decay)
< 1
< 0.1%
Type Prior T (Rules)
14
0.5%
Total (A-MAC)
2644
100%
Table 4: Latency breakdown by component. LLM-based Utility dominates computation time; rule-based features execute efficiently.
Domain
Samples
F1
Δ from Mean
Personal
127
0.482
+0.072
Professional
98
0.338
− 0.072
Mean
225
0.410
–
Std. Dev. ( σ )
–
0.102
–
Table 5: Cross-domain generalization performance. A-MAC transfers effectively to both domains without retuning, though Personal conversations yield higher F1 due to explicit preference patterns.
Figure 3: Cross-domain F1 performance. Personal conversations achieve higher F1 due to explicit preference statements that align with Type Prior’s strengths. The dashed line indicates mean performance across domains.
Large Language Model (LLM) agents increasingly rely on external memory systems to accumulate experience across tasks. Yet nearly all existing approaches, from graph-structured memories to reflective insight stores, access memory through fixed, hand-designed heuristics. We argue that this static view of memory is a core bottleneck for agentic learning because optimal memory behavior is fundamentally context-dependent. The early stages of the tasks, benefit from minimal retrieval because memory is sparse; recurring goal types benefit from plan reuse rather than generic nearest-neighbor lookup; stuck agents benefit from re-retrieval with alternative queries; and across long task streams, the memory store itself must be consolidated and pruned to remain useful. We present Memory as a Controlled Process (MemCon), a framework that models memory operations as a Markov Decision Process and learns an online policy that adaptively decides when, what, and how much to retrieve, when to inject a distilled plan, and when to consolidate or forget. MemCon is backend-agnostic: it wraps any existing memory implementation, learns from task-by-task binary feedback with no pretraining and no additional LLM calls, and uses a lightweight tabular contextual bandit with UCB exploration that converges within tens of tasks. Across 6 benchmarks, 3 agent frameworks, and 3 LLM backbones, MemCon consistently outperforms multiple memory baselines by up to 15.2 points in task success while reducing token consumption by 5--20%.
Eric Hanchen Jiang, Zhi Zhang, Yuchen Wu +11
University of California Los Angeles · University of Washington · Northwestern University
Human memory adapts through selective forgetting: experiences become less accessible over time but can be reactivated by reinforcement or contextual cues. In contrast, memory-augmented LLM agents rely on "always-on" retrieval and "flat" memory storage, causing high interference and latency as histories grow. We introduce Oblivion, a memory control framework that casts forgetting as decay-driven reductions in accessibility -- not explicit deletion. Oblivion decouples memory control into read and write paths. The read path decides when to consult memory, based on agent uncertainty and memory buffer utility, avoiding redundant always-on access. The write path decides what to strengthen, by reinforcing memories contributing to forming the response. Together, this enables hierarchical memory organization that maintains persistent high-level strategies while dynamically loading details as needed. We evaluate on both static and dynamic long-horizon interaction benchmarks. Oblivion outperforms both direct and memory-augmented baselines, while reducing token cost by up to 73% at 120K interaction spans. These results show that treating memory as a control problem -- deciding when to retrieve and what to reinforce -- is essential for sustaining long-horizon agent performance.
Long-term memory systems allow LLM agents to preserve information beyond a single context window, but most systems focus on storing and retrieving facts after extraction, leaving the write decision under-specified. What deserves memory can depend on the user's current task, topic, activity, or interaction partner, while uniform extraction applies one notion of importance across these different situations. We formulate this challenge as preference-conditioned write control and introduce AdaMem, which uses adaptive natural-language Memory Policies to personalize what an agent writes to memory. Each policy represents the user's memory preference for a particular interaction context, is updated from periodic feedback, and controls subsequent memory writing. We evaluate this loop in AdaMem-Bench, which assigns different memory preferences to six concurrent interaction personas across five ten-week stories. Across two extraction models and two feedback modes, AdaMem improves average QA accuracy over Mem0 from 80.0% to 84.35% while reducing persistent memory by 9.27%. Our analyses show that explicit feedback helps models learn better memory policies, but current models still struggle to translate those policies into reliably selective writing behavior. AdaMem thus demonstrates the promise of adaptive write control while exposing policy execution as a central limitation of current memory agents. Our code is publicly available: https://github.com/galaxyChen/AdaMem