betaFeedback

WorksComputer Science

Route to Remember: Adaptive Memory Selection for LLM Agents

Abstract

The memory of production agents is increasingly becoming a bottleneck and is built almost exclusively from text: key points are extracted from out-of-limit context and retrieved into context at query time. Therefore, every new query incurs an additional cost that grows with the accumulated history. Weight memory is a complementary alternative that internalizes knowledge into model parameters and answers with no context at all, and has recently proven effective in self-evolving agents for internalizing skills and behaviors. However, its application in episodic and semantic memory, such as user-specific facts, remains comparatively unexplored, and a gap remains between earlier attempts at weight memory and text-based systems regarding recall performance. We study how to make weight memory competitive as a long-term factual store by applying on-policy self-distillation (OPSD). It trains a context-free student from a teacher, which is the same model conditioned on the user's memory, together with a verify-then-regenerate router that lets weight and text memory each cover the queries they handle best. On the HaluMem benchmark, OPSD matches or surpasses strong text-memory baselines, including full-context prompting and retrieval systems, while reading fewer tokens per query. We further conduct an extensive study that characterizes the behavior of weight memory and analyzes how different training recipes affect its performance. As agent harnesses move toward persistent, multi-session deployments, these results position weight memory as a practical, low-cost component of agent memory and provide insights into feasible training and evaluation protocols for combining it with retrieval.

Introduction

Persistent agents need to recall project conventions, user preferences, and earlier interactions across sessions. Many memory systems store this information as text, then retrieve relevant entries into the prompt [1, 2, 3, 4]. This design makes stored evidence inspectable but introduces retrieval and context-processing costs and depends on retrieving the relevant facts.

Storing memory in weights provides an alternative. If user history is internalized into parameters, the following queries can be answered without retrieval or context, so the marginal cost of a query stops depending on how long the dialogue is, and the cost is a training pass whenever memory is written. Early attempts to use weights as memory, however, underperform once the model is deprived of context at inference and are studied mostly for verbatim recall [5, 6]. Recent self-evolving agents revive the idea more successfully, showing that on-policy

40th Conference on Neural Information Processing Systems (NeurIPS 2026). Workshop: Personalized, aligned, long-term memory for AI systems. distillation can internalize procedural skill into weights [7, 8]. But none of this work isolates the memory itself from the harness, and the case that matters most for personalization is left open: the episodic and semantic memories built from timestamped sessions can arrive incrementally, update, or even sometimes contradict each other. The nearest evidence is a diagnostic of substrate asymmetry [9], which compares a per-user adapter against retrieval and concludes that neither dominates and the two are complementary — leaving unanswered how far a parametric memory can actually be pushed on episodic and semantic recall and what it would take.

We address that question directly and apply on-policy self-distillation (OPSD): a per-user Low-Rank Adaptation (LoRA), referred to as the student, which is trained to reproduce, with no context at inference, the answers that the same model provides with context in the prompt, referred to as the teacher. The distillation takes place on the student’s own distribution, so the objective matches the deployment condition. OPSD makes weight memory outperform every text baseline we test, but it requires extra training costs and inherits two limits intrinsic to its parameters: it forgets older facts along with new updates, and it cannot tell whether a fact was never recorded, so it confabulates instead of abstaining. Because weight and text memory fail on different questions, we then ask whether they can combine. We adopt verify-then-regenerate (VtR): the parametric memory answers first; those answers are audited against the text store, and only conflicted answers are regenerated with the retrieved evidence, auditing the produced answer rather than judging from the query.

