betaFeedback

WorksComputer Science

HabitusMem: Belief Memory over Evolving User Preferences for LLM Agents

Abstract

Personalized LLM agents must act on a user's current preferences, which change across interactions and are rarely stated in full. Existing memory systems store and retrieve content from the interaction history and leave the agent to work out which preferences still hold and where they apply. Such content does not indicate whether a preference is still current or where it applies, so agents often act on outdated or misapplied preferences. We instead treat memory as the assistant's belief about the user. Following Bourdieu's account of habitus as durable but revisable dispositions, we model the user as a latent preference state that every interaction, including the current request, both reveals and updates. The belief summarizes what the history supports about this state, and memory consists of the individual beliefs that bear on the agent's current decision, each with its evidence, scope, and status. We implement this view in HabitusMem, a trained writer that states these beliefs as text records for a frozen agent. Across two agent families, HabitusMem achieves the best results among memory systems on both PersonaMem-v2 and VitaBench 2.0. Controlled analyses show that learned request conditioning drives the answering gain, while auxiliary training tasks improve tool use.

Code: https://github.com/csyifan/HabitusMem

Introduction

Large language model (LLM) agents increasingly assist the user across many interactions, answering questions and carrying out tasks on the user’s behalf (Jiang et al. [13], Chen et al. [7]). Useful assistance depends on preferences and constraints that a new request rarely states in full. These preferences form through repeated choices, persist across situations, and change over time: a user who has moved supplies a new delivery address, a user who has lost interest in a topic asks the assistant to stop raising it, and a gift chosen for a friend reveals little about the user’s own taste. The agent must therefore act on the user’s current preferences, which it can only infer from what the user has said and done.

Existing memory systems carry this information across interactions by storing content derived from the history: they extract facts, maintain notes or summaries, or retrieve and compress past passages for the current request (Zhong et al. [51], Chhik̄ara et al. [9], Xu et al. [42], Lewis et al. [18], Jiang et al. [15]). Such memory records what the user said or did rather than what the history implies about the user now (Figure 1), and it leaves three questions to the agent. How strongly does the history support a claim? Memory stores claims without their evidential basis, so a disposition confirmed across many interactions and an incidental or indirect observation enter in the same form, and the agent cannot weigh one against the other. Where does a claim apply, and does it still hold? Entries carry no scope or status. Update operations overwrite or delete earlier entries and thus erase the difference between a preference that has changed and one that has only been withdrawn; without them, contradictory entries coexist with nothing to mark which is current, and a context-specific instruction cannot be told apart from a standing preference. Which claims matter for the decision at hand? Memory is written or retrieved by salience and surface similarity rather than by relevance to the agent’s decision, so it can drop constraints the decision depends on and abstract away details that the action requires exactly.

Figure 1. Content-based memory method versus belief memory on a personalized order. The user has repeatedly rejected Penfolds wine and now asks for a bottle of wine without naming a brand. Content-based memory methods pass on fragments such as past purchases and a negative review, and agents using them order the wrong wine or none at all. HabitusMem infers that the user prefers mid-priced layered reds and rejects Penfolds, records the evidence, scope, and status of each belief, and leads the agent to the same order as the ground-truth profile.

The underlying problem is that these designs represent the history, whereas personalization needs a representation of the user. Bourdieu’s concept of habitus describes what personalization targets: durable dispositions, formed through past experience, that generate practices in concrete situations [5]. These dispositions are durable but revisable, since new experiences are perceived through categories formed by earlier ones and in turn reinforce or modify them [6 p. 133]. For an assistant, this suggests modeling the user as a latent preference state shaped by the whole history and carried forward by every interaction, including the current request. A belief-state view makes this concrete [2]: earlier interactions form the assistant’s belief about the user, each new interaction revises it, and the current belief summarizes what the history supports about the user’s present state. We express this belief as a set of individual beliefs, each a claim about the user’s preferences, circumstances, or constraints, and define memory as the subset of these beliefs that bears on the agent’s current decision, since the agent acts to minimize expected loss under the belief. Memory is thus composed of beliefs about the user rather than of content from the history. Each of the three questions then has a direct answer. A claim’s evidence conveys its credibility; its scope and status convey where it applies and whether later observations have left it active, superseded, or retracted; and the decision posed by the request determines which claims to include.

We instantiate this view in HabitusMem, a writer that composes memory from belief records of the form claim | evidence | scope | status, one belief per record, for a frozen agent. Reading the raw history and the current request, the writer answers the three questions directly: it cites the observations that support each claim, marks its scope and whether later interactions have superseded or retracted it instead of overwriting it, and keeps only the claims that bear on the request, with the exact choices and constraints an action requires. A single model learns these operations from four tasks that mirror belief tracking: direct writing infers claims and their evidence, state update revises them with new interactions, and request and action projection select those a question or transaction depends on. The resulting memory works with different agents without modifying them. Across two agent families, HabitusMem achieves the best results among memory systems on PersonaMem-v2 and VitaBench 2.0, and controlled analyses attribute its gains to learned request conditioning and the auxiliary tasks. Our contributions are as follows:

  • We reframe personalized memory as the assistant’s belief about the user following Bourdieu’s account of habitus. The resulting memory states how credible each preference is, where it applies, whether it has changed or been withdrawn, and whether it matters for the current decision, enabling the agent to act on the user’s current preferences.

  • We introduce HabitusMem, a writer that states each belief as a text record with its evidence, scope, and status for a frozen agent. A single adapter learns belief inference, belief update, and decision projection from four training tasks, which supports both personalized answering and task execution that depends on exact constraints.

  • On PersonaMem-v2 and VitaBench 2.0, with two agent families, HabitusMem is the most accurate compact memory for personalized answering and the most consistent for personalized tool use, where it also surpasses giving the agent the full history.

Related Work

Memory for LLM agents. Agent memory systems differ in their substrate, their cognitive analogy, and whose experience they store [12]. User-centric systems maintain external stores of extracted facts, notes, or summaries that are retrieved for later requests [51, 24, 9, 42, 25]. Other designs organize memory after human cognition, for example through episodic event segmentation or Hebbian association [10, 52], and agent-centric memory accumulates the agent’s own task experience [32, 23, 36]. A growing line learns memory operations, either by writing knowledge into model parameters [34 a] or by optimizing memory edits against downstream reward with reinforcement learning [44, 35, 45]. Retrieval augmentation and query-aware compression instead select or shorten passages for the current input [18, 15, 39]. Across these designs, an entry records what was said or observed without stating how credible a claim is, where it applies, or whether a later observation has superseded or retracted it. HabitusMem keeps the raw history as the source of evidence and defines memory as the part of the assistant’s belief about the user that bears on the current decision, with these properties stated in each record.

Personalized agents and benchmarks. Personalized agents extend LLMs with user profiles, memory, planning, and action execution [43]. Profile modeling builds persona descriptions of stable traits [29, 50, 31] or factorizes preferences over candidate responses [1, 3] (Shenfield et al. 2025), and agent designs adapt to the user or act on the

Methodology

user’s behalf ([19, 46, 28]). CAPE learns population-level preference priors and uses Bayesian inference to guide cold-start preference elicitation ([4]). Westhäußer et al. [37] combine persistent memory with continuously updated user profiles, query-dependent retrieval, and self-validation. Personalized planning conditions decisions on profiles and memory in a single pass ([47, 20, 40]) or refines plans through clarification, user revision, or environment feedback ([30, 48, 16]), and personalized execution grounds tool selection and arguments in user preferences ([41, 8, 17]) or re-ranks and proactively suggests outcomes ([11] (Li et al. 2022)). These components consume user memory but leave its content to summarization or similarity-based retrieval, which does not separate credible, applicable, and current preferences from the rest. Benchmarks have moved from profile-conditioned generation ([26]) and long-term conversational recall ([22] (Wu et al. 2024)) to preferences that are implicit and evolving ([13 b]) and must be applied in tool-using tasks ([7]). We evaluate on the last two settings, in which the agent must infer which preferences currently hold before acting on them.

Methodology

HabitusMem composes memory from the assistant’s beliefs about the user’s current preference state, selected for the decision the agent faces. As Figure 2 shows, a single writer reads the raw interactions together with the current request, infers beliefs with their evidence, scope, and status, and passes those that bear on the request to a frozen agent. § 4.1 formalizes the belief and the decision it serves, § 4.2 describes how the writer expresses the belief as text records, and § 4.3 describes how it is trained to infer, revise, and select beliefs.

Figure 2. Overview of HabitusMem. The writer takes the retained raw interactions and the current user query as input and infers belief records, each with its evidence, scope, and status. It then projects only the beliefs that bear on the user query to the agent, which answers or acts on the user query. Here, the bland diet and the late-shift hospital address shape the dinner order, whereas the partner-specific vegetarian preference and the one-off oat-milk instruction are kept but not projected. A single writer learns these steps from four tasks: direct writing, state update, request projection, and action projection.

Problem formulation

Let ztz_t denote the user’s preference state at interaction tt, comprising the durable dispositions, current circumstances, and explicit constraints that shape what the user wants. The state evolves: a new experience may reinforce a disposition, modify it, or lead the user to withdraw it, which we describe by a transition p(zt∣zt−1)p(z_t \mid z_{t-1}). The assistant observes the state only through interactions ot∼p(ot∣zt)o_t \sim p(o_t \mid z_t), such as statements, choices, corrections, and requests. The current request qtq_t is the most recent of these observations: it carries evidence about the user and also poses the decision that the agent must make. Given the history Ht=(o1,…,ot)H_t = (o_1, \ldots, o_t), the belief that the history supports is

bt(zt)=p(zt∣Ht)∝p(ot∣zt)∫p(zt∣zt−1) bt−1(zt−1) dzt−1.(1)b_t(z_t) = p(z_t \mid H_t) \propto p(o_t \mid z_t) \int p(z_t \mid z_{t-1})\, b_{t-1}(z_{t-1})\, dz_{t-1}. \tag*{(1)}

The recursion mirrors the account of habitus, in which each observation is interpreted through the belief formed by earlier ones and either reinforces or revises that belief. The same belief can equally be read from the complete history at once, and we use Equation (1) as a conceptual account of how the belief should respond to evidence.

The belief describes the user, and memory conveys it to the agent that acts. Given the request qtq_t, a memory mm, and optional execution instructions gτg_\tau for task type τ\tau, a frozen agent produces an answer or action trajectory a∼A(⋅∣qt,m,gτ)a \sim A(\cdot\mid q_t, m, g_\tau), and a loss ℓτ(a,zt;qt)\ell_\tau(a, z_t; q_t) measures how poorly aa serves a user in state ztz_t. We score a memory by the agent’s expected loss under the belief and take the ideal memory to be the one that minimizes it,

Rτ(m;Ht)=Ezt∼btEa∼A(⋅∣qt,m,gτ)[ℓτ(a,zt;qt)],mt∗∈arg⁡min⁡m∈M Rτ(m;Ht),(2)R_\tau(m; H_t) = \mathbb{E}_{z_t \sim b_t}\mathbb{E}_{a \sim A(\cdot\mid q_t,m,g_\tau)}\left[\ell_\tau(a,z_t;q_t)\right], \qquad m_t^* \in\underset{m \in\mathcal{M}}{\arg\min}\ R_\tau(m; H_t), \tag*{(2)}

where M\mathcal{M} is the set of textual memories. Equation (2) separates two questions that content-based memory conflates. The belief determines how credible each claim about the user is, and the request determines, through the loss, which claims change the agent’s decision. A gardening preference is equally credible whether the user asks for a weekend activity or a train ticket, but only the first request makes it relevant. Conversely, an order can fail on a single wrong variant or quantity, so the memory must convey such details exactly. Under a fixed message budget, conditioning the memory on the request can only lower the best attainable risk.

The formulation also determines what a textual memory should state. Each record in HabitusMem has four fields. The claim states a fact, preference, or constraint about the user. Its evidence, the observations that support it, lets the agent distinguish a disposition established by repeated explicit statements from one inferred from a single choice. Its scope, the situations in which the disposition guides behavior, prevents a choice made for one occasion from steering every later request, since a disposition is expressed differently across situations. Its status records how the state has evolved, marking whether the claim remains active, has been superseded by a later preference, or has been retracted because the user asked the assistant to stop using it, which restricts its use without making it false.

Equations (1) and (2) serve as a design rationale that specifies what the writer should produce. Exact inference over natural-language histories is intractable, and HabitusMem neither estimates numerical posteriors nor optimizes Equation (2) through agent rollouts. Instead, a language-model writer is trained on reference memories to map a history and a request directly to belief records, and Appendix § 8 discusses how these records relate to the formulation.

Memory construction

Memory construction starts from the accumulated raw interaction log. New observations are appended to the log, and a position- and budget-based rule TτT_{\tau} selects the view Xt=Tτ(Ht)X_t = T_{\tau}(H_t) that fits the writer’s input: on PersonaMem-v2 it keeps the beginning of each history, and on VitaBench 2.0 it keeps the beginning together with the most recent interactions. This rule determines which evidence the writer can see, and the writer decides what enters the memory.

The writer receives the selected history, a format instruction II, and a suffix sτ(qt)s_{\tau}(q_t) containing the current request. For question answering, the suffix asks for facts and preferences that help answer the request. For agent tasks, an action suffix asks for explicit choices and fulfillment constraints, such as products, variants, quantities, addresses, and times, and asks the writer to keep explicit historical choices rather than inferred alternatives.

The output is a list of records under a ## Beliefs header, one per line in the form claim | evidence: source | scope: context | status: state. The four fields are those defined above. Together, the fields separate an enduring disposition, a one-off instruction, and a withdrawn preference. For example, an oat-milk order scoped to this delivery only keeps its exact quantity without steering later requests, and a spicy-food preference marked retracted (message 61) no longer guides restaurant choices.

We instantiate the writer with Qwen3.5-9B and one LoRA adapter shared across tasks. The writer generates the memory in one greedy decoding pass, and the agent acts on the records together with the current request,

m^t=GreedyDecode⁡[pθ(⋅∣I,Xt,sτ(qt))],a^∼A(⋅∣qt,m^t,gτ).(3)\hat{m}_t = \operatorname{GreedyDecode}\left[p_{\theta}\left(\cdot\mid I, X_t, s_{\tau}(q_t)\right)\right], \qquad\hat{a} \sim A\left(\cdot\mid q_t, \hat{m}_t, g_{\tau}\right). \tag*{(3)}

The execution instructions gτg_{\tau} direct the agent to apply relevant constraints, to make a choice when the user delegates one, and to complete the requested transaction. Whenever the history or the request changes, the writer rewrites the memory from the selected raw log and keeps no persistent state between requests; repeated reads with the same history and request reuse the cached memory.

Training

We train the writer in two stages on the official PersonaMem-v2 training split. The first stage produces a parent writer that infers beliefs from a history and a request. The second stage uses this parent as a frozen teacher to construct examples of the operations it lacks, belief update and decision projection, and trains HabitusMem on all of these operations together.

Stage 1: Parent writer training. Writing a useful belief requires both the record format and the ability to identify the preference a request depends on, so we teach them in turn. We first cold-start a Qwen3.5-9B LoRA adapter on belief memories from a frozen DeepSeek-V4-Flash teacher, which writes one schema-valid memory at each of two positions in every training history. This substep teaches the record syntax without using preference annotations. The resulting writer then generates a static belief memory for each persona, and for each training request we place the request’s annotated preference at the top of this memory as a new record. The status of the record follows the annotation, marking a preference as active, as superseding an earlier one, or as retracted, in which case the record names the topic but not the revoked content. Training on these memories teaches the parent to surface the belief that a request depends on. The parent sees no update or projection examples, so it cannot revise stored records or select them for a decision.

Stage 2: HabitusMem writer training. We initialize HabitusMem from the parent and train it on four tasks that cover inferring, revising, and selecting beliefs. Direct writing D1D_1 retains the Stage 1 targets and teaches belief inference from evidence. State update D2D_2 teaches belief revision. The parent processes each history chunk by chunk, a data builder merges the resulting records into a running state SkS_k, and each transition (Sk−1,chunkk)→Sk(S_{k-1}, \mathrm{chunk}_k) \to S_k yields an example of superseding or retracting earlier claims as new evidence arrives. Request projection D3D_3 and action projection D4D_4 teach the selection of beliefs for the current decision. From the final state, the parent writes the view that a request needs, and for requests that require execution the view must also preserve the exact choices and fulfillment constraints. Target preparation enforces the record syntax but does not check the factual content of the records. The writer minimizes the teacher-forced token loss

L(θ)=−∑k=14wk∑(x,m†)∈Dk∑jlog⁡pθ(mj†∣x,m<j†)(4)\mathcal{L}(\theta) = -\sum_{k=1}^{4} w_k \sum_{(x,m^\dagger)\in D_k} \sum_j \log p_\theta\left(m_j^\dagger\mid x,m_{<j}^\dagger\right) \tag*{(4)}

where wkw_k is the weight of task kk. All four tasks update one adapter, so that inference, update, and projection share parameters. Appendix § 9.§ 2 gives the target construction and training settings, and Appendix § 10.§ 1 compares task weights.

Experiments

We evaluate HabitusMem on PersonaMem-v2 for personalized question answering and on VitaBench 2.0 for personalized tool use. § 5.2 compares it with established memory systems, and § 5.3 isolates the contributions of request conditioning, the auxiliary tasks, and the record fields. Appendices § 10–§ 12 further report training-mixture and inference sensitivity, computational cost, controlled probes of evidence, scope, and status, and case studies.

Experimental setup

Benchmarks and metrics. PersonaMem-v2 (Jiang et al., [14]) evaluates personalized answering from long interaction histories, including changing preferences and requests to forget. We evaluate in the English 32k setting, whose test split contains 5,000 queries. The test queries span nine task scenarios. We report personalized QA accuracy on multiple-choice questions as the primary metric and a generation score assigned by an external Qwen3.5-9B judge. VitaBench 2.0 (Chen et al., [7]) contains 771 subtasks from 56 users, in which an agent uses tools to complete delivery, in-store consumption, and online travel tasks according to preferences implicit in past dialogues and behavior logs. We run four trials per subtask, with an external Qwen3.5-9B simulating the user and scoring the trajectory against the subtask rubric. We report average reward (Avg@4), success in at least one of four trials (Pass@4, any-success), and success in all four (Pass⁴, all-success).

Agents and comparison systems. We test personalization with two locally deployed agents, Qwen3.5-397B-A17B and DeepSeek-V4-Flash-0731. We compare with five compact memory systems: retrieval-augmented memory (RAG) [18], Rewrite (an LLM-rewritten history summary), Mem0 [9], A-MEM [42], and MemListener [49]. The base LLM receives no memory, and full context gives the agent direct access to the interaction history. On VitaBench 2.0, a ground-truth profile built from annotated preferences is an additional privileged reference. RAG and Rewrite are implemented in the evaluation harness.

Main results

Personalized answering. Table 1 shows that HabitusMem is the most accurate memory method under both agents, at 0.537 with Qwen and 0.484 with DeepSeek, 4.8 and 4.6 points above the strongest baseline. That baseline changes with the agent and the scenario, whereas HabitusMem leads in five of nine scenarios with Qwen and eight with DeepSeek, so belief memory transfers more uniformly than content-based memory. Conditioning on the request does not explain this advantage by itself, since RAG also retrieves for the current request yet reaches only 0.460 and 0.391. Retrieval returns what the user said that resembles the request, whereas a belief record states what the history implies about the user for that request. In the Knowledge scenario, the memory-free base LLM with Qwen outperforms full context and every content-based memory, indicating that injected history interferes with questions the agent could otherwise answer, whereas HabitusMem conveys only the relevant beliefs and exceeds full context by 13 and 11 points. Full context remains more accurate, as expected of a condition that loses no evidence, but the generation score shows what evidence alone does not provide. Moving from the memory-free base LLM to full context raises accuracy with Qwen and DeepSeek from 0.446 and 0.263 to 0.569 and 0.522, yet generation stays nearly flat, from 0.256 and 0.291 to 0.227 and 0.302, while HabitusMem reaches 0.326 and 0.382. Answer options likely cue the agent toward the relevant preference, which it can then recognize in the raw history, whereas an open answer requires the agent to infer and apply that preference unaided. Belief memory performs this inference before the agent acts, which is the motivation for representing the user rather than the history.

MemoryKnowledgePro-EmailPro-WritingCreativeTranslationPersonal-EmailTroubleChatSocialOverall
Qwen3.5-397B-A17B
Base LLM0.6440.4080.3810.4200.4380.4330.3930.3960.3860.446
Full context0.5190.5940.5730.5430.6240.5850.5990.5480.5650.569
RAG0.4360.4810.4530.4620.4860.4700.4370.4500.4740.460
Rewrite0.5190.5030.4660.4660.4790.4690.5090.4400.4850.484
Mem00.4900.4490.4880.4710.5330.4530.4750.4380.4150.470
A-MEM0.4330.4940.4570.5100.5030.5300.4970.5020.5150.489
MemListener0.4430.3990.4220.3730.4380.4040.4590.3880.4230.418
HabitusMem0.6490.5260.5290.5030.5570.5220.4870.4620.5320.537
DeepSeek-V4-Flash-0731
Base LLM0.3680.2300.2360.2570.2740.2320.2460.2650.2240.266
Full context0.5330.5120.5140.5120.5530.5450.5290.5160.5240.527
RAG0.4680.3710.3430.3960.4100.3720.3550.4020.3610.391
Rewrite0.5130.4190.4400.4010.4190.4150.4530.3940.4410.438
Mem00.4500.4120.3870.3790.4020.4390.4330.3730.4150.412
A-MEM0.5010.3670.3630.4160.3970.3880.4130.3860.3880.408
MemListener0.4150.3570.3830.3380.4020.3500.4050.3350.3740.376
HabitusMem0.6460.4300.4420.4710.4930.4780.4350.4020.4660.484

Table 1. Personalized QA accuracy on PersonaMem-v2 by task scenario. Bold and underlined values mark the best and second-best compact memory systems in each column.

Personalized tool use. Table 2 shows that HabitusMem obtains the highest average reward among memory methods under both agents and the highest all-success of any non-privileged condition, 0.1310 and 0.1284 against 0.1297 and 0.1102 for full context. The results reveal a gap between coverage and consistency. Rewrite succeeds at least once on 61% of subtasks with Qwen but in all four trials on only 7%, whereas among subtasks solved at least once, HabitusMem succeeds in every trial on 23% with Qwen and 22% with DeepSeek, compared with 22% and 20% for full context. A history summary preserves much of what happened but leaves the agent to reconstruct the user’s choice on every run, so success varies from trial to trial, whereas a belief record that states the choice and its constraints fixes the decision across runs. The privileged ground-truth profile further shows that correct preferences alone do not secure execution. With Qwen it reaches 0.1193 all-success, below 0.1310 for HabitusMem, likely because a static profile does not carry the exact choices and constraints of a specific transaction.

MemoryQwen3.5-397B-A17B AgentDeepSeek-V4-Flash-0731 Agent
Avg@4Pass@4Pass4^{4}Avg@4Pass@4Pass4^{4}
Base LLM0.08950.20100.01820.08330.19460.0130
Full context0.33820.58880.12970.31190.54090.1102
Ground-truth profile0.33300.58880.11930.38390.63160.1569
RAG0.28570.53910.08640.22510.47050.0562
Rewrite0.31390.61090.07000.31230.58630.0869
Mem00.28440.56940.06360.26430.57070.0480
A-MEM0.29640.54860.09990.31650.58750.0843
MemListener0.22020.41890.06870.24220.42930.0934
HabitusMem0.32910.56160.13100.35730.57980.1284

Table 2. Personalized tool-use results on VitaBench 2.0. Bold and underlined values mark the best and second-best compact memory systems in each column.

Component analysis

Figure 3 and Table 3 report the contribution of each design component on PersonaMem-v2 and VitaBench 2.0, and Appendix § 9.§ 4 gives the complete protocols. Paired PersonaMem-v2 scores list Qwen first and DeepSeek second.

WriterQwen3.5-397B-A17B AgentDeepSeek-V4-Flash-0731 Agent
Avg@4Pass@4Pass4^{4}Avg@4Pass@4Pass4^{4}
Base, static0.25100.46200.08400.27000.50400.0840
Base + request0.34100.53800.16200.28970.53200.0866
Base + unrelated0.19400.37000.06100.21000.42500.0600
Trained, static0.26400.45300.10400.24800.46600.0890
Parent writer0.30120.52140.12450.32430.54990.1310
Direct only0.29440.49290.12840.31360.52270.1349
Plain text0.32520.49290.17250.33240.53440.1362
HabitusMem0.32910.56160.13100.35730.57980.1284

Table 3. Training lineage and matched-control results on VitaBench 2.0.

Figure 3. Component analysis on PersonaMem-v2. (a–b) Inference interventions with a fixed writer and leave-one-out retraining. (c–d) Training lineage, matched controls, and reference conditions. Bars are grouped by agent, the rightmost bar in each group is HabitusMem, and hatched bars are reference conditions. Table 4 and Table 5 list exact values.

Request conditioning. Two inference interventions test whether the writer depends on the request. Both keep the trained adapter, instruction, history selection, and generation settings fixed and change only the request passed to the writer. Without request conditioning removes the request suffix. With an unrelated request keeps the suffix format and replaces its content with one fixed question for every query. Both interventions lower accuracy from 0.537 and 0.484 to about 0.40 and 0.34, and generation from 0.326 and 0.382 to 0.12–0.20. The two interventions have nearly the same effect, which shows that the gain comes from the content of the request and not from the suffix format.

The training lineage tests whether the writer must learn to use the request. Base, static is the unadapted Qwen3.5-9B writer with the belief instruction and no request. Base + request adds the current request to this writer, and Base + unrelated replaces it with the fixed unrelated question. Trained, static is the cold-start writer evaluated without a request. The Parent writer is the direct-writing writer that initializes HabitusMem. Base, static reaches 0.383 and 0.329. The current request raises accuracy to 0.393 and 0.345, and the unrelated question raises it to 0.401 and 0.347, so the content of the request does not improve the accuracy of the unadapted writer. Trained, static reaches 0.406 and 0.335. The request alone and training alone therefore each add at most 2.3 points. The Parent writer, which combines training with the request, reaches 0.505 and 0.457, and HabitusMem reaches 0.537 and 0.484. § 4.1 states that conditioning on the request can only lower the best attainable risk under a fixed budget, and these results show that a writer must learn to attain this benefit.

The request also steers the unadapted writer on VitaBench 2.0. In the archived Qwen runs, Base + request reaches 0.3410 average reward, Base, static reaches 0.2510, and Base + unrelated reaches 0.1940. With DeepSeek, the three conditions reach 0.2897, 0.2700, and 0.2100. An unrelated request lowers average reward below the no-request condition under both agents, likely because it directs the memory budget toward irrelevant content.

Training tasks. Each leave-one-out variant removes all examples of one task from the 40,766-row four-task training file and is retrained from the parent with the same recipe, so the removed task is the only difference. Leave out fields (stage only) keeps all rows and removes the record schema from the instruction and targets of the final stage. Removing direct writing lowers accuracy to 0.387 and 0.348, the level of the untrained writers, although the other three tasks remain. Direct writing is the only task that trains the deployed mapping from a raw history and a request to records, because state update receives no request and the projection tasks start from existing records.

Direct only retrains the parent on the 18,529 direct-writing examples alone for 5,096 steps, which matches the optimization budget of the full mixture. On tool use, the full mixture improves paired average reward over Direct only by 3.3 points with Qwen and 4.5 points with DeepSeek, and it raises Qwen all-success over the Parent writer from 0.1245 to 0.1310. This result is consistent with the content of the training targets. Direct-writing targets place the annotated preference at the top of the memory, and action-projection targets require the exact choices and fulfillment constraints that a transaction needs. The leave-one-out runs were evaluated on answering only, so this result applies to the auxiliary tasks as a group and not to any single task.

Record fields. Plain text repeats the cold-start and four-task stages from the base model with the same rows and settings. It converts the instruction and targets to plain bullets by removing the record header and the evidence, scope, and status fields. On PersonaMem-v2, the full format adds 1.3 and 1.9 accuracy points and 3.3 and 3.9 generation points over Plain text. Appendix § 11.§ 1 reports controlled probes of these fields.

Conclusion

Conclusion

We treated personalized memory as the assistant’s belief about an evolving user state, conveyed as the part relevant to the current decision with the evidence, scope, and status of each claim. With one writer shared across benchmarks and two agent families, HabitusMem is the most accurate evaluated compact memory on PersonaMem-v2 and achieves the highest all-success among non-privileged VitaBench conditions. The component analysis separates the sources of these results: learned request conditioning is central to answering, the auxiliary tasks improve tool use, and structured fields provide an answering gain.

Limitations. HabitusMem has three main limitations. First, its fixed input budget may exclude relevant evidence from long interaction histories. Second, belief extraction and application remain imperfect, particularly for retracted preferences and precise execution constraints. Third, we have not yet evaluated HabitusMem in broader applications, including email composition, personalized recommendations, and scheduling.

Reproducibility Statement

Section 3 describes the writer interface and supervision. Section 4.1 specifies the evaluation protocol, and Section 4.3 reports the component comparisons. Appendix § 9 gives training, evaluation, and statistical details; Appendices § 10 and § 11 contain sensitivity, cost, and probe results. Appendix § 12 gives case studies.

Decision-theoretic interpretation of belief memory

§ 4.1 models the user as an evolving latent state and defines memory by expected loss under the belief, following Bayesian decision theory [2]: the decision variable is a memory message, and its value depends on the actions it induces in a fixed agent. The formulation is a design rationale for what a record should state, and HabitusMem does not carry out the inference numerically. This appendix separates the evidential and decisional roles of the request, relates the formulation to habitus, and shows when conditioning the memory on the request helps.

The request as evidence and as decision

Let bˉt(zt)=∫p(zt∣zt−1)bt−1(zt−1) dzt−1\bar{b}_t(z_t) = \int p(z_t \mid z_{t-1}) b_{t-1}(z_{t-1}) \,\mathrm{d}z_{t-1} denote the belief predicted from the interactions before the request. Setting ot=qto_t = q_t in Equation (1) gives

bt(zt)∝p(qt∣zt)bˉt(zt).(5)b_t(z_t) \propto p(q_t \mid z_t)\bar{b}_t(z_t). \tag*{(5)}

If the request carries no evidence about the user, its likelihood is constant in ztz_t and the belief equals the prediction from earlier interactions. The request still enters the loss ℓτ(a,zt;qt)\ell_\tau(a,z_t;q_t) and can therefore change the ideal memory: a gardening preference can become central to an activity recommendation without becoming more credible because the user asks for an activity. A request that reveals a new circumstance, such as a changed delivery address, changes both the belief and the loss. In the implementation, input selection additionally determines which part of the history the writer sees.

Habitus and the latent state

Bourdieu describes habitus as durable dispositions, produced by past experience, that generate practices in concrete situations [5], and as an open system of dispositions that new experiences either reinforce or modify [6 p. 133]. In our formulation, the interaction history is the record of practices from which the assistant infers the user’s state, the transition p(zt∣zt−1)p(z_t \mid z_{t-1}) allows that state to change, and the scope field records the situations in which a disposition guides behavior. The computational state ztz_t is broader than habitus, since it also includes facts and explicit constraints that are not dispositions. The belief represents the assistant’s uncertainty about the user rather than a model of the user’s own reasoning; habitus motivates the formulation, and the experiments evaluate the memory design that follows from it.

The value of conditioning memory on the request

When memories must fit a message budget, conditioning on the request can only lower the best attainable risk. Fix a common history selection Hˉ=T(H)\bar{H}=T(H), a task type τ\tau, the agent and its guidance, and a budget BB, and let MB⊆M\mathcal{M}_B \subseteq\mathcal{M} contain the memories of at most BB tokens. Write Rτ(m;Hˉ,Q)\mathcal{R}_\tau(m;\bar{H},Q) for the risk in Equation (2) given the selected history Hˉ\bar{H} and the request QQ. Let CB\mathcal{C}_B contain all encoders c:Hˉ↦MBc:\bar{H}\mapsto\mathcal{M}_B, and let WB\mathcal{W}_B contain all encoders w:(Hˉ,Q)↦MBw:(\bar{H},Q)\mapsto\mathcal{M}_B. Assuming the expected risks exist, the best attainable decision risk satisfies

inf⁡w∈WBEHˉ,Q[Rτ(w(Hˉ,Q);Hˉ,Q)]≤inf⁡c∈CBEHˉ,Q[Rτ(c(Hˉ);Hˉ,Q)].(6)\inf_{w\in\mathcal{W}_B}\mathbb{E}_{\bar{H},Q}\left[\mathcal{R}_\tau(w(\bar{H},Q);\bar{H},Q)\right]\leq\inf_{c\in\mathcal{C}_B}\mathbb{E}_{\bar{H},Q}\left[\mathcal{R}_\tau(c(\bar{H});\bar{H},Q)\right]. \tag*{(6)}

Proof. For every c∈CBc\in\mathcal{C}_B, the encoder wc(h,q)=c(h)w_c(h,q)=c(h) belongs to WB\mathcal{W}_B and produces the same memory and risk. Taking the infimum over the larger class gives the inequality. The comparison holds the information, agent, and output budget fixed and concerns the best attainable risk; how closely a trained writer approaches it is an empirical question, which § 5.3 examines.

A one-bit example shows that the inequality can be strict. Suppose the history contains independent uniform bits (U,V)(U, V) and a uniform request asks for one of them. A request-conditioned encoder sends the requested bit and achieves zero error with a one-bit message. A static one-bit encoder, even with an optimal decoder, has minimum average error 1/41/4: the four histories require four answer pairs, but one bit permits only two reconstruction pairs. At least two of the eight equally likely history–request cases are therefore answered incorrectly, and sending UU attains the bound. The example isolates the benefit of allocating a limited message to a known request.

Textual records and the learned approximation

A record (claim, evidence, scope, status) communicates a user-related assertion together with its source, applicability, and current standing. Its evidence field refers to an observation already present in the history and is not an independent observation in Equation (1). Likewise, the token probabilities in Equation (4) model textual continuations, not calibrated probabilities that the claims are true. The records therefore express the belief qualitatively, through the stated evidence and status of each claim, and not as posterior probabilities.

The status field distinguishes changes that a truth probability alone cannot express. A correction changes what the assistant believes happened, a preference update changes what is currently desired, and a request to stop using information restricts its use without necessarily making it false. Explicit records make these distinctions available to the agent, and correct use depends on both the generated memory and the agent. Action-oriented supervision likewise consists of demonstrated textual memories whose effects are evaluated on downstream agent tasks; it does not train on observed user actions.

Implementation and evaluation details

Inference and history selection

HabitusMem uses the same adapter on both benchmarks, with the inference settings of § 4.2. Both evaluations use Hugging Face generation with greedy decoding and a serialized generation lock. The writer regenerates the memory whenever the history–request pair changes, so the memory can change during a VitaBench interaction without recursive updates to a persistent state; state-update and projection examples serve as training supervision only. The VitaBench selector reserves space for the instruction, the request suffix, and 32 additional tokens, and then combines an initial history segment, an elision marker, and the most recent interactions. The PersonaMem selector keeps the first 32,000 characters before the final token cutoff.

Training and evaluation settings

The LoRA adapter has rank 64, alpha 128, and dropout 0.05. The cold-start stage trains for two epochs at learning rate 5×10−55 \times10^{-5} on 1,598 belief memories, which the DeepSeek-V4-Flash teacher writes at two history positions for each of the 799 training personas. The parent stage trains for one epoch on 18,529 direct-writing examples. The four-task stage trains for one epoch with a cosine schedule on 40,766 rows, comprising 18,529 direct-writing, 6,270 state-update, 6,379 request-projection, and 9,588 action-projection rows, the last of which repeat 3,196 examples three times. The parent and four-task stages both use learning rate 2×10−52 \times10^{-5}, a 12,288-token sequence cutoff, and an effective batch of 8. The base checkpoint is a vision-language model, and all inputs in our experiments are text. LoRA targets q_proj, k_proj, v_proj, o_proj, the linear-attention in_proj_* modules, and the feed-forward gate_proj, up_proj, and down_proj. Because the targeting rule matches all linear layers, 32.12M of the 205.23M adapter parameters (15.65%) go to visual projection and feed-forward modules, which text inputs do not use. Embeddings and the output head are not trained.

Each direct-writing example pairs the instruction, the selected history, and the current request with an annotated memory. The record inserted at the top of the static memory, under the ## Beliefs header, has one of three forms:

Active
- {preference} | evidence: user statement | scope: always | status: active

Update
- [update] {preference} | evidence: latest statement | scope: always | status:
active (supersedes the earlier preference on this topic)

Retraction
- The user has asked to forget a preference regarding {topic}; do not use or mention
it | evidence: user instruction | scope: always | status: retracted

Auxiliary targets use 5,000-token history chunks, an 11,400-token input budget, teacher generation caps of 4,800 tokens for states and 1,800 for views, and final state and view budgets of 2,400 and 800 tokens. The data builder merges records using line-level deduplication and ordering heuristics, and the parent writes up to eight request-conditioned and four action-conditioned views per persona. Target generation is retried when no syntactically complete record is produced. All examples come from the official training split, and direct writing uses its preference annotations as target supervision. Action-projection examples take teacher-constructed states as inputs, whereas VitaBench inference takes raw history, so the training prompts for this task differ from the deployment prompt.

The ground-truth profile is a privileged reference and full context exposes the history directly. All VitaBench systems share the same execution guidance and four-trial protocol. PersonaMem-v2 uses the official training and test splits, with all 5,000 official test queries evaluated. Component results are reported in § 5.3.

Table 4 and Table 5 list the exact PersonaMem-v2 scores plotted in Figure 3.

SettingQwen3.5-397B-A17BDeepSeek-V4-Flash-0731
AccuracyGenerationAccuracyGeneration
HabitusMem (default)0.53720.32570.48420.3824
Inference intervention (writer fixed)
Without request conditioning0.40040.13450.33940.1995
With an unrelated request0.40190.12470.33760.1859
Training component removed (retrained)
Leave out direct writing0.38710.14110.34760.2026
Leave out state update0.54440.33330.47340.3900
Leave out request projection0.54290.32830.47750.3899
Leave out action projection0.54250.32810.47860.3799
Leave out fields (stage only)0.53830.32020.47240.3717

Table 4. Request and training ablations on PersonaMem-v2.

WriterQwen3.5-397B-A17BDeepSeek-V4-Flash-0731
AccuracyGenerationAccuracyGeneration
Training lineage
Base, static0.3830.1120.3290.181
Base + request0.3930.1460.3450.211
Base + unrelated0.4010.1330.3470.189
Trained, static0.4060.1350.3350.200
Parent writer0.5050.3100.4570.364
Matched controls
Direct only0.5530.3450.4870.401
Plain text0.5240.2930.4650.343
HabitusMem0.5370.3260.4840.382
Reference conditions
Base LLM0.4460.2560.2630.291
Full context0.5690.2270.5220.302

Table 5. Training lineage and matched answering controls on PersonaMem-v2.

Component-analysis protocols

All component conditions are evaluated on the full 5,000-query PersonaMem-v2 benchmark with the same agents and judge. The training-lineage conditions and matched controls are also evaluated on VitaBench 2.0 with the same agents. The inference interventions, lineage conditions, and matched controls otherwise use the final inference interface; only the factor named in each condition changes.

Inference interventions. Both interventions keep the trained adapter, instruction, selected history, and generation settings fixed and change only the request passed to the writer. Without request conditioning removes the request suffix, so the writer sees the instruction and history alone. With an unrelated request retains the suffix format used in training but replaces its content with the fixed question “Recommend a good book on European history for a beginner” for every query. Memories are regenerated under each condition, and the same queries are re-answered by the same agent and judge, so the comparison is paired at the query level.

Leave-one-out training components. The final training file contains 18,529 direct-writing, 6,270 state-update, 6,379 request-projection, and 3,196 action-projection examples; action-projection examples are repeated three times, giving 40,766 rows and weights (1, 1, 1, 3). Each leave-one-out variant is a filtered copy of this file that removes all rows of one task and keeps the other three, with the same repetition counts. Every variant is retrained from the parent writer with the same LoRA rank, alpha, dropout, learning rate, schedule, cutoff, and one-epoch budget as the default, so the dropped task is the only difference. The variants contain 22,237 rows without direct writing, 34,496 without state update, 34,387 without request projection, and 31,178 without action projection. Leave out fields (stage only) keeps all 40,766 rows but replaces the instruction with a schema-free instruction and strips the evidence, scope, and status suffixes from the targets; it starts from the same schema-trained parent, so only the final stage is trained on plain records.

Training lineage. Base, static is the unadapted Qwen3.5-9B writer with the belief instruction and no request suffix. Base + request adds the current request to the same unadapted writer, and Base + unrelated keeps the suffix but replaces its content with the fixed unrelated question. Trained, static is the cold-start writer, trained for two epochs on 1,598 teacher-written belief memories, evaluated without request conditioning. The Parent writer is the direct-writing writer trained for one epoch on the 18,529 request-conditioned examples of the official training split; it initializes the final writer and is the teacher that generates the state-update and projection targets. All five conditions use the final inference interface and the same test set.

Matched controls. The direct-only control is retrained from the same parent with the same recipe on the 18,529 direct-writing examples alone. It runs for 2.2 epochs, matching the 5,096 steps of the 40,766-row full mixture, so the comparison holds the optimization budget fixed while removing the auxiliary tasks. The plain-text control starts from the base model and repeats the cold-start and four-task stages with the same examples, queries, annotated preferences, selector, output cap, and optimization settings: it trains a plain-text cold-start writer for two epochs on the 1,598 cold-start memories at learning rate 5×10−55 \times10^{-5} and then a four-task writer for one epoch on the 40,766-row mixture at 2×10−52 \times10^{-5}. The instruction and targets are converted mechanically: the ## Beliefs header and the evidence, scope, and status fields are removed without paraphrasing, and the instruction asks for plain bullets. The targets are text transforms of the final training file, and no teacher is rerun.

Paired PersonaMem-v2 accuracy comparisons use query-level correctness and McNemar tests. VitaBench average reward uses paired bootstrap over task clusters, while any-success and all-success use McNemar tests over common completed subtasks. Because these tests use common subtasks, the full-run aggregates can differ from the means on paired subsets. Each writer is trained once, so these tests do not capture variation across training seeds. Qwen training-lineage results use archived full runs of the same Qwen3.5-397B-A17B agent.

For the direct-only comparison, the full mixture improves paired average reward by 3.3 points with Qwen and 4.5 with DeepSeek. It also improves Qwen all-success from 0.1284 to 0.1310 and DeepSeek any-success from 0.5227 to 0.5798. For the parent comparison, the Qwen all-success gain is concentrated in the 668 personalization subtasks. Its paired average-reward gain is 2.6 points. The DeepSeek parent comparison has a paired reward gain of 2.8 points with an interval of [+0.6, +4.9] points. For the plain-text comparison, DeepSeek’s paired reward difference is 1.8 points, and any-success and all-success differ by 3.6 and 0.9 points, none of which is statistically significant.

Parameter sensitivity and computational cost

Training-mixture sensitivity

We did not run an extensive hyperparameter search because the purpose of this comparison is to test sensitivity to the weights rather than to optimize them. We therefore compare three common training mixtures. We train three writers from the same parent with the identical recipe (one epoch, learning rate 2×10−52 \times10^{-5}, LoRA rank 64, α=128\alpha= 128), changing only the repetition counts in the training file. The selected (1,1,1,3) mixture repeats each action-projection example three times, the uniform (1,1,1,1) mixture repeats every example once, and the direct-doubled (2,1,1,3) mixture repeats direct-writing examples twice while keeping action projection at three. Figure 4 compares the three mixtures.

Figure 4. Sensitivity to training-mixture weights on the full VitaBench 2.0 benchmark. Weights follow direct writing, state update, request projection, and action projection. Scores are percentages.

On the full DeepSeek benchmark, selected reaches 0.3619 average reward and 0.1505 all-success, against 0.3469 and 0.1284 for uniform and 0.3450 and 0.1479 for direct-doubled. Their any-success values are 0.5823, 0.5811, and 0.5759. With Qwen, average reward is indistinguishable (0.3379, 0.3233, 0.3405), but selected has higher any-success (0.5642 against 0.4410 and 0.4488) and lower all-success (0.1336 against 0.2153 and 0.2438). Uniform and direct-doubled do not differ significantly on any metric. The selected and uniform writers both reach 0.4842 PersonaMem accuracy. Thus, weight selection does not yield a uniform advantage across agents and metrics.

Inference sensitivity

The trained writer is fixed, and all PersonaMem-v2 queries are answered under each setting with both agents. We vary one setting at a time: input caps of 2,500, 5,000, 8,500 (default), and 11,400 tokens; output caps of 200, 800 (default), and 1,200 tokens; a head-and-tail selector that reserves 15% of the input token budget for the beginning of the history and the rest for the most recent interactions; and Prompt B, an alternative instruction that keeps the record schema but prioritizes concrete preferences, facts, and constraints and limits biographical background to two lines. Figure 5 reports the results. Reducing the input cap to 2,500 or 5,000 tokens costs 13.7–16.7 accuracy points and 12.8–16.3 generation points across the two agents. Raising it to 11,400 changes accuracy by at most 0.4 points and generation by at most 0.7. Head-and-tail selection incurs the largest accuracy loss among the other choices (3.06 points with Qwen), with little generation change. A 200-token output cap slightly reduces accuracy but improves generation under both agents; expanding to 1,200 tokens yields little benefit. Prompt B similarly trades a small accuracy decrease for a generation increase. These effects are much smaller than those of removing relevant history or request conditioning.

Figure 5. Inference sensitivity on PersonaMem-v2. (a–b) Personalized QA accuracy and (c–d) generation score. Each cluster varies one setting while the others stay at their defaults, and darker bars mark the default configuration.

Computational cost

The four-task training stage takes 76.3 GPU-hours. In the PersonaMem-v2 32k setting, the writer reads a median of 7,125 tokens and generates 443 tokens per request. Evaluating 5,000 distinct requests takes roughly 24 writer-hours on one GPU. The memory presented to the agent has a median length of 515 tokens, compared with 31,855 tokens for full history, a 61.9-fold reduction in history input. An unchanged history–request pair can reuse its cached memory; a new history or request requires another writer pass.

Memory quality and agent behavior

Belief memory exposes not only a claim, but also its evidence, applicability, and current status. We design diagnostics around these distinctions to examine two separate steps: whether the writer preserves the relevant fact and whether a frozen agent uses it in a decision. A constructed paired probe suite tests these steps under controlled history changes.

Constructed probes of evidence, scope, and status

We construct 90 probes per writer across ten topics and nine cells: a self-purchase and gift pair for attribution, unconditional and conditional preferences crossed with partner and solo questions for scope, and active, retracted, and superseded preferences for status. Each topic therefore contributes two attribution, four scope, and three status probes. Within each history pair or triple, the question and four choices stay fixed while one history element changes. The full writer is evaluated with both agents; the matched plain-text writer is evaluated with Qwen. The suite is constructed rather than sampled from either benchmark because this design requires controlled alternatives for the same decision. The writer, agents, and inference configurations otherwise match the benchmark evaluations. The writer sees the history and question; the answering agent sees the generated memory and question without the raw history. A separate call to the agent model checks whether the memory states the manipulated fact, and we cross-check those judgments by inspecting the records. This design makes the fields operational: it tests whether a change in evidence, scope, or status survives the memory bottleneck and changes the downstream answer.

A concrete attribution pair. The two histories of the jasmine-tea pair differ only in their third turn. The question and the four choices are the same in both conditions.

Shared history The opening user statement “I’ve really gotten into jasmine tea lately,” the assistant’s acknowledgment, and a final unrelated turn about documentaries.

Third turn

Self: “I picked up jasmine tea again yesterday and loved it.”

Gift: “I picked up jasmine tea yesterday—it’s a birthday gift for my sister, she loves it.”

Question

“I want to pick something up for myself this weekend—what would you suggest I go for?”

Choices

A. Since you’re into jasmine tea, go for that again.

B. Try something completely new that you haven’t mentioned before.

C. Pick whatever is on sale, brands don’t matter.

D. Ask a friend what they would choose for you.

Answer key

A for the self condition and B for the gift condition.

The attribution axis contains ten such pairs, one per topic, so each of these two cells contains ten probes.

Table 6: All controlled probe results. Entries are correct agent answers out of ten. The gift cell also includes an earlier self-statement of interest; it does not isolate writer attribution. Manual inspection finds the gift relationship in all ten memories from both writers.

FactorConditionFull, QwenFull, DeepSeekPlain, Qwen
AttributionSelf10/1010/1010/10
AttributionGift / prior interest0/101/100/10
ScopeUnconditional, partner10/1010/1010/10
ScopeUnconditional, solo10/1010/1010/10
ScopeConditional, partner10/1010/1010/10
ScopeConditional, solo10/102/107/10
StatusActive10/1010/1010/10
StatusRetracted1/102/100/10
StatusSuperseded9/109/108/10

Table 6. All controlled probe results.

What the fields preserve and what the agent applies. Table 6 separates record quality from downstream answers and shows that explicit fields preserve distinctions that plain records lose. The full writer records the conditional scope and the retraction in all ten corresponding memories and the supersession in nine to ten, whereas the matched plain-text writer marks no retractions. With Qwen, full records match or exceed plain records in every cell. They yield ten of ten correct conditional-solo answers against seven with plain records, nine of ten superseded answers against eight, and one of ten retracted answers against zero. The scope result illustrates the purpose of an explicit scope field, since a preference can remain valid without applying to the current situation. Explicit records also make the remaining errors diagnosable. DeepSeek answers all other scope questions correctly but only two of ten conditional-solo questions, and the two agents answer one and two of ten retraction probes correctly although the full writer marks the revocation. These results show that correct use also depends on the agent, and that an explicit status makes a constraint available without guaranteeing that a frozen agent obeys it.

Interpreting the gift cell. Manual inspection confirms that all ten gift memories from both writers state “a birthday gift for the user’s sister.” The checker criterion expects the gift attribution and rejects memories that present the item as the user’s interest; this expectation is stricter than the history, which already contains the user’s earlier self-statement. A faithful memory can therefore contain both facts. The same memories receive one of ten correct judgments from the Qwen checker and nine of ten from the DeepSeek checker. The answer key is similarly strict, marking the item-based answer wrong in the gift condition despite the earlier interest. The resulting zero of ten correct answers with Qwen and one of ten with DeepSeek diagnose how the consumer weighs gift framing against existing interest. They do not estimate pure attribution accuracy or establish that the writer misrecords the gift. We treat the automatic checks as model-dependent diagnostics cross-checked by manual inspection.

Case studies

We select two cases, one from each benchmark, to analyze and illustrate clearly how HabitusMem works. Memory excerpts are verbatim and state how many generated records they show, and Chinese records and dialogues are translated. Together, the cases show why writing memory as beliefs helps an agent act on the user’s current preferences. In Case 1, the options differ only in whether they invoke a withdrawn preference, so a correct answer requires knowing both what was withdrawn and that it was withdrawn. The retracted record supplies both. It names the preference, which lets the agent recognize three different paraphrases of it, and its status tells the agent not to use it, while leaving the agent free to answer the question about architecture. A memory that deleted the preference could not identify these paraphrases, and a memory that kept it without a status could support the wrong options. In Case 2, the request supplies none of the arguments that the purchase needs. The guidance gτg_{\tau} names the constraints to extract and asks the agent to finish the transaction, but it contains no user-specific values. The records supply them, each stating one exact brand, flavor, size, or address that maps onto a tool argument, so the agent can fill the calls without asking again. The alternative record also lets the agent recover from missing stock with a choice from the user’s own history. In both cases, the records state what holds about the user, where it applies, and whether it still holds, so the agent acts on explicit beliefs rather than reconstructing preferences from raw content. Stated values can also keep an action repeatable across trials.

Case 1: Recommending buildings after a retraction

Figure 6. A PersonaMem-v2 example in which the agent answers a recommendation question after the user has retracted a preference.

Case 1: Recommending buildings after a retraction PersonaMem-v2

History The user asked for notable buildings, and the assistant replied “Since you love modernist architecture.” The user then said: “Please forget that I love modernist architecture more than colonial styles.” The benchmark marks the query below as ask_to_forget.

Question “I’m planning a major renovation of my house and want to gather inspiration—could you recommend some exemplary buildings, public spaces, or design showcases that feature striking, contemporary architectural styles I could study for ideas?”

Options A. If you’re looking for architectural inspiration, you might explore Frank Lloyd Wright’s Prairie School designs for their harmony with nature, or Antoni Gaudí’s whimsical, organic forms in Barcelona. Both offer distinctive approaches that can spark fresh ideas for a renovation. [key]

B. Given your preference for modernist architecture over colonial styles, you could study the glass-and-steel precision of Mies van der Rohe’s Farnsworth House or the sweeping, organic forms of Oscar Niemeyer’s Brasília buildings.

C. If you’re drawn to modernist rather than colonial influences, you might explore Ricardo Legorreta’s vibrant geometric structures in Mexico City, or visit the Salk Institute in La Jolla for Louis Kahn’s masterful interplay of form, light, and open space.

D. Since you appreciate modernist design more than colonial aesthetics, consider touring Tadao Ando’s work—like the Modern Art Museum of Fort Worth—or revisiting Le Corbusier’s Villa Savoye for its bold functionalism.

Memory 2 of 13 records

  • The user has asked to forget a preference regarding Architecture; do not use or mention it | evidence: user instruction | scope: always | status: retracted

  • The user previously expressed a preference for modernist architecture over colonial styles, but has requested this preference be forgotten. | evidence: msg 9, msg 11 | scope: situational (architecture) | status: retracted

Agent It identifies the second record as relevant and checks each option against it. It rejects B, C, and D because each restates the retracted preference, and it accepts A because A “provides architectural recommendations without referencing the user’s retracted preference.”

Result The agent outputs “Final Answer: A”, which matches the benchmark key.

Case 2: Buying dog food

History The user wrote of her dog: “ZIWI’s food has a good nutritional profile and Bao loves it; it is expensive, but I will keep buying it until he stops liking it.” Her stored favorites contain “ZIWI chicken-flavored dog food, 1 kg.”

Request “I completely forgot to buy dog food for Bao—ordering from Taobao is too late; just buy it for me and deliver it home.” The request names no brand, flavor, size, or address.

Guidance Every memory system in the comparison receives the same execution guidance gτg_{\tau}:

The memory above is evidence, not a response to repeat. For the current request:

  1. Extract every known relevant constraint before choosing: exact product/category, brand, variant or specification, quantity, address, time, distance/rating, and updates/retractions.

  2. Prefer an explicit historical choice over a generic or health-inferred substitute.

  3. If the user says "whatever" or delegates the choice, choose the single best matching option and continue the required tool workflow; do not stop at a list of recommendations or ask for information already present in memory/profile.

  4. Complete the transaction when the request asks to buy/book/order.

Memory 5 of 20 records

  • Dog food brand: ZIWI | evidence: [msg 291], [msg 296], [msg 299] | scope: always | status: active

  • Flavor, current: chicken (currently feeding) | evidence: [msg 296], [msg 299] | scope: situational (current stock) | status: active

  • Flavor, alternative: beef (already added to cart, pending switch) | evidence: [msg 299] | scope: situational (future stock) | status: active

  • Format: 1 kg | evidence: [msg 291], [msg 296], [msg 299] | scope: always | status: active

  • Delivery address: 143 Shanlin West Road, Building 8, Unit 1, Room 704 | evidence: [msg 285], [msg 288], [msg 289] | scope: always | status: active

Agent The search finds only ZIWI beef in 1 kg in stock, and the user replies “Whatever, you decide; deliver it whenever.” The tool calls draw their arguments as follows:

Tool callArgumentsSource
delivery_product_search_recommandZIWI, dog food, chicken flavor, 1 kgBrand, current flavor, and format records
get_delivery_store_infoThe pet-food storeSearch result
create_delivery_orderOne bag of 1 kg ZIWI beef, full addressAlternative flavor and address records
pay_delivery_orderThe created ordergτg_{\tau} and user confirmation

Table 7.

Result The rubric checks the brand and the delivery address, and the subtask succeeds in all four trials, each paying for the same product at the same address.

A VitaBench 2.0 example in which the agent completes a paid delivery order from an underspecified request

Figure 7. A VitaBench 2.0 example in which the agent completes a paid delivery order from an underspecified request.

References

  1. [1]André Barreto, Vincent Dumoulin, Yiran Mao, Mark Rowland, Nicolas Perez-Nieves, Bobak Shahriari, Yann Dauphin, Doina Precup, and Hugo Larochelle. Capturing individual human preferences with reward features. Advances in Neural Information Processing Systems, 38:82119–82154, 2026.arxiv.org/abs/2503.17338
  2. [2]James O Berger. Statistical decision theory. In The New Palgrave Dictionary of Economics, pages 1–6. Springer, 1987.
  3. [3]Avinandan Bose, Zhihan Xiong, Yuejie Chi, Simon Shaolei Du, Lin Xiao, and Maryam Fazel. Lore: Personalizing llms via low-rank reward modeling. arXiv preprint arXiv:2504.14439, 2025.arxiv.org/abs/2504.14439
  4. [4]Avinandan Bose, Shuyue Stella Li, Faeze Brahman, Pang Wei Koh, Simon Shaolei Du, Yulia Tsvetkov, Maryam Fazel, Lin Xiao, and Asli Celikyilmaz. Cold-start personalization via training-free priors from structured world models, 2026. URL https://arxiv.org/abs/2602.15012.
  5. [5]Pierre Bourdieu. Outline of a theory of practice. In The new social theory reader, pages 80–86. Routledge, 2020.
  6. [6]Pierre Bourdieu and Loïc JD Wacquant. An invitation to reflexive sociology. University of Chicago press, 1992.
  7. [7]Yuxin Chen, Yi Zhang, Zhengzhou Cai, Yaorui Shi, Zhiyuan Yao, Chenhang Cui, Jingnan Zheng, Yaqi Huo, Xi Su, Qi Gu, et al. Vitabench 2.0: Evaluating personalized and proactive agents in long-term user interactions. arXiv preprint arXiv:2605.27141, 2026.arxiv.org/abs/2605.27141
  8. [8]Zihao Cheng, Hongru Wang, Zeming Liu, Yuhang Guo, Yuanfang Guo, Yunhong Wang, and Haifeng Wang. ToolSpectrum: Towards personalized tool utilization for large language models. In Findings of the Association for Computational Linguistics: ACL 2025, pages 20679–20699, 2025.arxiv.org/abs/2505.13176
  9. [9]Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. Mem0: Building production-ready ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413, 2025.arxiv.org/abs/2504.19413
  10. [10]Zafeirios Fountas, Martin A Benfegoul, Adnan Oomerjee, Fenia Christopoulou, Gerasimos Lampouras, Haitham Bou Ammar, and Jun Wang. Human-inspired episodic memory for infinite context llms. In International Conference on Learning Representations, volume 2025, pages 77230–77268, 2025.arxiv.org/abs/2407.09450
  11. [11]Yupu Hao, Pengfei Cao, Zhuoran Jin, Huanxuan Liao, Yubo Chen, Kang Liu, and Jun Zhao. Evaluating personalized tool-augmented llms from the perspectives of personalization and proactivity. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 21897–21935, 2025.arxiv.org/abs/2503.00771
  12. [12]Wei-Chieh Huang, Weizhi Zhang, Yueqing Liang, Yuanchen Bei, Yankai Chen, Tao Feng, Zhen Tan, Yu Wang, Tianxin Wei, Shanglin Wu, et al. A survey of agent memory in the second half: Towards self-evolving and long-horizon agents. Transactions on Machine Learning Research, 2026.arxiv.org/abs/2602.06052
  13. [13]Bowen Jiang, Zhuoqun Hao, Young-Min Cho, Bryan Li, Yuan Yuan, Sihao Chen, Lyle Ungar, Camillo J Taylor, and Dan Roth. Know me, respond to me: Benchmarking llms for dynamic user profiling and personalized responses at scale. arXiv preprint arXiv:2504.14225, 2025a.arxiv.org/abs/2504.14225
  14. [14]Bowen Jiang, Yuan Yuan, Maohao Shen, Zhuoqun Hao, Zhangchen Xu, Zichen Chen, Ziyi Liu, Anvesh Rao Vijjini, Jiashu He, Hanchao Yu, et al. Personamem-v2: Towards personalized intelligence via learning implicit user personas and agentic memory. arXiv preprint arXiv:2512.06688, 2025b.arxiv.org/abs/2512.06688
  15. [15]Huiqiang Jiang, Qianhui Wu, Xufang Luo, Dongsheng Li, Chin-Yew Lin, Yuqing Yang, and Lili Qiu. Longllm-lingua: Accelerating and enhancing llms in long context scenarios via prompt compression. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1658–1677, 2024.
  16. [16]Hannah Kim, Kushan Mitra, Chen Shen, Dan Zhang, and Estevam Hruschka. Aipom: Agent-aware interactive planning for multi-agent systems. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pages 85–96, 2025.arxiv.org/abs/2509.24826
  17. [17]Mehmet Kurmaz. Aware-us: Preference-aware infeasibility resolution in tool-calling agents. arXiv preprint arXiv:2601.02643, 2026.arxiv.org/abs/2601.02643
  18. [18]Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in neural information processing systems, 33:9459–9474, 2020.arxiv.org/abs/2005.11401
  19. [19]Hao Li, Chenghao Yang, An Zhang, Yang Deng, Xiang Wang, and Tat-Seng Chua. Hello again! llm-powered personalized agent for long-term dialogue. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 5259–5276, 2025a.
  20. [20]Jia-Nan Li, Jian Guan, Wei Wu, and Rui Yan. Extended inductive reasoning for personalized preference inference from behavioral signals. arXiv preprint arXiv:2505.18071, 2025b.arxiv.org/abs/2505.18071
  21. [22]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.
  22. [23]Siru Ouyang, Jun Yan, I Hsu, Yanfei Chen, Ke Jiang, Zifeng Wang, Ruijun Han, Long Le, Samira Daruki, Xiangru Tang, et al. Reasoningbank: Scaling agent self-evolving with reasoning memory. In International Conference on Learning Representations, volume 2026, pages 94327–94354, 2026.arxiv.org/abs/2509.25140
  23. [24]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
  24. [25]Preston Rasmussen, Pavlo Paliychuk, Travis Beauvais, Jack Ryan, and Daniel Chalef. Zep: a temporal knowledge graph architecture for agent memory. arXiv preprint arXiv:2501.13956, 2025.arxiv.org/abs/2501.13956
  25. [26]Alireza Salemi, Sheshera Mysore, Michael Bendersky, and Hamed Zamani. Lamp: When large language models meet personalization. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 7370–7392, 2024.
  26. [28]Yunxiao Shi, Wujiang Xu, Zhang Zeqi, Xing Zi, Qiang Wu, and Min Xu. Personax: A recommendation agent-oriented user modeling framework for long behavior sequence. In Findings of the Association for Computational Linguistics: ACL 2025, pages 5764–5787, 2025.arxiv.org/abs/2503.02398
  27. [29]Anikait Singh, Sheryl Hsu, Kyle Hsu, Eric Mitchell, Stefano Ermon, Tatsunori Hashimoto, Archit Sharma, and Chelsea Finn. Fspo: Few-shot optimization of synthetic preferences effectively personalizes to real users. In International Conference on Learning Representations, volume 2026, pages 109496–109524, 2026.arxiv.org/abs/2502.19312
  28. [30]Manan Suri, Puneet Mathur, Nedim Lipka, Franck Dernoncourt, Ryan A Rossi, and Dinesh Manocha. Structured uncertainty guided clarification for llm agents. In Findings of the Association for Computational Linguistics: ACL 2026, pages 40811–40838, 2026.
  29. [31]Yanming Wan, Jiaxing Wu, Marwa Abdulhai, Lior Shani, and Natasha Jaques. Enhancing personalized multi-turn dialogue with curiosity reward. Advances in Neural Information Processing Systems, 38:155857–155894, 2026.arxiv.org/abs/2504.03206
  30. [32]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16291, 2023.arxiv.org/abs/2305.16291
  31. [34]Yu Wang, Yifan Gao, Xiusi Chen, Haoming Jiang, Shiyang Li, Jingfeng Yang, Qingyu Yin, Zheng Li, Xian Li, Bing Yin, et al. Memoryllm: Towards self-updatable large language models. arXiv preprint arXiv:2402.04624, 2024b.arxiv.org/abs/2402.04624
  32. [35]Yu Wang, Ryuichi Takanobu, Zhiqi Liang, Yuzhen Mao, Yuanzhe Hu, Julian McAuley, and Xiaojian Wu. Mem-α: Learning memory construction via reinforcement learning. arXiv preprint arXiv:2509.25911, 2025.arxiv.org/abs/2509.25911
  33. [36]Zora Zhiruo Wang, Jiayuan Mao, Daniel Fried, and Graham Neubig. Agent workflow memory. arXiv preprint arXiv:2409.07429, 2024c.arxiv.org/abs/2409.07429
  34. [37]Rebecca Westhäuser, Wolfgang Minker, and Sebastian Zepf. Enabling personalized long-term interactions in LLM-based agents through persistent memory and user profiles, 2025. URL https://arxiv.org/abs/2510.07925.
  35. [39]Fangyuan Xu, Weijia Shi, and Eunsol Choi. Recomp: Improving retrieval-augmented lms with context compression and selective augmentation. In International Conference on Learning Representations, volume 2024, pages 43478–43502, 2024.arxiv.org/abs/2310.04408
  36. [40]Manjie Xu, Xinyi Yang, Wei Liang, Chi Zhang, and Yixin Zhu. Inferring the Unspoken: Aligning Embodied Agents with Implicit Preferences, 2025a. URL https://arxiv.org/abs/2502.00858.
  37. [41]Qiancheng Xu, Yongqi Li, Heming Xia, Fan Liu, Min Yang, and Wenjie Li. Petoolllm: Towards personalized tool learning in large language models. In Findings of the Association for Computational Linguistics: ACL 2025, pages 21488–21503, 2025b.arxiv.org/abs/2502.18980
  38. [42]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
  39. [43]Yue Xu, Qian Chen, Zizhan Ma, Dongrui Liu, Wenxuan Wang, Xiting Wang, Li Xiong, and Wenjie Wang. Toward personalized llm-powered agents: Foundations, evaluation, and future directions. arXiv preprint arXiv:2602.22680, 2026b.arxiv.org/abs/2602.22680
  40. [44]Sikuan Yan, Xiufeng Yang, Zuchao Huang, Ercong Nie, Zifeng Ding, Zonggen Li, Xiaowen Ma, Jinhe Bi, Kristian Kersting, Jeff Z Pan, et al. Memory-r1: Enhancing large language model agents to manage and utilize memories via reinforcement learning. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 12805–12825, 2026.
  41. [45]Hongli Yu, Tinghong Chen, Jiangtao Feng, Jiangjie Chen, Weinan Dai, Qiying Yu, Ya-Qin Zhang, Wei-Ying Ma, Jingjing Liu, Mingxuan Wang, et al. Memagent: Reshaping long-context llm with multi-conv rl-based memory agent. In International Conference on Learning Representations, volume 2026, pages 39458–39486, 2026.arxiv.org/abs/2507.02259
  42. [46]Weizhi Zhang, Xinyang Zhang, Chenwei Zhang, Liangwei Yang, Jingbo Shang, Zhepei Wei, Henry Peng Zou, Zijie Huang, Zhengyang Wang, Yifan Gao, et al. Personaagent: Bridging memory and action for personalized llm agents. In Findings of the Association for Computational Linguistics: ACL 2026, pages 26421–26439, 2026.arxiv.org/abs/2506.06254
  43. [47]Xinliang Frederick Zhang, Nick Beauchamp, and Lu Wang. Prime: Large language model personalization with cognitive dual-memory and personalized thought process. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 33695–33724, 2025.arxiv.org/abs/2507.04607
  44. [48]Xuan Zhang, Yang Deng, Zifeng Ren, See Kiong Ng, and Tat-Seng Chua. Ask-before-plan: Proactive language agents for real-world planning. In Findings of the association for computational linguistics: EMNLP 2024, pages 10836–10863, 2024.arxiv.org/abs/2406.12639
  45. [49]Jihao Zhao, Ding Chen, Zhaoxin Fan, Kerun Xu, Mengting Hu, Bo Tang, Feiyu Xiong, and Zhiyu Li. Inside out: Evolving user-centric core memory trees for long-term personalized dialogue systems. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13429–13446, 2026a.
  46. [50]Weixiang Zhao, Xingyu Sui, Yulin Hu, Jiahe Guo, Haixiao Liu, Biye Li, Yanyan Zhao, Bing Qin, and Ting Liu. Teaching language models to evolve with users: Dynamic profile modeling for personalized alignment. Advances in Neural Information Processing Systems, 38:33162–33199, 2026b.arxiv.org/abs/2505.15456
  47. [51]Wanjun Zhong, Lianghong Guo, Qiqi Gao, He Ye, and Yanlin Wang. Memorybank: Enhancing large language models with long-term memory. In Proceedings of the AAAI conference on artificial intelligence, volume 38, pages 19724–19731, 2024.arxiv.org/abs/2305.10250
  48. [52]Jinchang Zhu, Jindong Li, Cheng Zhang, Jiahong Liu, and Menglin Yang. Hela-mem: Hebbian learning and associative memory for llm agents. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13757–13769, 2026.

Paper details

vlnc:W_3mvmu6yy
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