These claims rest on a broad experimental study on benchmarks for long-term memory such as HaluMem Chen et al. [ [10] and LoCoMo Maharana et al. [ [11], and four findings stand out. First, OPSD reaches an overall QA accuracy of 59.9%, while ordinary Supervised Fine-Tuning (SFT) on identical data reaches 36.9%, which is below every text baseline; the accuracy holds across model variant scales. Second, the three memory paradigms differ less in accuracy than in how they degrade with question age: context truncates, weights forget gradually, retrieval barely notices, and within weight memory, the learned habit of declining survives while the content it protected decays. Third, the one deficit training does not fix is inspecting absence, which can be traced to a single training-side lever. The model’s willingness to decline is attributable entirely to the ratio of refusal samples included in the training set. Fourth, VtR adds 6.2 points over OPSD and improves five of six question categories, whereas every other query-side routing signal we tried, including similarity, learned query features, model consistency, and answer confidence, can hardly predict whether the answer of weight-based memory is correct. Extensive analysis is conducted on these observations.

We summarize our contributions as follows.

  • An evaluation of OPSD for recent user-memory recall. On the question set for eight HaluMem-Long users, OPSD reaches 59.9%, compared with 47.8% for MemOS-style retrieval, 51.9% for extracted context, and 51.3% for raw dialogue. The advantage over retrieval is positive for all eight users, and the comparison with extracted context and retrieval holds at 4B, 9B, and 27B.

  • A characterization of retention and training effects. Repeated questions distinguish context truncation, gradual forgetting in weights, and more stable retrieval. Our ablations identify training-objective and refusal-supervision effects within the tested recipes, while cost accounting separates query token usage from unmeasured deployment costs.

  • A routing study and VtR integration. Query-side and confidence signals provide limited correctness information in our probes. Answer verification with text-based regeneration adds 6.2 points over OPSD on native HaluMem questions, improving five of six categories while reducing memory-conflict accuracy.

Related Work

Text memory systems. Text memory in deployed agents follows a typical loop: key points are extracted from the dialogue as natural-language statements, written to external storage, then retrieved by relevance when a new query arrives and injected into the prompt. Within that shared skeleton, systems differ mainly in how they organize and consolidate. Xu et al. [ [3] maintain atomic notes with evolving cross-links, Gutiérrez et al. [ [2] build a knowledge graph, and Feng et al. [ [12] store distilled reasoning rather than raw text. A further line evolves the memory online from feedback [Zhang et al., 2026b, c, Rhodes and Kang, 2026]. Li et al. [ [4] generalize the picture into an operating-system abstraction spanning plaintext, activation, and parameter memory. However, these text-based systems inherit the same costs. Every query incurs retrieval latency and context tokens, and because the store grows while the window does not, retrieval quality eventually becomes the binding constraint on accuracy. Surveys of the area reach the same conclusion from the opposite direction, finding that consolidation, updating, and forgetting remain far less developed than retrieval [16, 17], and that a longer context window is not a substitute for a memory system [18]. We take Li et al. [2025] as our primary text-based system baseline.

Weight memory systems. The alternative writes new information directly into the model parameters. Editing methods localize a fact and overwrite the responsible feed-forward weights [19], which is precise but degrades after thousands of edits. Others attach side feed-forward modules to a frozen backbone [20] or update fast weights during inference [21], while Behrouz et al. [2026] learns a memory module updated by surprise-gated descent with an explicit forgetting gate. Empirical analyzes of LoRA as a memory store [5, 6] report that adapter capacity scales with rank while efficiency peaks at low rank, and that question-answer formatted synthetic data substantially improves memorization, which is consistent with our own findings. Closest to our setting are methods using distillation: Hübotter et al. [2026] compress in-context feedback into parameters through KL minimization, and the same idea appears in recent self-evolving agent work. Zhang et al. [2026a] distills a hindsight-conditioned teacher into a context-free student to internalize skills, and Feng et al. [2026a] uses self-distillation to calibrate search behavior. Our training method belongs to this family, and what distinguishes it is the object rather than the optimizer: the teacher’s privilege is a recency-bounded window of the user’s accumulated memory, the student is context-free at evaluation, and the target is a specific user’s episodic and semantic memory rather than a skill or a search policy.

Routing between memory systems. Routing is the natural response to the observation that not a single memory system can win all behavioral consistency, fact recall, and absence calibration at the same time[9]. Existing routers on memories are mostly built within the same type, either text-based or parametric: Wang et al. [2024] route a query between frozen and edited parametric memory by activation distance; Back et al. [2026] routes among multiple learned adapters through similarity; Xu et al. [2026c] arbitrates the model’s closed-book answer against a retrieved one by likelihood margin. We tested various signals for routing and finally designed a verify-then-regenerate mechanism for routing between two memory systems, making the memory reader closer in spirit to the write-time verification gate of Rhodes and Kang [2026].

Method

To make weight memory competitive, we train it using QPSD [26]: when a memory write is triggered, we convert the new dialogue contents into a question-answer training set and distill a context-free student from a teacher that uses the same model but can see the context window. To combine the two memory systems where each is strong, we then add a VtR reader that acts as a router: it fact-checks the weight memory’s answer against the text store, judges what the store supports it, and regenerates from retrieved context only when it does not.

Data preparation

We call one assistant response a turn, and a session a sequence of turns spanning one period of interaction. A user’s history is then a sequence of sessions S1,…,STS_1,\ldots,S_T, and the evaluation is conducted after each complete session through question answering, so memory is written once per session and read after every session.

Both memory systems we study consume the same intermediate representation for adding a session into memory: a base language model reads each session’s dialog and extracts its key memory points, each written as one narrative sentence carrying its timestamp. A text memory system stores and retrieves those sentences directly; we instead convert them into training supervision, using the same base model for the augmentation that produced the extraction. How that supervision is shaped matters more than how much of it there is. Continued pretraining on memory points or dialogue as raw text transfers poorly to question answering; what works is generating question-answer pairs in the same prompt template used at evaluation, and training with the loss masked to the answer. For each memory point we then generate three kinds of pair. Paraphrases ask for the same fact several ways, which is what later lets the student generalize across phrasings rather than memorize one surface form. Counterfactuals state the fact wrongly and require a correction, which teaches the corrective form that questions carrying a false premise demand. Unknowns ask about attributes the session never recorded and require an explicit refusal; these turn out to be the entire source of the model’s willingness to decline, and removing them is catastrophic in a way §4.3 quantifies.

On-policy self-distillation of memory

We train a per-user LoRA adapter to answer without context, using the same base model conditioned on the context window as the teacher. Denoting πθ\pi_\theta for the student and πbase\pi_{\mathrm{base}} for the base model, the teacher is πbase(⋅∣q,Mt)\pi_{\mathrm{base}}(\cdot\mid q, M_t) and the student is πθ(⋅∣q)\pi_\theta(\cdot\mid q) with no memory in the prompt. Here MtM_t is not the entire accumulated memory, which eventually exceeds any context budget, but a recency-bounded window over it: the current session’s memory points, always kept, plus as many of the most recent prior sessions as fit a fixed budget, usually the context limit of the model. The student, being a persistent adapter, keeps evolving across sessions, so it can retain facts that no individual teacher context still contained, a point we return to when we ask why the student can outperform its teacher (§4.2). Training proceeds on-policy: for a question qq drawn from the pool, the student samples its own answer y∼πθ(⋅∣q)y \sim\pi_\theta(\cdot\mid q), the teacher scores exactly those tokens, and we minimize the divergence between them on the sampled trajectory,

L(θ)=EqEy∼πθ(⋅∣q)∑iKL⁡(πbase(⋅∣q,Mt,y<i)∥πθ(⋅∣q,y<i)).(1)\mathcal{L}(\theta) = \mathbb{E}_{q}\mathbb{E}_{y\sim\pi_\theta(\cdot\mid q)} \sum_i \operatorname{KL}\left(\pi_{\mathrm{base}}(\cdot\mid q, M_t, y_{<i}) \mathbin{\|} \pi_\theta(\cdot\mid q, y_{<i})\right). \tag*{(1)}

Sampling from the student rather than the teacher is what keeps the objective on-policy, and it matters for both a mundane reason and a theoretical one: an off-policy variant, like supervised learning over the teacher’s answers, suffers from exposure bias and degenerates into repetition loops, scoring well below the on-policy version.

Two design choices proved decisive for training robustness. The first is that the teacher should not be replaced by the student: Using the accumulating student snapshot from the previous session as a teacher, the natural self-distillation choice lets errors compound across sessions, and the forgetting curve collapses late in the horizon. The second is that the question pool should stay fixed or grow only within a reasonable range. Expanding it with an adversarially trained questioner helps in a single-session probe but hurts across many sessions, where the generated questions can drift onto unrelated topics and dilute the native facts the model needs to retain. Since memory is written once per session and read many times, we keep the adapter persistent across sessions, so each session’s training accumulates on top of all previous ones. Adding a regularization term may be a solution for both problems, however it can introduce extra costs to tune the hyperparameter.

Verify-then-regenerate as the router

Weight memory answers fluently whether or not it knows, and its one systematic blind spot, absence, is exactly what a text store makes visible. That asymmetry suggests auditing the weight memory’s answer rather than choosing between the two systems in advance based on the query, and §4.4 shows why the alternative fails. Given the student’s answer y^\hat{y} to question qq at session tt, we retrieve from the text store twice, once with qq as the query and once with y^\hat{y}, taking the top kk of each. A verifier then judges y^\hat{y} against the answer-anchored evidence as supported, conflicting, or unsupported. Because it only has to emit one of three labels, the verifier is a cheap classifier rather than a second LLM agent. If the verdict is supported, the weight memory’s answer stands. Otherwise, the base model, with no adapter, re-answers from the union of both retrieved evidence sets, each memory point annotated with a timestamp, under an instruction to reply properly with the retrieved evidence.

Three details carry the result: (1) Where the evidence comes from matters. We retrieve from the store managed by the text memory system, not from the weight memory’s raw training data. This is what allows the text-based memory system to handle updates, which a case weight memory handles poorly on its own, because a later session’s training set can overwrite an earlier fact, for example, a user’s changing physical address. More specifically, in this experiment, we retrieve against a merged store, in which superseded values have been integrated into the previous related statements or totally replaced them; without merging, a third of all verdicts come back as conflicts, while merging reduces that to about one percent. (2) Retrieving with a generated answer is not the same operation as retrieving with the question because it inserts a step of semantic reasoning. Weight memory produces a plausible answer, which maps the question into a region of the space where memory points themselves live; matching against that region is a better-posed retrieval problem than matching a question against statements that are not phrased as questions, and it cuts retrieval noise accordingly. The two keys are also deliberately kept distinct since verification and regeneration need different evidence: the audit should see what was actually claimed, while the regenerator should see what the question makes answerable. The two sets overlap only partially, and the answer-anchored half contributes evidence that the question alone does not surface. (3) Only the base model is used for regeneration; therefore, it is adapter-free by design. The fallback path is purely text-based and thus cannot inherit the confabulations that the audit aims to catch.

Experiments

Setup

Benchmarks. HaluMem Chen et al. [2025] is our primary benchmark. It has in total dialogue data of 20 distinct users, each with 109–136 sessions and roughly a million tokens per use. We choose it because it evaluates after every session rather than once after the whole dialogue, and because its question taxonomy separates the phenomena we care about: basic fact recall, memory conflict, dynamic update, multi-hop inference, generalization and application, and memory boundary. That last category is where the question is asking for out-of-distribution facts, and the agent should refuse to answer. We additionally tested our method over LoCoMo Maharana et al. [2024], a multi-session dialogue benchmark, to check that the result is not an artifact of HaluMem’s generation process; it has no native notion of question age, so the retention protocol remains HaluMem-only.

HaluMem originally asks each question only in the session that first makes it answerable, and that native distribution is what all our headline numbers report. To study retention, we add a supplementary protocol that re-asks every question 20, 40, . . . , 80 sessions later, which we report the results per each age to trace each memory system’s forgetting curve (§ 4.3). We do not average the two, because the re-asks outnumber the native questions roughly two to one and the memory systems decay at different rates, so a pooled mean reflects the mixing ratio as much as the systems.

Baselines. Three text memory systems span the cost spectrum: MemOS-style retrieval over a database with top-kk fetch, the full extracted memory in context, and the raw dialogue truncated to the context limit. We use MemOS because it is the strongest text memory system in HaluMem’s own evaluation. Ground-truth memory points in context, provided by the benchmark, serve as an oracle and is denoted as GT points. On the weight side we compare against SFT on identical augmented data in the style of Back et al. [2026], which isolates the contribution of the distillation objective.

Protocol. One language model performs every text operation in the pipeline, including memory-point extraction, text-store management, training-data preparation, and question answering, so differences between systems are attributable to the memory rather than to the reader. We use Qwen3.5-9B for the main comparison and repeat it at a smaller scale to check that the effect is not scale-specific (Appendix § 6.§ 2). Claude Sonnet 4.6 serves as the judge, labelling each response correct, hallucinated, or omitted, with no partial credit; we report Correct% throughout, and the absence of partial credit is worth keeping in mind for questions whose ground-truth answer is a terse label. We report paired McNemar tests over matched questions, 95% confidence intervals from a bootstrap clustered on users, and per-user differences, so that no claim rests on a single user’s behaviour. Full training and retrieval hyperparameters are given in Appendix § 6.§ 1.

OPSD-based weight memory outperforms text memory

Table 1 gives per-category accuracy for every method on HaluMem’s native question set (n=1438n=1438); Table 2 gives the cost of each. We read the two together: weight memory is at once the most accurate non-oracle system and the cheapest to query, at a higher write cost.

Weight memory is more accurate, and the recipe is what makes it so. OPSD reaches 59.9%, above every text baseline, including the two full-context systems that hold the entire history in the prompt (51.3% and 51.9%) and the MemOS retriever (47.8%). The margin over retrieval is 12.1 points, with a user-clustered confidence interval of [9.4, 14.8], positive for all eight users individually, from 7.1 to 18.1 points; on matched questions, OPSD is uniquely correct on 309 questions against retrieval’s 136. We take the comparison against the full-context base model to be the more informative one: even though the context is not shown, the OPSD method still does better relying purely on its weights. The advantage is broadly distributed — OPSD leads on five of six question categories — and it holds across model size, leading every baseline at 4B and 27B (Appendix § 6.§ 2). It is, nonetheless, an accuracy that is concentrated on recent material and blind to what was never recorded: weight memory forgets as facts age and confabulates when asked for an attribute the user never gave, the two failure modes we characterize in § 4.3. The latter is exactly the memory boundary, the one category OPSD loses, where the answer is an abstention, and a text system can simply observe that its retrieved list contains nothing relevant (§ 4.3); this is also the only category propping up the otherwise weak text baselines, and removing it widens OPSD’s overall margin over retrieval from 12.1 to 18.0 points.

That this accuracy is a property of the training recipe rather than of parametric storage is shown by the weakest row in Table 1: supervised fine-tuning on the identical augmented data reaches 36.9%, below every text baseline, even though its stored representation and training data match OPSD’s and only the objective differs. Early results discouraging about weight memory were obtained almost entirely with supervised fine-tuning ([9, 5]); our comparison indicates that on-policy self-distillation, not SFT, is the appropriate objective for internalizing episodic/semantic memory, and that the medium was never the constraint those results attributed it to. Appendix § 6.§ 5 traces how the OPSD configuration was reached.

Weight memory is costly to write but cheap to query. Table 2 shows that the two families invert where their cost falls. A text system writes for free but reads an entire context on every query, spending 1.7M to over a billion input tokens across the evaluation; weight memory front-loads the cost into writing — extraction, QA augmentation, and a distillation pass not billed in tokens — and then reads only the query tokens, four orders of magnitude fewer than full context and a factor of five below retrieval. Because writing is paid once per stored memory while reading recurs, weight memory pays off precisely when the same memory is queried many times: its natural use case is internalizing a common fact or skill that thousands of users will each query, rather than a single user’s transient history. The crossover is quantifiable from Table 2. Against full context, OPSD’s roughly 150M extra write tokens are repaid after about 600 queries per stored memory, since each query saves about 2.4×1052.4 \times10^{5} input tokens. Against retrieval the break-even is far higher, on the order of 10510^{5} queries, because retrieval is already cheap to read (about 310 input tokens saved per query against a 57M-token extra write): weight memory dominates full context almost immediately but only overtakes retrieval on cost under very heavy, highly shared query load. VtR keeps weight memory’s read cost on the 38% of queries the gate accepts and pays a retrieval-plus-regeneration read on the rest, so its per-query cost sits between OPSD and MemOS (Table 2).

methodwrite tokens inwrite tokens outread tokens inread tokens outread GPU-h
Raw Dialogue——1.07B0.46M23.4
Extracted (dump)30.2M12.0M1.03B0.39M22.5
MemOS (retrieval)30.2+19.6M12.0+1.3M1.7M0.05M0.9
OPSD30.2+76.5M12.0+31.4M326K0.06M1.0
OPSD + VtR30.2+96.1M12.0+32.7M1.3M0.09M1.8

Table 2. Usage per method. Write is the one-time cost of building a user’s memory (LLM in/out tokens); read is the per-query evaluation cost (tokens and GPU-h). Storage and weight methods share the extraction pass (30.2M/12.0M) plus a method-specific term (merge for MemOS, QA augmentation for the weight methods). All experiments are done on NVIDIA H200 GPU.

Why the student can beat its teacher. OPSD (59.9%) also exceeds the teacher configuration it distils from — the base model reading extracted memory in context (51.9%). We offer three possible explanations and leave further analysis for future work: (i) Consolidation: training over many paraphrases of a fact averages over the extraction noise that any single retrieved statement carries, in the psychological sense of consolidation. (ii) No in-context search: the student never has to locate its answer among hundreds of distractor statements, which is where the full-context memory systems visibly fail, their hallucination rate sitting at 33–34%. (iii) Persistence past the teacher’s window: because the teacher sees only a recency-bounded context while the adapter persists, the student can retain facts that have since dropped out of any single teacher window rather than re-finding them at query time.

Characterizing weight memory as long-term memory

Retention: content decays, habits do not. Figure 1 separates the three paradigms by failure modes. Context methods fall off a cliff when the relevant session leaves the window, and the more compressed the representation the later the cliff arrives: raw dialogue collapses by age 40, extracted memory holds until 60. Weight memory decays smoothly instead, from 59.9 to 32.4 by age 80. Retrieval is nearly flat, from 47.8 to 40.1, because a top-5 fetch is indifferent to how old a fact is. This is the precise scope condition on §4.2: weight memory’s advantage is concentrated on recent material, and retrieval overtakes it beyond roughly twenty sessions. It also suggests the write policy a deployed system should adopt, distilling recent sessions into weights while leaving the tail to retrieval.

Figure 1. HaluMem-Long retention—Correct% by question age; context truncates, weight decays, retrieval stays flat.

Within weight memory, forgetting is strikingly non-uniform. Between age 0 and age 100 the memory-boundary category is flat, drifting from 81.7 to 88.1, while every content category collapses. The model does not forget that it should be careful; it forgets what it knew, and keeps answering anyway.

Second benchmark: LoCoMo. To check that the ranking is not an artifact of HaluMem’s generation process, we port LoCoMo, a multi-session dialogue benchmark independently constructed. LoCoMo asks all questions once after the full conversation, so there is no notion of question age; we therefore pool every session into a single memory and report end-of-conversation accuracy per LoCoMo category (single-hop, temporal, multi-hop, open-domain, and adversarial, the last being unanswerable-from-context questions that should be refused). Figure 2 shows overall accuracy; the full per-category breakdown is in Table 15 (appendix).

Figure 2. LoCoMo overall accuracy—the ranking of Figure 1 reproduces on an independent benchmark. Per-category in Table 15.

Table 15: LoCoMo end-of-conversation accuracy (Correct%) by question category (Qwen3.5-9B, Claude-Sonnet judge, 1,586 questions). Best per column in bold.

MethodSingle-hopTemporalMulti-hopOpen-dom.AdversarialOverall
Raw dialogue (full-context)74.77.230.131.22.539.1
Extracted (text)69.361.733.332.33.446.4
MemOS (retrieval)46.140.218.831.24.731.3
SFT (weight)23.710.313.114.611.716.9
OPSD (weight)70.261.333.525.010.646.9
VtR (weight + text)69.257.428.621.173.160.4

Table 15.

The HaluMem ranking reproduces. OPSD matches extracted text memory on the content categories (single-hop 70.2 vs 69.3, temporal 61.3 vs 61.7, multi-hop 33.5 vs 33.3) and edges it overall (46.9 vs 46.4), while both crush SFT (16.9); raw full-context again loses on temporal questions (7.2), where a whole conversation in the window obscures when each fact was held. The one category where every paradigm fails is adversarial: pure weight and pure text memory both sit near the floor (2.5–10.6), because neither reliably refuses an unanswerable question. This is the same absence-inspection failure as HaluMem’s memory-boundary category (§4.3), and it is exactly what the router repairs: verify-then-regenerate lifts adversarial accuracy to 73.1 and, without hurting the categories weight memory already answers, takes the overall best at 60.4, the same +13–15pt hybrid gain we see on HaluMem, now on an independent benchmark.

Absence is not inspectable in weights. The one category where text memory beats weight memory is the one where the correct answer is that nothing was recorded. The mechanism is not knowledge but inspectability: a text system reads a retrieved list, finds no such field, and reports its absence, whereas parameters offer nothing to inspect and instead supply a plausible value. The inventions are specific enough to be diagnostic, with concrete salaries and body weights produced for attributes the dataset never contained, inconsistently across ages for the same question. This is precisely the confabulation Deng [ [9] identify for single-turn personalization, reproduced here in a multi-session setting. About a fifth of the boundary “hallucination” verdicts are in fact valid abstentions scored wrong while a near-identical text refusal was scored correct, so the true fabrication rate is roughly 80% of the stated one; this is one instance of the rubric artifacts catalogued in Appendix A.11.

What the training recipe contributes. The recipe rather than the medium is what makes weight memory work, and we ablate it along every axis we could vary; the full sweeps are in Appendix A and we summarize it here. (1) Objective is the dominant lever: on-policy self-distillation (59.9%) beats both supervised fine-tuning on identical data (Table 1, 36.9%) and an off-policy variant that teacher-forces the teacher’s raw text rather than the student’s own samples, and full-parameter fine-tuning does not improve on the LoRA adapter (Appendix A.5). (2) Teacher construction is next: decoupling the teacher from the accumulating student to a frozen base model on capped cumulative memory removes a late-session collapse and is worth roughly +14 points over the horizon, while curriculum expansion of the training-QA pool, helpful in a single session, reverses online and is dropped (Appendix A.5). (3) Training data matters more than capacity: unknown-answer augmentation is solely responsible for the abstention ability. Removing it collapses the memory boundary from 88% to 1% and costs 14–16 points overall, with hallucination rising to 60%—while doubling the unknown/counterfactual budget or adding composite-QA augmentation is at best neutral (Appendix A.4). (4) Anti-forgetting replay of cached answers helps the tail but craters dynamic update, because re-supervising a stale answer re-teaches a superseded value (Appendix A.5). (5) By contrast capacity is nearly inert: adapter rank is flat from 16 to 128 (best at 64, 128 mildly overfitting) and training length is non-monotonic (Appendix A.3). Across all of these it is the objective and the training-QA set, not the size of the store, that determine what weight memory can do.

systemBasicConflictDynamicMulti-hopGeneral.BoundaryOverall
(311)(304)(94)(79)(311)(339)(1438)
oracle GT points74.377.357.440.534.477.064.0
text Extracted (dump)50.269.718.116.535.470.551.9
text Raw dialogue50.571.118.117.731.569.351.3
text MemOS (retrieval)33.858.626.610.122.589.147.8
weight SFT9.053.33.27.610.088.836.9
weight OPSD54.376.029.824.144.181.759.9
both VtR59.266.135.136.753.499.466.1

Table 1. Per-category accuracy (Correct%) on HaluMem’s native questions. GT points is an oracle (upper bound if memory point extraction is ideal); VtR is the verify-then-regenerate reader (§ 4.4). Overall gaps vs. OPSD are significant (paired McNemar p<10−9p < 10^{-9}).

Route design

Since the two memory systems fail on different questions, disagreeing on 445 of 1438, an oracle choosing the better one per question would reach 69.3% against OPSD’s 59.9%. The natural way to claim that prize is to inspect the query and decide which store to trust, and we report four attempts, all negative, because together they explain the design of §3.3.

Query-memory similarity carries no signal at all: correct and incorrect answers have indistinguishable top-1 similarity distributions (0.735 against 0.741 for weight memory, 0.737 against 0.737 for retrieval), so every threshold degenerates into always choosing the better system. A classifier over query embeddings, similarity features and cue tokens gains at most 0.9 points, and raw query embeddings actively hurt: whether the weights happen to have memorized a fact is not legible in the question. Confidence in the generated answer looks promising until it is deconfounded: per-token confidence correlates at 0.65 with answer length, and length correlates with correctness with opposite signs across categories, positively where the right answer is a verbose refusal and negatively where a rambling answer signals a miss, so a single global probe hides two opposing effects. Controlling for that with a length-constant probe, which teacher-forces a fixed refusal string of identical token length for every question, gives a genuinely clean detector, with an area under the curve of 0.918 for answerability and negligible correlation with answer length. But it detects answerability rather than correctness: against the event that the model is wrong, the same probe is at chance (0.516). Routing on it yields a single point, and under the retention protocol it collapses entirely, sending essentially every question to retrieval once the threshold drifts.

The common thread (Figure 3) is that all four signals are functions of the question and the model’s internal state, and none of them observes the answer that was actually produced. Verification does, which is why VtR takes the form it does.

Figure 3. Left: pabsp_{\mathrm{abs}} has near-identical distributions for correct vs. wrong age-0 OPSD answers (means 0.305/0.306), so no threshold separates them. Right: query-side signals predict correctness at chance (red, AUC≈\approx0.5) but pabsp_{\mathrm{abs}} predicts answerability at 0.918 (blue): confidence knows if a question is answerable, not if the answer is right. Details in Appendix § 6.10.

VtR reaches 66.1%, an improvement of 6.2 points over OPSD (p=2×10−6p = 2 \times10^{-6}, user-clustered interval [3.6, 8.6]) and 18.2 over the best text baseline, and unlike any of the selection mechanisms above it improves at every question age (Figure 1). The gate keeps 37.9% of answers and regenerates the rest. Its behaviour is category-dependent in a way that matches the per-category picture (Table 8, Appendix § 6.7): it improves five of six categories, and every memory-boundary question is flagged, correctly, since nothing in the store supports an unanswerable question, and the regenerated answer is a refusal, which lifts that category to 99.4%.

Table 8: VtR routing behaviour by category (native protocol, n=1438n=1438). “regen.” is the share of the category the gate sent to regeneration; Δ\Delta is VtR’s gain over OPSD (accuracies in Table 1). VtR improves five of six categories and regresses only on memory conflict, diagnosed in § 4.4.

categoryregen.Δ\Delta vs. OPSD
Memory boundary100%+17.7
Multi-hop inference67%+12.7
Generalization & application66%+9.3
Dynamic update60%+5.3
Basic fact recall42%+4.8
Memory conflict36%−9.9
Overall62%+6.2

Table 8.

Conclusion

Today’s agents keep a user’s memory in text and pay for it on every turn. We showed that this memory can instead live in a model’s weights by training with OPSD. Parametric memory should be held back not by the model or data but by the training protocol, since SFT on the same data has distinct performances. The characteristic study conducted on weighted-based memory demonstrates that it excels with recent material but forgets as facts age and cannot tell when a fact was never recorded; the regimes where a text store still wins. Our verify-then-regenerate router lets the weight memory answer and then checks that answer against the text store. For an agent, this suggests a concrete design: consolidate a user’s recurring or widely shared knowledge into weights while keeping a text store for the recent and the absent, and compose the two by verifying answers.

The broader opportunity is that weight memory changes what an agent can afford to remember. Because the write cost is paid once and the read cost is negligible, the natural unit to internalize is not a single user’s history but a pattern mined across many of them: a workflow that thousands of users repeat, a tool-calling convention, a recurring preference, or an interaction style. Distilling such shared regularities, with per-user memory layered on top, would let a harness carry common competence in its weights and reserve retrieval for what is genuinely individual and current. This also points beyond text. The same objective should apply to procedural and skill memory, to tool use, and, with a multimodal teacher, to knowledge that never had a clean textual form, so that an agent accumulates capability rather than merely facts, which marks the future direction of this research.

Additional results

Implementation details

All conditions use Qwen3.5-9B as the reader; the memory-point extraction, text-store management, training-data augmentation, and question answering are performed by this same model. OPSD trains a per-user LoRA adapter of rank 64 (α=128\alpha=128) for 30 rounds per session, sampling 60 on-policy questions per round; the adapter is persistent across sessions. The teacher is the same base model conditioned on a recency-bounded window of the user’s memory, capped at 12,000 characters (current session always kept, whole older sessions dropped to fit). Retrieval, for both the MemOS baseline and the verify-then-regenerate router, uses Qwen3-Embedding-0.6B with cosine top-5 fetch. The judge is Claude Sonnet 4.6 with a correct/hallucinated/omitted rubric and no partial credit. These settings are fixed across the experiments below unless a subsection states otherwise.

Model scale: the effect is not specific to Qwen3.5-9B

The main comparison uses Qwen3.5-9B; we repeat it at 4B and 27B so the ranking is not read as a single-model artifact. Table 3 collects results over all three scales. OPSD leads every text baseline at both sizes, and supervised fine-tuning on the identical data is the weakest condition by a wide margin at 4B and 9B but rises steeply with model size while distilled OPSD stays high, so the gap between the plain and the distilled recipe closes as the base model strengthens. Besides, the advantage of OPSD over the text-based model strengths from 1.2% at 27B to 8.0% at 9B and 9.4% at 4B, indicating that the performance of smaller based model can be enhanced more significantly with OPSD.

method/model scale4B9B27B
OPSD (weight)57.459.962.6
Extracted (dump)48.051.961.4
MemOS (retrieval)45.647.847.4
SFT (weight)15.936.958.3

Table 3. Model-scale comparison over full question set used in the main text; OPSD leads every text baseline at every scale on the full-horizon set; SFT rising steeply with model size while distilled OPSD stays high, so the recipe gap closes as the base model strengthens. Besides, the advantage of OPSD over its teacher (Extracted) grows along with smaller models.

LoRA rank sweep

Table 4 sweeps adapter rank for the weight memory on the pooled all-age set. Accuracy is nearly flat from r=16r=16 to r=64r=64, peaks at r=64r=64, and r=128r=128 regresses with the highest hallucination rate, consistent with mild overfitting rather than a capacity ceiling. Rank is therefore not the operative variable in this range, which is why the main text fixes r=64r=64 and treats the training objective, not adapter size, as the lever (§ 4.2, § 4.3).

rankCorrect%Halluc%Omit%
r=16r=1637.931.230.8
r=32r=3239.228.732.1
r=64r=6439.529.930.6
r=128r=12837.234.728.1

Table 4. LoRA rank sweep (HaluMem-Long, pooled n=4428n=4428), Correct/Halluc/Omit%. Alpha = 2r2r, 100 steps.

Augmentation ablations

The training data, not the storage medium, determines what weight memory can do, and the augmentation ablations locate the effect precisely. Table 5 reports the decisive one: removing the synthetic unknown-answer pairs (the u0u_0 column) collapses Memory Boundary from roughly 88% to under 4% and costs 14–16 points overall, with hallucination rising to about 60%. The model’s entire ability to abstain is learned from those refusals; it is not a free byproduct of parametric storage. This is the quantitative backing for the training-recipe paragraph of §4.3.

conditionBasicConflictDynamicMulti-hopGeneral.BoundaryOverallHalluc%
r64r64, n5u1c1 (base)14.656.87.110.611.888.439.529.9
r64r64, n5u0c1, s10024.655.921.419.217.40.823.6∼\sim60
r64r64, n5u0c1, s20028.856.622.718.420.63.425.9∼\sim60

Table 5. Unknown-augmentation ablation (HaluMem-Long, pooled n=4428n=4428), Correct%. n5u1c1 keeps the unknown pairs, n5u0c1 removes them. The entire loss is concentrated in Memory Boundary.

Two further augmentation findings are directional (small categories) but consistent. First, doubling the unknown and counterfactual budget (u2c2u_2c_2 vs u1c1u_1c_1) is net-negative: on the HaluMem-Medium session probe it trails u1c1u_1c_1 by 3–4 points at every training length, but adds about +5 points on Memory Boundary while collapsing Generalization (27 → 18) and Multi-hop (33 → 22). Second, an embedding-graph composite-QA augmentation (u1c1cmp1u_1c_1cmp1) reaches 50.0 ± 1.9% at 200 steps on the same probe, its best cell, and accuracy declines monotonically with more steps for both augmentation levels, indicating overfitting past roughly 200 training steps rather than an undertraining regime.

These two results come from a smaller HaluMem-Medium probe (8×108 \times10 users, 196 questions, training with SFT) and are reported as directional; they motivate the "capacity is not the operative variable" claim of § 4.3 but should not be read as precise.

Training objective and anti-forgetting

The following recipe results are directional—they explain how the OPSD configuration in the main text was arrived at. Objective. On the session-0 probe the objective ladder is monotone: an off-policy variant that teacher-forces the teacher’s raw answer text reaches 47% and suffers repetition/degeneration from exposure bias, whereas the on-policy formulation (the student samples its own answer and the teacher scores those tokens) reaches 61% with clean generations; supervised fine-tuning on the same data is the weakest and is the row reported in the main comparison (Table 1). Full-parameter fine-tuning of the base model, on the value-only pipeline, does not beat the rank-64 LoRA adapter and is far more expensive, so we keep the adapter. Teacher construction. The dominant fix over the multi-session horizon is teacher decoupling: replacing the accumulating-student teacher (which itself degrades over sessions) with a frozen base model reading capped cumulative memory lifts the full run from about 51% to about 65% on the first-10-session probe (+14 points), with the largest gains on Generalization (20→5020 \to50) and Basic Fact (56→7856 \to78), and removes the late-session collapse. Curriculum expansion of the training-QA pool, which helped on the single-session probe (reaching the ∼\sim80% teacher ceiling), reverses online: growing the pool to 1000+ generated questions dilutes the native facts, so the best multi-session configuration is base teacher with a fixed cache pool and no expansion. A more aggressive questioner is worse still: a learned questioner trained with a GRPO objective to maximize the student–teacher KL divergence, that is, to ask whatever the student is currently worst at, reaches only 26% on the session-0 probe against on-policy OPSD’s 61%, because the difficulty-chasing reward collapses the generated pool onto a single question type and starves it of diversity. The lesson across both variants is that the questioner should broaden coverage of the recorded facts, not maximize hardness. On the full long horizon, an SFT-replay anti-forgetting term (rehearsing cached answers to old questions) helps the far tail (age-100 27 →\to 32%) but craters Dynamic Update, because re-supervising a cached answer re-teaches a value that has since been superseded, a concrete instance of weight memory and volatile facts interacting badly. Round count is non-monotonic with 30 rounds the sweet spot. This is the mechanism behind the retention-versus-freshness tension in § 4.3.

Full retention detail

Breaking OPSD’s retention curve (Figure 1 in the main text) into the six question categories makes the non-uniform-forgetting claim of § 4.3 concrete: Memory Boundary is flat with age (the abstention habit persists, drifting 81.7 →\to 88.1) while every content category collapses toward the floor, Generalization and Multi-hop reaching 0.0 by age 100. The abstention behavior is a habit that survives; the knowledge is what decays. Table 6 gives the accompanying Correct/Halluc/Omit trajectory: as

agennCorrect%Halluc%Omit%
0143859.933.07.1
20105239.049.811.2
4080336.053.710.3
6059333.657.29.3
8036432.454.712.9
10017832.651.715.7

Table 6. OPSD verdict mix by question age (auxiliary protocol). Hallucination, not omission, grows with forgetting.

OPSD forgets, hallucination climbs from 33.0 to over 50% while omission barely moves, so the model becomes confidently wrong rather than appropriately cautious.

Table 7 gives per-category accuracy for all paradigms on the pooled all-age set, the counterpart to the age-0 Table 1. Read against the age-0 table it shows where the ranking inverts: MemOS, flat with age, overtakes OPSD on the aged pooled set overall (46.1 vs 43.7) and on most content categories, while OPSD keeps a clear lead only on Memory Conflict (57.2 vs 47.7). This is the honest scope condition on § 4.2: weight memory’s advantage is concentrated on recent material.

conditionBasicConflictDynamicMulti-hopGeneral.BoundaryOverall
GT points (oracle)76.573.260.643.933.575.663.4
Extracted (dump)42.150.126.720.821.083.446.7
MemOS (retrieval)32.447.724.516.918.695.946.1
Raw dialogue31.141.518.910.217.569.537.3
OPSD (weight)26.657.213.412.221.683.843.7
LoRA r64 (persistent adapter)14.656.87.110.611.888.439.5

Table 7. Per-category accuracy on the pooled all-age set (HaluMem-Long, n=4428n=4428), Correct%. Counterpart to the age-0 Table 1.

Verify-then-regenerate: full breakdown

Table 8 gives VtR’s per-category regeneration behavior, referenced from § 4.4; the main text reports its retention (Figure 1). Table 9 gives the by-age accuracies behind those, and Table 10 the gate accounting. VtR improves at every age including age 0, with the largest gains at ages 20–80 where OPSD has forgotten but retrieval still holds the fact. The gate keeps 22% of answers as SUPPORTED and regenerates the rest; of the 3434 regenerated answers it fixes 814 and breaks 277 (net +537, a 21% damage rate on the already-correct answers it touched).

Routed hybrids and oracle ceilings

Because the two memory systems fail on different questions, a per-question oracle that always chooses the better arm reaches 69.3% against OPSD’s 59.9% at age 0; this is the prize the negative routing signals of § 4.4 could not claim. Table 11 shows the practical routed hybrids we ran fall well short of it. Routing stable facts to a LoRA and volatile facts to a text arm never beats the best single non-oracle text method (MemOS at 46.1% pooled), because the LoRA loses to retrieval even on the stable slice it is handed, and a ground-truth stability oracle for the route does not rescue it. The LLM router is a high-recall, low-precision volatile detector (agreement with the ground-truth route 71.6%, volatile recall 99.6%), so it over-routes to the text arm. This is why the main text pursues verification (which observes the produced answer) rather than query-side routing.

routed variantrouteCorrect%%LoRA
full-LoRA r64r64 + extractionLLM route46.218.8
full-LoRA r64r64 + extractionGT route46.048.3
stable-LoRA + extractionGT route43.548.3
stable-LoRA + MemOSGT route41.248.3
oracle (any arm correct, age 0)—69.3—

Table 11. Routed hybrids (HaluMem-Long, pooled n=4428n=4428), Correct%. %LoRA is the share of questions answered by the weight arm. No routed hybrid beats plain MemOS (46.1%); the oracle ceiling is far above all of them.

Retrieval recency is a binary cliff, not a gradient

A natural hypothesis is that retrieval accuracy degrades gracefully with how stale the fetched fact is. It does not. Once question age and category are controlled and Memory Boundary is excluded, the graded session-distance correlation is negligible for all three paradigms (∣r∣≤0.10|r| \le0.10; the pooled correlation has an inverted sign purely from age and boundary confounds, so we do not report it).

Table 9: VtR accuracy by question age (HaluMem-Long, all ages), Correct%. VtR improves over both single systems at every age.

agennOPSDMemOSVtRΔ\Delta vs OPSD
0143859.947.866.1+6.2
20105239.045.656.2+17.2
4080336.042.251.6+15.6
6059333.642.350.9+17.4
8036432.440.148.4+15.9
10017832.636.543.3+10.7

Table 9.

The real effect is binary: whether any retrieved fact comes from the current session. Table 12 shows this separates the paradigms cleanly: extracted memory collapses to 3% without a current-session fact (near-definitional, since it only sees the current session), OPSD gains +21 points, and MemOS is nearly flat at +3 points. That flatness is exactly why MemOS overtakes weight memory at high age. The only graded signal that survives is recency variance (a wider spread of retrieved-fact ages predicts worse accuracy by −0.07 to −0.10), a topic-drift/interference signature too weak to route on. These are working-note numbers (recency builder over the retrieval logs) and support the retrieval-is-flat reading of § 4.3.

Table 12: Accuracy conditioned on whether any retrieved fact is from the current session (within-age, non-boundary, n=3378n=3378), Correct fraction.

methodcurrent-session factno current-session factΔ\Delta
Extracted (dump)0.4190.032+0.387
OPSD (weight)0.4520.245+0.207
MemOS (retrieval)0.3310.300+0.031

Table 12.

Confidence signals for routing

§ 4.4 reports that confidence in the generated answer is not a usable global routing signal. This subsection gives the detail. Self-consistency (agreement across K=5K=5 samples) is a weak, category-dependent correctness signal that inverts on Memory Boundary: boundary accuracy rises with consistency up to the 95–99% bin (0.971) then collapses to 0.404 at perfect consistency, because a deterministic wrong value (a middle name grabbed from the surname) repeats perfectly while genuine abstentions vary in phrasing. Per-token confidence is orthogonal to self-consistency (r=−0.02r=-0.02) and slightly stronger, but on boundary it is largely an answer-length proxy (corr(length, ptc_mean)=0.65): a scoring penalty on the first token is diluted across a long abstention but dominates a one-word value. A single global correctness probe therefore averages two opposite confidence-to-correctness mappings and lands near chance (AUC 0.63). The signal only works once the boundary regime is separated.

The clean detector is a length-constant one. Teacher-forcing a fixed six-token abstain string (constant for every question, so length-confound-free by construction) and reading its probability gives an answerability detector with AUC 0.944 on the extraction baseline and, critically, AUC 0.918 when scored under the OPSD weight adapter, confirming the gate reads the model’s parametric knowledge state, not merely context visibility. But this detector predicts answerability, not correctness: against the event that the model is wrong it is at chance (0.516), and margin_lp/minp confidence features are actively anti-predictive. Routing on it yields a single operating point that gains only +1.0 point over OPSD at age 0 and turns net-negative pooled over ages, because once OPSD forgets the threshold degenerates to "always route to text." Table 13 collects the AUCs. This is the evidence base for the four negative signals of § 4.4 and for why VtR verifies the produced answer instead.

Table 13: Confidence-signal AUCs. The fixed-candidate abstain probe detects answerability well and transfers to weight memory, but no signal predicts correctness. Extraction-baseline numbers from the confidence-calibration note; OPSD transfer from the fixed-candidate note

signal / targetallnon-boundaryboundary
self-consistency →\to correct0.6060.6310.391 (inverts)
per-token conf. →\to correct0.6280.8550.931
per-token conf., age-0 only0.6720.7380.870
pabsp_{\mathrm{abs}} (fixed str.) →\to answerable, extraction0.944——
pabsp_{\mathrm{abs}} under OPSD adapter →\to answerable0.918——
pabs→p_{\mathrm{abs}} \to OPSD wrong (correctness)0.516——

Table 13.

gate outcomecountOPSD→final Correct%
SUPPORTED (kept)994 (22%)61.8 → 65.6
UNSUPPORTED + CONFLICT (regen)3434 (77%)38.5 → 54.1
regenerated, FIXED814
regenerated, BROKE277net +537, damage 21%

Table 10. VtR gate accounting (pooled n=4428n=4428). The merged store folds superseded values, which collapses false CONFLICT verdicts from 36% (raw store) to 1%.

Weak categories are partly measuring the rubric

Dynamic Update and Multi-hop Inference are our two smallest and lowest-scoring categories, and much of that score reflects the evaluation rubric rather than the memory systems. On the 173 age-0 questions in these two categories, 97 (56%) are failed by all five methods including full context, which sees the entire dialogue, so retrieval cannot be the dominant cause. Table 14 buckets those 97 universal failures: only about half are genuine content errors, while 34% have a gold answer not fully recoverable from the evidence the dataset itself cites (Multi-hop golds are abstractive one-line summaries; only 48% are fully reconstructible from the cited evidence) and 11% are cases where a method stated the gold verbatim and was still scored wrong. Verbosity is punished: hallucination-judged answers carry a median of 28 content words against a 4-word median gold, and 14.4% of all hallucination verdicts contain at least 80% of the gold content plus extra true-but-unasked detail. Even the per-question oracle reaches only 0.48/0.39 here versus 0.74–0.98 elsewhere. The honest reading is that roughly 45% of all-method failures in these categories are rubric or gold artifacts, so the 0.24–0.30 numbers should be read against an achievable ceiling of 0.39–0.48, not as a system failure. This rubric artifact is the reason we do not tune the router on these categories.

Table 14: The 97 age-0 Dynamic Update + Multi-hop questions failed by all five methods, bucketed by cause. Nearly half are gold or rubric artifacts rather than system defects.

bucketnnshare
Genuine content error (all methods wrong differently)5153%
Under-specified gold (not recoverable from cited evidence)3334%
Judge strictness (gold stated verbatim, still marked wrong)1111%
Universal abstention (date-scoping)22%

Table 14.

Representation dominates age on HaluMem-Medium

On HaluMem-Medium, where each user’s full history (∼160\sim160k tokens) still fits the context window, the representation of memory matters far more than question age. Answering the same cumulative questions from ground-truth points, extracted memory, and raw dialogue gives 63.7% > 57.6% > 54.2% overall, with accuracy nearly flat across age in every condition (no long-context decay at this scale). The extraction-over-dialogue win is entirely a Memory Boundary effect (dialogue 46.6% vs extraction 72.6%): a clean extracted list lets the reader say "unknown," whereas a raw transcript invites a hallucinated answer, and on every other category extraction slightly loses to raw dialogue because extraction drops or fragments detail. This localizes where compression helps (abstention) and where it hurts (fine detail), and it is why the main results use the longer HaluMem-Long, where the context wall actually bites. from a cumulative-representation probe (8 users, 8630 questions/condition)

RouterMem-Mini: volatile facts are the hard axis

To probe volatile-versus-stable memory more directly than HaluMem allows, we built RouterMem-Mini, a small generator (8 users ×\times 20 sessions) with an enriched volatile-fact axis (173 of 520 questions typed volatile through explicit update chains) and genuinely unanswerable Memory Boundary questions. The round-2 evaluation confirms the split that motivates routing: text methods drop from 66–69% on stable facts to 31% on volatile facts, and the weight memory drops from 29–31% to 8%. Improved third-person minimal-span augmentation did not lift the weight memory (22–23% overall, r=100≈r=200r=100 \approx r=200), which holds only on Memory Boundary abstention (92–94%), confirming that the roughly 20% weight-memory ceiling on this data is a weight-memory limit and not an augmentation-quality artifact. This corroborates the volatile-facts finding of § 4.3 on an independently generated benchmark.

Where each memory system wins, qualitatively

The one robust place text memory beats weight memory is absence. Analyzing the disjoint wins at age 0, the only category where either MemOS or extracted memory beats OPSD net is Memory Boundary: of 120 MemOS-only wins, 47 are boundary questions where OPSD confabulates a value (its boundary omission rate is 0.000, so it never abstains, it invents), and the clearest sub-pattern is the "precise unrecorded attribute" question (a salary, an exact weight, a film title the dataset never recorded) where a text system reads its list, finds no such field, and reports the absence, while OPSD produces a concrete number, inconsistently across ages for the same question. The remaining non-boundary "wins" are mostly not a text-memory capability: about 18% are OPSD over-answering artifacts (it contained the gold but added extra true detail and was scored wrong) and a majority are lenient passes where the text answer contained under half the gold content. We include this because it is the honest mechanism behind the one category OPSD loses in § 4.2 and § 4.3: inspectability, not knowledge. We also flag a judge inconsistency found here, where roughly 20% of OPSD’s "hallucination" verdicts on boundary questions were correct abstentions scored wrong while a near-identical text abstention was scored correct, so the stated OPSD fabrication rate is inflated by about a fifth.

LoCoMo second benchmark: full per-category breakdown

Table 15 gives the per-category accuracy behind the overall comparison in Figure 2. We port LoCoMo and use its standard protocol (all questions asked once after the full conversation) over LoCoMo’s five categories, mapping its adversarial category to abstention (the answer is not in the conversation). Weight memory is the pooled variant (all sessions distilled into a single adapter, since there is no age axis). OPSD tracks extracted text memory across every content category and edges it overall (46.9 vs 46.1); both, like all paradigms, fail on adversarial (unanswerable) questions, which verify-then-regenerate repairs (73.1) to take the overall best (60.4). This mirrors the HaluMem result—weight memory competitive with text on content, the router winning through recovered abstention—on an independently-constructed benchmark.

References

  1. [1]Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G Patil, Ion Stoica, and Joseph E Gonzalez. MemGPT: Towards llms as operating systems. arXiv preprint arXiv:2310.08560, 2023.arxiv.org/abs/2310.08560
  2. [2]Bernal Jiménez Gutiérrez, Yiheng Shu, Weijian Qi, Sizhe Zhou, and Yu Su. From rag to memory: Non-parametric continual learning for large language models. arXiv preprint arXiv:2502.14802, 2025.arxiv.org/abs/2502.14802
  3. [3]Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. A-mem: Agentic memory for llm agents. Advances in Neural Information Processing Systems, 38:17577–17604, 2026a.arxiv.org/abs/2502.12110
  4. [4]Zhiyu Li, Chenyang Xi, Chunyu Li, Ding Chen, Boyu Chen, Shichao Song, Simin Niu, Hanyu Wang, Jiawei Yang, Chen Tang, et al. Memos: A memory os for ai system. arXiv preprint arXiv:2507.03724, 2025.arxiv.org/abs/2507.03724
  5. [5]Seungju Back, Dongwoo Lee, Naun Kang, Taehee Lee, SK Hong, Youngjune Gwon, and Sungjin Ahn. Understanding lora as knowledge memory: An empirical analysis. arXiv preprint arXiv:2603.01097, 2026.arxiv.org/abs/2603.01097
  6. [6]Ziwen Xu, Haiwen Hong, Linsong Yu, Benglei Cui, Longtao Huang, Hui Xue, and Ningyu Zhang. How lora remembers? a parametric memory law for llm finetuning. arXiv preprint arXiv:2605.30260, 2026b. Verbatim-recall scaling law (rank × length); token p = 0.5 phase transition; MemFT.arxiv.org/abs/2605.30260
  7. [7]Guibin Zhang, Xun Xu, Yanwei Yue, Zikun Su, Wangchunshu Zhou, Xiaobin Hu, and Shuicheng Yan. Opd-evolver: Cultivating holistic agent evolver via on-policy distillation. arXiv preprint arXiv:2606.17628, 2026a. On-policy distillation of a privileged hindsight teacher into a context-free student; procedural/skill memory inside a whole-agent evolver.arxiv.org/abs/2606.17628
  8. [8]Tao Feng, Xinke Jiang, and Chao Wu. Kbsd: Knowledge boundary aware self-distillation for behavioral calibration in agentic search. arXiv preprint arXiv:2606.29863, 2026a. Information-asymmetric self-distillation (hint teacher → hint-free student); retriever stays live at eval, unlike the context-free premise here.arxiv.org/abs/2606.29863
  9. [9]Youwang Deng. Substrate asymmetry in user-side memory: A diagnostic framework. arXiv preprint arXiv:2606.11712, 2026. Per-user LoRA wins style, RAG wins absence-calibration; concludes weight memory cannot match text memory – the claim this work overturns.arxiv.org/abs/2606.11712
  10. [10]Ding Chen, Simin Niu, Kehang Li, Peng Liu, Xiangping Zheng, Bo Tang, Xinchi Li, Feiyu Xiong, and Zhiyu Li. Halumem: Evaluating hallucinations in memory systems of agents. arXiv preprint arXiv:2511.03506, 2025.arxiv.org/abs/2511.03506
  11. [11]Adyasha Maharana, Dong-Ho Lee, Sergey Tulyakov, Mohit Bansal, Francesco Barbieri, and Yuwei Fang. Evaluating very long-term conversational memory of llm agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13851–13870, 2024.
  12. [12]Tao Feng, Pengrui Han, Guanyu Lin, Ge Liu, and Jiaxuan You. Thought-retriever: Don’t just retrieve raw data, retrieve thoughts for memory-augmented agentic systems. arXiv preprint arXiv:2604.12231, 2026b.arxiv.org/abs/2604.12231
  13. [16]Yiming Du, Wenyu Huang, Danna Zheng, Zhaowei Wang, Sebastien Montella, Mirella Lapata, Kam-Fai Wong, and Jeff Z Pan. Rethinking memory in ai: Taxonomy, operations, topics, and future directions. arXiv e-prints, pages arXiv–2505, 2025.
  14. [17]Yuanze Hu, Yu Wang, and Julian McAuley. Evaluating memory in llm agents via incremental multi-turn interactions. In International Conference on Learning Representations, volume 2026, pages 156259–156291, 2026.arxiv.org/abs/2507.05257
  15. [18]Pengfei Du. Memory for autonomous llm agents: Mechanisms, evaluation, and emerging frontiers. arXiv preprint arXiv:2603.07670, 2026.arxiv.org/abs/2603.07670
  16. [19]Kevin Meng, David Bau, Alex Andonian, and Yonatan Belinkov. Locating and editing factual associations in gpt. Advances in neural information processing systems, 35:17359–17372, 2022.arxiv.org/abs/2202.05262
  17. [20]Sidi Lu, Zhenwen Liang, Dongyang Ma, Yan Wang, Haitao Mi, and Dong Yu. Locas: Your models are principled initializers of locally-supported parametric memories. arXiv preprint arXiv:2602.05085, 2026.arxiv.org/abs/2602.05085
  18. [21]Guhao Feng, Shengjie Luo, Kai Hua, Ge Zhang, Wenhao Huang, Di He, and Tianle Cai. In-place test-time training. In International Conference on Learning Representations, volume 2026, pages 114452–114472, 2026c.arxiv.org/abs/2604.06169
  19. [26]Siyan Zhao, Zhihui Xie, Mengchen Liu, Jing Huang, Guan Pang, Feiyu Chen, and Aditya Grover. Self-distilled reasoner: On-policy self-distillation for large language models. arXiv preprint arXiv:2601.18734, 2026. URL https://arxiv.org/abs/2601.18734.

Paper details

vlnc:W_4b3apgks
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents