Paper deep dive
User Preference Modeling for Conversational LLM Agents: Weak Rewards from Retrieval-Augmented Interaction
Yuren Hao, Shuhaib Mehri, ChengXiang Zhai, Dilek Hakkani-Tür
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 94%
Last extracted: 3/26/2026, 2:21:22 AM
Summary
The paper introduces Vector-Adapted Retrieval Scoring (VARS), a framework for conversational LLM agents that enables persistent user modeling through dual-vector representations (long-term and short-term). These vectors are updated online using weak scalar rewards derived from user feedback, allowing for personalized retrieval over structured preference memory without requiring per-user fine-tuning of the underlying LLM backbones.
Entities (4)
Relation Signals (2)
VARS → evaluatedon → MultiSessionCollab
confidence 95% · We evaluate this framework on MultiSessionCollab, an online multi-session benchmark
VARS → usesalgorithm → REINFORCE
confidence 90% · a REINFORCE-style update then adjusts zU(L) and zU,t(S)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large language models are increasingly used as personal assistants, yet most lack a persistent user model, forcing users to repeatedly restate preferences across sessions. We propose Vector-Adapted Retrieval Scoring (VARS), a pipeline-agnostic, frozen-backbone framework that represents each user with long-term and short-term vectors in a shared preference space and uses these vectors to bias retrieval scoring over structured preference memory. The vectors are updated online from weak scalar rewards from users' feedback, enabling personalization without per-user fine-tuning. We evaluate on \textsc{MultiSessionCollab}, an online multi-session collaboration benchmark with rich user preference profiles, across math and code tasks. Under frozen backbones, the main benefit of user-aware retrieval is improved interaction efficiency rather than large gains in raw task accuracy: our full VARS agent achieves the strongest overall performance, matches a strong Reflection baseline in task success, and reduces timeout rate and user effort. The learned long-term vectors also align with cross-user preference overlap, while short-term vectors capture session-specific adaptation, supporting the interpretability of the dual-vector design. Code, model, and data are available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2603.20939v1
- Canonical: https://arxiv.org/abs/2603.20939v1
Trouble viewing inline? Open PDF directly →
Full Text
85,586 characters extracted from source content.
Expand or collapse full text
User Preference Modeling for Conversational LLM Agents: Weak Rewards from Retrieval-Augmented Interaction Yuren Hao, Shuhaib Mehri, ChengXiang Zhai, Dilek Hakkani-Tür University of Illinois at Urbana-Champaign yurenh2, mehri2, czhai, dilek@illinois.edu Abstract Large language models are increasingly used as personal assistants, yet most lack a persistent user model, forcing users to repeatedly restate preferences across sessions. We propose Vector-Adapted Retrieval Scoring (VARS), a pipeline-agnostic, frozen-backbone framework that represents each user with long-term and short-term vectors in a shared preference space and uses these vectors to bias retrieval scoring over structured preference memory. The vectors are updated online from weak scalar rewards from users’ feedback, enabling personalization without per-user fine-tuning. We evaluate on MultiSessionCollab, an online multi-session collaboration benchmark with rich user preference profiles, across math and code tasks. Under frozen backbones, the main benefit of user-aware retrieval is improved interaction efficiency rather than large gains in raw task accuracy: our full VARS agent achieves the strongest overall performance, matches a strong Reflection baseline in task success, and reduces timeout rate and user effort. The learned long-term vectors also align with cross-user preference overlap, while short-term vectors capture session-specific adaptation, supporting the interpretability of the dual-vector design. Code, model, and data are available at https://github.com/YurenHao0426/VARS. User Preference Modeling for Conversational LLM Agents: Weak Rewards from Retrieval-Augmented Interaction Yuren Hao, Shuhaib Mehri, ChengXiang Zhai, Dilek Hakkani-Tür University of Illinois at Urbana-Champaign yurenh2, mehri2, czhai, dilek@illinois.edu 1 Introduction LLMs are increasingly used as personal assistants for writing, analysis, and programming (Chatterji et al., 2025). During these interactions, users exhibit distinct preferences for how they communicate, receive feedback, and structure workflows (Jiang et al., 2025a, b), yet most systems lack mechanisms to remember and adapt to these preferences across sessions, forcing users to repeatedly restate them and reducing the efficiency of long-term collaboration (Wu et al., 2024; Li et al., 2025; Mehri et al., 2026). A growing body of work has explored retaining information across sessions for conversational agents. Most systems store past exchanges in a database and retrieve relevant entries at query time, or produce post-session reflections that are reinserted into future conversations (Zhong et al., 2024; Packer et al., 2023; Tan et al., 2025; Chhikara et al., 2025). Several recent works have also explored using memory to directly improve personalization across sessions (Mehri et al., 2026; He et al., 2026; Li et al., 2025). The retrieval in these systems typically relies on query similarity alone, without a persistent user state to prioritize which preferences are most relevant to the current context (Salemi et al., 2024; Yang et al., 2026). A central gap remains: existing systems recall past interactions but do not maintain a user representation that improves retrieval of relevant preferences through ongoing interaction. We address this gap with Vector-Adapted Retrieval Scoring (VARS), a framework that learns a compact dual-vector user state from weak scalar rewards from users’ feedback and uses it to bias retrieval over structured preference memory. The framework comprises four learned components—a lightweight preference extraction model that converts dialogue into structured memory cards, a preference memory that indexes these cards for retrieval, a dual-vector user state that separates stable cross-session preferences from transient within-session context, and a reward-driven update mechanism that refines the user vectors from weak scalar feedback—layered on top of three frozen backbones (chat LLM, embedding model, reranker). At inference time, the effective user vector biases retrieval scoring so that the most relevant preferences are surfaced for each query. Because adaptation occurs only through compact user-specific vectors, the framework supports continuous personalization without per-user fine-tuning—a form of user-centric memory that organizes stored preferences around the user rather than the task. We evaluate this framework on MultiSessionCollab, an online multi-session benchmark for long-horizon personalization (Mehri et al., 2026). This benchmark pairs each system with an LLM-based user simulator whose preference profiles are enforced across sessions, making it possible to measure whether a persistent user representation improves behavior over time. We instantiate the framework on math and code tasks using open-source LLMs and compare against context-only, reflection-based, and retrieval-based baselines. Our results show that the main benefit of VARS is improved interaction efficiency rather than large gains in raw task success. Compared with a strong Reflection baseline, the full VARS system achieves comparable task success while reducing timeout and user effort, indicating that a persistent user representation helps the agent surface relevant preferences with less corrective interaction. More broadly, these findings suggest a distinction between task-centric and user-centric memory objectives: task-centric memory is naturally reflected in whether the task is eventually completed, whereas user-centric memory is also reflected in the cost of collaboration required to reach that outcome. In this setting, organizing memory around the user primarily makes collaboration more efficient, while still yielding modest improvements in task success. The contributions of our work are: • We propose VARS, a frozen-backbone framework that learns a per-user dual vector from weak interaction feedback and adds a learned user-aware bonus to the task-centric reranker, so that retrieval reflects both query relevance and individual user preference. • We evaluate VARS on MultiSessionCollab and show that it improves interaction efficiency—reducing timeout rate and user effort—while matching a strong baseline in task success. • We analyze the learned user vectors and show that the dual-vector design separates stable cross-session preferences from transient within-session context, with long-term vectors aligning with cross-user preference overlap. 2 Related Works LLM personalization. Prior work on LLM personalization includes profile-augmented prompting (Salemi et al., 2024), learned user representations (Jiang et al., 2025b), and retrieval-based profile optimization (Du et al., 2026). These approaches have established the importance of adapting LLM behavior to individual users, but they typically assume a fixed user profile provided as input rather than one learned and updated from ongoing interaction. In contrast, our method learns a compact user representation online from interaction feedback and uses it to guide retrieval over structured preference memory, without per-user fine-tuning. Long-term memory and multi-session user modeling. A closely related line of work equips LLM agents with long-term memory by storing dialogue history, retrieved notes, or reflection summaries for later use (Zhong et al., 2024; Packer et al., 2023; Tan et al., 2025; Chhikara et al., 2025; Yang et al., 2026; Sarin et al., 2025). Some systems further separate long-term and short-term state through modular or event-centric architectures (Li et al., 2025; Zou et al., 2026). Related benchmarks study long-horizon memory and user modeling across sessions through profile inference, memory probing, or multimodal memory tasks (Jiang et al., 2025a, b; Wu et al., 2024; Bei et al., 2026; Shen et al., 2026), while Hu et al. (2026) highlight the complementary risk of over-personalization. Among these, MultiSessionCollab is closest to our setting because it evaluates downstream collaboration under persistent user preferences rather than question answering over stored history (Mehri et al., 2026). Building on this setting, we ask whether a learned persistent user state improves collaboration over time by reducing user effort and corrective interaction, not only by increasing eventual task success. Learning from weak interaction feedback. Our online update mechanism is also related to learning from implicit or bandit-style feedback in ranking and preference elicitation (Rendle et al., 2012; Hu et al., 2008; Koren et al., 2009; Zhao et al., 2022). Du et al. (2026) optimize profile selection via contextual bandits with a global policy; in contrast, we keep all backbone models frozen and learn a per-user retrieval bias from weak scalar feedback. 3 Method Figure 1: VARS architecture. MextM_ext extracts preference cards; a dual user vector zU,teff=βLzU(L)+βSzU,t(S)z_U,t^eff= _Lz_U^(L)+ _Sz_U,t^(S) biases reranking; a keyword-based reward r^t r_t drives REINFORCE updates. Our goal is to learn a persistent representation of the user that improves through interaction and enables the system to selectively surface relevant preferences at inference time. This representation is low-dimensional, modulates retrieval and reranking over structured preference memory, and requires no modification to backbone model parameters, and captures preferences that arise from user interaction as structured condition–action rules. 3.1 Problem Setting A user U interacts with an assistant across sessions s∈1,…,SUs∈\1,…,S_U\. Each session s is a conversation Cs=(u1,a1),…,(uTs,aTs)C_s=\(u_1,a_1),…,(u_T_s,a_T_s)\ of TsT_s turns, where utu_t and ata_t are the user and assistant utterances at turn t. A user utterance may pose a task query (e.g., a math problem) and simultaneously reveal preferences. The assistant must produce responses that are both task-correct and preference-aligned. User preferences persist across sessions, and the system maintains a per-user state (zU(L),zU,t(S))(z^(L)_U,z^(S)_U,t) between them. 3.2 System Overview Our framework uses three frozen backbone components—a chat model MchatM_chat for response generation, an embedding model fembf_emb for encoding preference notes, and a reranker MrerankM_rerank for scoring query–memory pairs—and introduces four learned components: a lightweight preference extraction model that converts dialogue into structured memory cards, a preference memory that indexes these cards for retrieval, a dual-vector user state that separates stable cross-session preferences from transient within-session context, and a reward-driven update mechanism that refines the user vectors from weak scalar feedback. All backbone parameters remain fixed; adaptation occurs only through the user-specific state. As illustrated in Figure 1, the system performs the following steps for a user U: 1. Preference Extraction. A small finetuned model MextM_ext processes a window of recent turns and extracts structured (condition,action)(condition,action) preference tuples in a fixed JSON schema (e.g., condition: “solving algebra”, action: “show each step”). 2. Preference Memory. Each extracted tuple is stored as a memory card comprising the tuple itself, a natural-language note nmn_m, a global/conditional flag, and a dense embedding eme_m from fembf_emb (schema and example in Appendix J). 3. User Vector. Memory embeddings are mapped into a shared item space; a long-term vector zU(L)z^(L)_U is computed as the mean of a user’s item vectors, and a short-term vector zU,t(S)z^(S)_U,t is updated online from the same scalar reward signal (Section 3.6). 4. Personalized Retrieval. For query utu_t, candidate memory cards are retrieved by dense search, reranked with a cross-encoder, and adjusted by a user-dependent bonus from zU,teff=βLzU(L)+βSzU,t(S)z^eff_U,t= _Lz^(L)_U+ _Sz^(S)_U,t. Universally applicable preferences bypass retrieval and are injected directly (Section 3.4). 5. Online RL Update. The follow-up query ut+1u_t+1 is converted into a scalar reward via keyword matching (Section 3.6); a REINFORCE-style update then adjusts zU(L)z^(L)_U and zU,t(S)z^(S)_U,t. 3.3 Preference Extraction Model We use MextM_ext, a 0.6B-parameter Qwen3 model Team (2025), as a lightweight preference extractor. The model is finetuned for instruction following and structured JSON generation. To train it, we construct a dataset of 564564K examples by combining public chat logs (LMSYS-Chat, WildChat), instruction-tuning corpora (Alpaca, SlimOrca), and GPT-5.1–labeled preference JSON Zheng et al. (2023); Zhao et al. (2024); Wang et al. (2023). On a held-out set, MextM_ext achieves 99.7%99.7\% JSON validity and 97.5%97.5\% recall at 37.7%37.7\% precision: it over-extracts, but the downstream reranker and user vector filter irrelevant cards, making high recall the priority. A per-source breakdown is in Appendix A, Table 6. The trained model and training data are publicly available.111https://huggingface.co/blackhao0426/pref-extractor-qwen3-0.6b-full-sft; https://huggingface.co/datasets/blackhao0426/user-preference-564k 3.4 Preference Memory and Item Space Memory cards. For each dialogue window WtW_t with non-empty extracted preferences PtP_t, we instantiate one or more memory cards. A memory card m for user U stores the user and session identifiers, the source turn IDs and raw user queries uk(m)\u_k^(m)\, a preference subset Pm⊆PtP_m P_t, a short textual note nmn_m summarizing the extracted preference(s) (e.g., “When doing code generation, use Python.”), and an embedding em=femb(usource(m))∈ℝde_m=f_emb(u_source^(m)) ^d (d=4096d=4096) of the source user query that expressed the preference. Global and conditional preferences. Not all extracted preferences need to be retrieved at inference time. Some are globally applicable (e.g., “always respond in Chinese”), whereas others are conditional on task type or local context (e.g., “when coding, include type hints”). We therefore classify each extracted preference as global or conditional from its condition field. A preference is treated as global if its condition contains universal indicators such as “general,” “always,” or “any task,” or if it consists of fewer than three words and contains no domain-specific terms. Global preferences bypass retrieval and are injected directly into the agent prompt, up to a cap of 1010, while only conditional preferences enter the dense retrieval and reranking pipeline. This two-tier design preserves retrieval capacity for query-dependent preferences while ensuring frequently applicable preferences are not missed; misclassified global preferences can still be surfaced through the conditional retrieval pipeline, limiting the impact of classification errors. Shared item space via PCA. We project memory embeddings into a shared lower-dimensional item space via PCA. Given all memory embeddings emm=1M\e_m\_m=1^M with mean μ, we retain the top k principal components in P∈ℝk×dP ^k× d and define the item vector vm=P(em−μ)∈ℝkv_m=P(e_m-μ) ^k. We set k=256k=256 to reduce the cost of user-vector operations while retaining the dominant structure of the embedding space (Kusupati et al., 2022; Khaledian et al., 2025). This shared coordinate system enables direct comparison between memory cards and learned user vectors (Section 3.5). 3.5 User State and User-Centric Retrieval Long-term and short-term user vectors. For each user U, we maintain two learned vectors in ℝkR^k. The long-term vector zU(L)∈ℝkz^(L)_U ^k is initialized to zero at the start of the first session and updated across all subsequent sessions via the REINFORCE-style rule in Section 3.6. Because it is never reset, it accumulates information from past interactions and is intended to capture stable cross-session preferences, such as preferred language or level of detail. The short-term vector zU,t(S)∈ℝkz^(S)_U,t ^k is initialized to zero at the start of each session, updated from turn-level feedback, and exponentially decayed to down-weight older signals. It is intended to capture transient within-session context and recency effects. The effective user vector at turn t is zU,teff=βLzU(L)+βSzU,t(S),z^eff_U,t= _Lz^(L)_U+ _Sz^(S)_U,t, where βL,βS≥0 _L, _S≥ 0 control the relative influence of cross-session and within-session state. Both vectors are learned from interaction feedback alone; no explicit user features or pre-computed user centroids are required. Base reranker. Given query utu_t and candidate memories Mt=m1,…,mKM_t=\m_1,…,m_K\ from dense retrieval, the frozen reranker MrerankM_rerank computes base relevance scores s0(ut,mi)=logprerank(y=1∣ut,nmi),s_0(u_t,m_i)= p_rerank(y=1 u_t,n_m_i), where nmin_m_i is the textual note of memory mim_i. These scores depend only on the query and note text and are independent of the user state. User-aware scoring. We add a user-specific bonus based on the dot product between the effective user vector and the memory-card item vector: s(ut,mi;u)=s0(ut,mi)+⟨zU,teff,vmi⟩.s(u_t,m_i;u)=s_0(u_t,m_i)+ z^eff_U,t,v_m_i . This yields a low-rank residual scoring layer on top of the frozen reranker, linear in both zU,teffz^eff_U,t and vmiv_m_i, and introduces no new global parameters beyond the user vectors. We define a softmax retrieval policy over the candidate set: πz(mi∣ut,U)=exp(s(ut,mi;u)/τ)∑j=1Kexp(s(ut,mj;u)/τ), _z(m_i u_t,U)= (s(u_t,m_i;u)/τ) _j=1^K (s(u_t,m_j;u)/τ), with temperature τ>0τ>0. In practice, we inject the top-J memories under s(⋅)s(·) into the LLM prompt. To bridge the semantic gap between task-oriented queries and preference descriptions during dense retrieval, we apply a lightweight keyword-based query transformation (Appendix H). 3.6 Weak Reward Instantiation and Online User-State Update A central design choice of the framework is that user-state learning depends only on a scalar feedback signal. The update rule itself is agnostic to how this signal is produced; in our experiments, we instantiate it with a lightweight heuristic computed from the user’s next turn ut+1u_t+1. Intuitively, this follow-up turn provides weak evidence about local collaboration quality: if the user continues without restating preferences or correcting the response, the preceding interaction is treated as more favorable; if the user expresses dissatisfaction or repeats preference constraints, it is treated as less favorable. Keyword-based reward estimation. We compute a scalar reward r^t r_t from ut+1u_t+1 using two lightweight signals: 1. Sentiment keywords. Curated negative indicators (e.g., “incorrect”, “redo”) contribute −1.0-1.0, while positive indicators (e.g., “thanks”, “continue”) contribute up to +1.0+1.0. 2. Topic coherence. Cosine similarity between eute_u_t and eut+1e_u_t+1 is used to detect topic shifts. When the similarity is low (<0.2<0.2), the reward is dampened, since it becomes less clear whether the follow-up turn reflects satisfaction with the previous response. The final reward is clipped to [−1,1][-1,1]. This instantiation requires no additional model call; a sensitivity analysis is in Appendix I. Heuristic retrieval-attribution gate. Because r^t r_t may reflect generation failures unrelated to retrieval, we scale the update by a gating factor gt∈[0,1]g_t∈[0,1] that heuristically attributes reward to the retrieval decision. Let sqmax=maxicos(emi,eut)s_q = _i (e_m_i,e_u_t) denote the maximum similarity between the query and any retrieved memory. We then use the following rule: • Strongly negative reward and no similar retrieved memory (sqmax<0.2s_q <0.2): assign high retrieval attribution, gt=0.9g_t=0.9. • Strongly negative reward and a relevant retrieved memory (sqmax>0.5s_q >0.5): assign low retrieval attribution, gt=0.2g_t=0.2. • Positive reward with a relevant retrieved memory: gt=0.6g_t=0.6; otherwise gt=0.3g_t=0.3. A sensitivity analysis on the ablation logs (Appendix I) confirms that the learned vectors are robust to moderate reward perturbations but that gating is critical: removing it causes severe vector inflation and directional drift. We maintain a running per-user baseline bU←(1−α)bU+αr^t,b_U←(1-α)b_U+α r_t, with smoothing coefficient α, following standard variance reduction practice for policy gradients (Williams, 1992; Greensmith et al., 2004). REINFORCE-style user-state update. Let At⊆MtA_t M_t denote the memories actually injected at turn t. We define the average item vector of the selected memories and the policy expectation: vchosen,t v_chosen,t =1|At|∑mi∈Atvmi, = 1|A_t| _m_i∈ A_tv_m_i, (1) μt _t =∑i=1Kπz(mi∣ut,U)vmi. = _i=1^K _z(m_i u_t,U)\,v_m_i. The retrieval-specific advantage is Atretr=gt(r^t−bU),A_t^retr=g_t( r_t-b_U), (2) which down-weights updates when retrieval is unlikely to be responsible for the observed reward or when the reward is close to baseline. The long-term and short-term update increments are ΔzU(L) z_U^(L) =ηLAtretrτ(vchosen,t−μt), = _L A_t^retrτ (v_chosen,t- _t ), (3) ΔzU,t(S) z_U,t^(S) =ηSAtretrτ(vchosen,t−μt), = _S A_t^retrτ (v_chosen,t- _t ), with learning rates ηL,ηS _L, _S. We then update the long-term state by zU(L)←zU(L)+ΔzU(L),z_U^(L)← z_U^(L)+ z_U^(L), (4) and the short-term state by zU,t+1(S)=(1−λ)zU,t(S)+ΔzU,t(S),z_U,t+1^(S)=(1-λ)z_U,t^(S)+ z_U,t^(S), (5) where λ∈(0,1)λ∈(0,1) is the decay rate (Besbes et al., 2015). Positive advantage moves the user state toward the selected memories, while negative advantage pushes it away. Because user vectors and memory-card vectors share the same item space, repeated updates toward similar retrieved preferences can lead users with similar revealed preferences to occupy nearby regions of that space, analogous to implicit collaborative filtering (Hu et al., 2008; Koren et al., 2009). We test this empirically in Section 5. A theoretical motivation for the update dynamics is provided in Appendix E. In brief, we show that the implemented updates correspond to exact gradients of a fixed-candidate surrogate objective (Proposition 1), and that the dual-vector state admits an exact two-timescale decomposition separating persistent signal from transient local context (Proposition 2). 3.7 Inference and Adaptation Loop Figure 1 shows how the components described above interact at each turn. When a new query utu_t arrives, the system retrieves candidate preference cards from memory via dense search over fembf_emb embeddings, then reranks them using MrerankM_rerank augmented by the user-dependent bonus from zU,teffz_U,t^eff. The top-ranked preference notes, together with any global preferences, are injected into the prompt for MchatM_chat, which generates the response ata_t. Once the user’s follow-up ut+1u_t+1 is observed, the reward model produces r^t r_t and the attribution gate gtg_t, driving a REINFORCE-style update of both user vectors. In parallel, MextM_ext processes recent dialogue windows to extract new preference cards that are added to memory. This creates a closed loop: the preference memory grows with interaction, and the user state adapts to steer retrieval toward increasingly relevant preferences. At session boundaries, zU,t(S)z_U,t^(S) resets while zU(L)z_U^(L) persists, separating transient context from stable cross-session signal. 4 Experimental Setup 4.1 Benchmark and Tasks We evaluate on MultiSessionCollab (Mehri et al., 2026), a benchmark that pairs each system with an LLM-based user simulator whose persona encodes a rich set of style preferences. Evaluation proceeds across multiple sessions per user profile, so the central challenge is whether the system can learn and leverage user preferences over successive interactions rather than treating each session independently. We select three task domains requiring both correctness and style compliance: math-hard (complex problems with ground-truth LaTeX solutions), math-500 (broad mathematical topics), and bigcodebench (code generation with executable test cases). In all domains the agent must produce a correct solution while respecting the user’s style preferences across sessions. For each system mode, we evaluate the same 6060 user profiles over 6060 sessions per profile, with up to 1010 turns per session, yielding 3,6003,600 sessions per method. Reported aggregate metrics are computed over all sessions pooled across the three domains. 4.2 Profiles and Style Preferences Each user profile specifies style preferences as structured condition–action rules that persist across sessions. Across the 6060 profiles, the average profile contains 4343 preferences, covering dimensions such as algebraic derivation style, degree of intermediate reasoning, language choice, and code formatting. Preferences are represented in a structured JSON schema with explicit identifiers, conflict groups, and priority cues. Appendix B provides a complete example profile. 4.3 Models and System Implementation We use an open-source stack throughout. The benchmark user simulator is Llama-3.3-70B-Instruct Team (2024), and the conversational agent is Llama-3.1-8B-Instruct Team (2024), both served with vLLM Kwon et al. (2023). For preference memory, we use Qwen3-Embedding-8B Zhang et al. (2025) for dense retrieval and Qwen3-Reranker-8B Zhang et al. (2025) for query–memory scoring. Preference extraction uses the lightweight finetuned model MextM_ext described in Section 3.3. All backbone components are kept frozen during evaluation; online adaptation occurs only through the user vectors. The scalar feedback signal for user-vector updates is instantiated with the keyword-based heuristic described in Section 3.6, requiring no additional LLM call. 4.4 System Modes and Baselines We compare six system modes under the same frozen-backbone setting (rows in Table 1): Vanilla (no memory), Contextual (full history appended), All-memory (all extracted preferences appended), Reflection (session-level reflection summaries appended to future prompts), RAG (dense retrieval + reranking, no user vector), and VARS (our full method with learned user state). Full descriptions are provided in Appendix F. Global preference injection (Section 3.4) applies identically to all modes that use preference extraction (All-memory, RAG, VARS); Vanilla and Contextual have no preference memory, and Reflection uses its own session-level summaries. All modes are evaluated on the same 6060 profiles over 6060 sessions. 4.5 Evaluation Metrics The main comparison (Table 1) reports success rate, timeout rate (fraction of sessions exhausting all turns without task completion), and user effort (average user tokens per session; note that Mehri et al. (2026) define user effort as the number of preference enforcement instances—we adopt a token-based measure as a more direct proxy for interaction cost), distinguishing whether the task is completed from how much user-side intervention is required. Table 3 adds efficiency and compliance metrics including interaction efficiency (successes per 1k user tokens), late-session success, quick resolution, first-turn enforcement, and zero-enforcement success. 5 Result Figure 2: Main results summary on MultiSessionCollab. 5.1 Main Comparison Table 1 summarizes results across all three task domains for the six system modes, evaluated over 6060 profiles × 6060 sessions (3,6003,600 sessions per method). Method Success (%) ↑ Timeout (%) ↓ User tokens ↓ VARS 55.2 26.4 193.6 Reflection 54.4 28.8 207.5 Vanilla 54.3 29.2 232.9 Contextual 52.4 31.4 213.7 RAG 52.0 44.3 188.4 All-memory 50.9 33.4 226.8 Table 1: Main results on MultiSessionCollab (6060 profiles × 6060 sessions). Bold = best; underline = second best. Overall ranking. VARS leads on all three primary metrics (Table 1). The +3.2+3.2 p success gap over RAG isolates the user vector’s contribution, since all other pipeline components are shared. Comparison with Reflection. Paired tests across 6060 profiles (Table 2) show VARS significantly reduces timeout (−2.4-2.4 p, p=0.046p=0.046) and user effort (−13.9-13.9 tokens, p=0.021p=0.021), while the success difference (+0.9+0.9 p) is not significant (p=0.276p=0.276). Metric Reflection RAG+Vec Δ p (paired t) Success (%) 54.4 55.2 ++0.9 0.276 Timeout (%) 28.8 26.4 −-2.4 0.046∗ User tokens 207.5 193.6 −-13.9 0.021∗ Table 2: VARS vs. Reflection (6060 profiles, one-sided paired t-tests). ∗ p<0.05p<0.05. Additional metrics. Table 3 reports efficiency and compliance metrics. VARS leads on all reported measures, yielding the highest interaction efficiency (2.832.83 successes per 1,0001,000 user tokens, +8.4%+8.4\% over Reflection). VARS has a slightly higher per-turn enforcement rate (0.1860.186 vs. 0.1750.175, n.s.), but this does not translate into worse interaction quality given matched success with fewer turns and lower token cost. Metric Reflection RAG VARS Succ. / 1k user tokens ↑ 2.61 2.80 2.83 Late success (sess. 30–59) ↑ 51.8% 51.7% 54.1% Quick resolution (≤ 4 turns) ↑ 3.5% 3.4% 3.9% Zero-enf. success ↑ 60.2% 57.1% 60.6% First-turn enforced ↓ 7.9% 7.2% 7.1% Profiles improved ↑ 31.6% — 36.7% Table 3: Additional metrics. ↑ /↓ = higher/lower is better. Bold = best. VARS also maintains the highest late-session success and the lowest first-turn enforcement rate, indicating that cross-session learning and proactive preference surfacing both improve over time. 5.2 User-Vector Representation Analysis We next ask whether the learned long-term user vectors zU(L)z^(L)_U capture meaningful structure in the underlying preference space. Setup. For each user pair (u,v)(u,v) we compute the Jaccard similarity of their revealed preferences (enforced at least once during the 6060 sessions) and the cosine similarity of their learned long-term vectors cos(zU(L),zv(L)) (z^(L)_U,z^(L)_v). All 6060 users develop non-zero long-term vectors; the mean ℓ2 _2 norm grows monotonically from 0 (session 0) to 0.00330.0033 (session 6060). Preference overlap predicts vector similarity. Spearman correlation between Jaccard overlap and vector cosine is ρ=0.040ρ=0.040 (p=0.093p=0.093)—modest globally, but a quartile analysis reveals a clearer signal: user pairs in the top 25%25\% of preference similarity have mean vector cosine +0.012+0.012 versus −0.027-0.027 for the bottom 25%25\% (Mann–Whitney U, p=0.021p=0.021), confirming that shared preferences push users toward similar regions in vector space via REINFORCE updates. Dual-vector separation. Table 4 compares the three vector variants. The long-term vector z(L)z^(L) significantly associates with preference overlap (quintile p=0.006p=0.006), while z(S)z^(S) does not (p=0.586p=0.586), confirming that the dual-vector design separates stable user identity from session-specific adaptation. Vector Spearman ρ (p) Quintile p z(L)z^(L) (long-term) 0.040 (0.093) 0.006 z(S)z^(S) (short-term) 0.010 (0.681) 0.586 Combined 0.046 (0.054) 0.003 Table 4: User-vector cosine vs. preference Jaccard overlap ((602) 602 pairs). Dual-vector ablation. Table 5 reports ablations that disable one or both user vectors. The full dual-vector model leads on all primary metrics. Removing z(L)z^(L) hurts more than removing z(S)z^(S) in terms of timeout rate, while removing z(S)z^(S) has a larger effect on success rate. The non-timeout user token column reveals a functional separation: z(L)z^(L) drives effort reduction in successful sessions (Full 166.5166.5 ≈ z(L)z^(L)-only 168.1168.1, both well below z(S)z^(S)-only 185.7185.7), while z(S)z^(S) contributes more to timeout avoidance (z(S)z^(S)-only 12.7%12.7\% vs. z(L)z^(L)-only 14.7%14.7\%). This supports the intended design: z(L)z^(L) captures stable preferences that reduce corrective interaction, and z(S)z^(S) enables within-session adaptation that prevents session failure. Method Success (%) ↑ Timeout (%) ↓ User tok ↓ Non-TO utok ↓ VARS (full) 74.0 10.7 474.5 166.5 z(S)z^(S) only 72.7 12.7 846.8 185.7 z(L)z^(L) only 71.3 14.7 1347.4 168.1 No vector 70.0 14.0 1566.1 183.7 Table 5: Dual-vector ablation on math-hard (1010 profiles × 1515 sessions) with GPT-4o-mini. Higher absolute success reflects the stronger backbone. Non-TO utok = non-timeout sessions only. We also identify three recurring failure modes—over-cautious clarification, preference overload, and early user disengagement—which are more pronounced for RAG (44.3%44.3\% timeout) than VARS (26.4%26.4\%); details are in Appendix G. 6 Discussion Where does personalization help? The user vector’s primary contribution is not raw success rate—where the gain over Reflection is modest and not significant—but interaction efficiency: matching task success with significantly less user effort and fewer timeouts. This suggests that under frozen backbones, lightweight user modeling improves how the agent interacts rather than how often it ultimately succeeds. Comparing RAG (52.0%52.0\%) with VARS (55.2%55.2\%) further shows that the vector mitigates preference overload: without it, retrieval surfaces an increasingly noisy set of preferences as memory grows, leading the agent to hedge or produce unfocused responses (RAG timeout: 44.3%44.3\% vs. VARS: 26.4%26.4\%). That Vanilla (54.3%54.3\%) nearly matches Reflection (54.4%54.4\%) despite having no cross-session memory reinforces this point—a meaningful portion of success is driven by intrinsic problem-solving ability, making interaction efficiency a more informative measure of personalization quality than success rate alone. We note that aggressive preference surfacing can risk over-personalization (Hu et al., 2026); our design mitigates this through selective retrieval biasing and a cap on global preference injection, though systematic evaluation of this risk remains future work. Preference format and agent compliance. Directly injecting structured condition–action rules into an 8B-parameter agent’s prompt often fails to elicit compliance: the agent treats them as metadata rather than instructions. Reflection’s natural-language summaries are more readily followed, and the MultiSessionCollab prompt template is designed for reflection-style notes, suggesting that compliance is bottlenecked by presentation format as well as retrieval quality. 7 Conclusion We have presented a frozen-backbone personalization framework that represents each user as a learned dual vector in a shared preference space, updated online from weak scalar rewards and used to modulate retrieval over structured preference memory—without modifying any backbone model. This lightweight approach matches a reasoning-based baseline in task success while significantly reducing user effort and timeout rate, and the learned vectors encode interpretable preference structure that separates stable user identity from session-specific context. These results motivate scaling to richer preference types, stronger reward signals, and real-user evaluation. Limitations Scale and generalization. We evaluate on 6060 profiles drawn from a pool of 200200, with 6060 sessions per profile. While this yields 3,6003,600 sessions per method, it remains a single benchmark with LLM-simulated users. Extending to real users, longer interaction horizons, and non-style preferences (e.g., topical interests, tool choices, safety constraints) is necessary to assess generalizability. Reward signal. The current system uses a keyword-based heuristic to classify user follow-ups into reward categories. While fast and requiring no additional model, this heuristic may miss subtle feedback cues. We have implemented and validated an LLM-as-judge alternative (Llama-3.1-8B-Instruct, 8383–92%92\% agreement with GPT-based judges) that can serve as a drop-in replacement for richer reward estimation, but have not yet evaluated its effect on user-vector learning dynamics. Hyperparameter sensitivity. Learning rates (ηL _L, ηS _S), scoring weights (βL _L, βS _S), decay rate (λ), and retrieval parameters (top-k, reranker threshold) are set heuristically (Appendix D). Systematic hyperparameter sweeps are needed to understand sensitivity. Simulator fidelity. All evaluation relies on an LLM-based user simulator whose preference enforcement behavior may differ from real users. The simulator’s tolerance thresholds and enforcement patterns introduce variance that may not reflect authentic human interaction dynamics (Mehri et al., 2025). More broadly, LLM-based user simulators can exhibit systematic biases—such as unrealistic patience or overly formulaic preference enforcement—that may inflate or deflate measured personalization gains relative to real users. Privacy. Storing persistent user vectors and structured preference memories introduces profiling risks. In deployment, these artifacts should be subject to the same access controls and deletion policies as conversation history. References Y. Bei, T. Wei, X. Ning, Y. Zhao, Z. Liu, X. Lin, Y. Zhu, H. Hamann, J. He, and H. Tong (2026) Mem-Gallery: benchmarking multimodal long-term conversational memory for MLLM agents. CoRR abs/2601.03515. External Links: Document, 2601.03515 Cited by: §2. O. Besbes, Y. Gur, and A. Zeevi (2015) Non-stationary stochastic optimization. Operations Research 63 (5), p. 1227–1244. External Links: Document Cited by: §3.6. A. Chatterji, T. Cunningham, D. J. Deming, Z. Hitzig, C. Ong, C. Y. Shan, and K. Wadman (2025) How people use chatgpt. Working Paper Technical Report 34255, Working Paper Series, National Bureau of Economic Research. External Links: Document, Link Cited by: §1. P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. Yadav (2025) Mem0: building production-ready ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413. Cited by: §1, §2. L. Du, Y. Yuan, Z. Zhao, F. Lyu, E. Penaloza, X. Chen, Z. Sun, J. Kang, L. Charlin, X. Liu, and H. Wu (2026) Optimizing user profiles via contextual bandits for retrieval-augmented LLM personalization. arXiv preprint arXiv:2601.12078. Cited by: §2, §2. E. Greensmith, P. L. Bartlett, and J. Baxter (2004) Variance reduction techniques for gradient estimates in reinforcement learning. Journal of Machine Learning Research 5, p. 1471–1530. Cited by: §3.6. Z. He, Y. Wang, C. Zhi, Y. Hu, T. Chen, L. Yin, Z. Chen, T. A. Wu, S. Ouyang, Z. Wang, J. Pei, J. McAuley, Y. Choi, and A. Pentland (2026) MemoryArena: benchmarking agent memory in interdependent multi-session agentic tasks. arXiv preprint arXiv:2602.16313. Cited by: §1. Y. Hu, Y. Koren, and C. Volinsky (2008) Collaborative filtering for implicit feedback datasets. In Proceedings of the 2008 IEEE International Conference on Data Mining, p. 263–272. External Links: Document Cited by: §2, §3.6. Y. Hu, Z. Long, J. Guo, X. Sui, X. Fu, W. Zhao, Y. Zhao, and B. Qin (2026) OP-Bench: benchmarking over-personalization for memory-augmented personalized conversational agents. arXiv preprint arXiv:2601.13722. Cited by: §2, §6. B. Jiang, Z. Hao, Y. Cho, B. Li, Y. Yuan, S. Chen, L. H. Ungar, C. J. Taylor, and D. Roth (2025a) Know me, respond to me: benchmarking LLMs for dynamic user profiling and personalized responses at scale. arXiv preprint arXiv:2504.14225. External Links: Document Cited by: §1, §2. B. Jiang, Y. Yuan, M. Shen, Z. Hao, Z. Xu, Z. Chen, Z. Liu, A. R. Vijjini, J. He, H. Yu, R. Poovendran, G. Wornell, L. Ungar, D. Roth, S. Chen, and C. J. Taylor (2025b) PersonaMem-v2: towards personalized intelligence via learning implicit user personas and agentic memory. arXiv preprint arXiv:2512.06688. External Links: Document Cited by: §1, §2, §2. A. Khaledian, A. Ghadiridehkordi, and N. Khaledian (2025) PCA-RAG: principal component analysis for efficient retrieval-augmented generation. arXiv preprint arXiv:2504.08386. External Links: Document Cited by: §3.4. Y. Koren, R. Bell, and C. Volinsky (2009) Matrix factorization techniques for recommender systems. Computer 42 (8), p. 30–37. External Links: Document Cited by: §2, §3.6. A. Kusupati, G. Bhatt, A. Rege, M. Wallingford, A. Sinha, V. Ramanujan, W. Howard-Snyder, K. Chen, S. Kakade, P. Jain, and A. Farhadi (2022) Matryoshka representation learning. In Advances in Neural Information Processing Systems, Vol. 35. Cited by: §3.4. W. Kwon, H. Kim, et al. (2023) Efficient memory management for large language model serving with pagedattention. In Proceedings of the 29th ACM Symposium on Operating Systems Principles (SOSP), External Links: Document Cited by: §4.3. H. Li, C. Yang, A. Zhang, Y. Deng, X. Wang, and T. Chua (2025) 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), p. 5259–5276. External Links: Link, Document Cited by: §1, §1, §2. W. Lian, G. Wang, B. Goodson, E. Pentland, A. Cook, C. Vong, and Teknium (2023) SlimOrca: an open dataset of GPT-4 augmented FLAN reasoning traces, with verification. HuggingFace. External Links: Link Cited by: Table 6. S. Mehri, P. Kargupta, T. August, and D. Hakkani-Tür (2026) Learning user preferences through interaction for long-term collaboration. CoRR abs/2601.02702. External Links: Document, 2601.02702 Cited by: §1, §1, §1, §2, §4.1, §4.5. S. Mehri, X. Yang, T. Kim, G. Tur, S. Mehri, and D. Hakkani-Tür (2025) Goal alignment in llm-based user simulators for conversational ai. arXiv preprint arXiv:2507.20152. Cited by: Simulator fidelity.. C. Packer, S. Wooders, K. Lin, V. Fang, S. G. Patil, I. Stoica, and J. E. Gonzalez (2023) MemGPT: towards llms as operating systems. arXiv preprint arXiv:2310.08560. Cited by: §1, §2. S. Rendle, C. Freudenthaler, Z. Gantner, and L. Schmidt-Thieme (2012) BPR: bayesian personalized ranking from implicit feedback. CoRR abs/1205.2618. External Links: Document, 1205.2618 Cited by: §2. A. Salemi, S. Mysore, M. Bendersky, and H. Zamani (2024) LaMP: when large language models meet personalization. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), External Links: Document, 2304.11406 Cited by: §1, §2. S. Sarin, L. Singh, B. Sarmah, and D. Mehta (2025) Memoria: a scalable agentic memory framework for personalized conversational AI. In 2025 5th International Conference on AI-ML-Systems (AIMLSystems), p. 32–39. External Links: Document Cited by: §2. Y. Shen, D. Pei, Y. Guo, J. Wang, Y. Guo, Z. Zhang, Q. Jia, J. Zhou, and G. Zhai (2026) EvolMem: a cognitive-driven benchmark for multi-session dialogue memory. arXiv preprint arXiv:2601.03543. Cited by: §2. Z. Tan, J. Yan, I. Hsu, R. Han, Z. Wang, L. Le, Y. Song, Y. Chen, H. Palangi, G. Lee, A. R. Iyer, T. Chen, H. Liu, C. Lee, and T. Pfister (2025) In prospect and retrospect: reflective memory management for long-term personalized dialogue agents. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Vienna, Austria, p. 8416–8439. Cited by: §1, §2. L. Team (2024) The llama 3 herd of models. External Links: 2407.21783, Document Cited by: §4.3. Q. Team (2025) Qwen3 technical report. External Links: 2505.09388, Document Cited by: Appendix A, §3.3. Y. Wang, H. Ivison, P. Dasigi, et al. (2023) How far can camels go? exploring the state of instruction tuning on open resources. External Links: 2306.04751, Document Cited by: Table 6, §3.3. R. J. Williams (1992) Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning 8 (3), p. 229–256. External Links: Document Cited by: §3.6. D. Wu, H. Wang, W. Yu, Y. Zhang, K. Chang, and D. Yu (2024) LongMemEval: benchmarking chat assistants on long-term interactive memory. CoRR abs/2410.10813. External Links: Document, 2410.10813 Cited by: §1, §2. K. Yang, Z. Chen, X. He, J. Jiang, M. Galley, C. Wang, J. Gao, J. Han, and C. Zhai (2026) PlugMem: a task-agnostic plugin memory module for llm agents. External Links: 2603.03296, Link Cited by: §1, §2. Y. Zhang, M. Li, D. Long, X. Zhang, H. Lin, B. Yang, P. Xie, A. Yang, D. Liu, J. Lin, F. Huang, and J. Zhou (2025) Qwen3 embedding: advancing text embedding and reranking through foundation models. External Links: 2506.05176, Link Cited by: §4.3. C. Zhao, T. Yu, Z. Xie, and S. Li (2022) Knowledge-aware conversational preference elicitation with bandit feedback. In Proceedings of the ACM Web Conference 2022, p. 483–492. External Links: Document Cited by: §2. W. Zhao, X. Ren, J. Hessel, C. Cardie, Y. Choi, and Y. Deng (2024) WildChat: 1m ChatGPT interaction logs in the wild. External Links: 2405.01470, Document Cited by: Table 6, §3.3. L. Zheng, W. Chiang, Y. Sheng, T. Li, S. Zhuang, Z. Wu, Y. Zhuang, Z. Li, Z. Lin, Eric. P. Xing, J. E. Gonzalez, I. Stoica, and H. Zhang (2023) LMSYS-chat-1m: a large-scale real-world llm conversation dataset. External Links: 2309.11998 Cited by: Table 6, §3.3. Y. Zheng, R. Zhang, J. Zhang, Y. Ye, Z. Luo, Z. Feng, and Y. Ma (2024) LlamaFactory: unified efficient fine-tuning of 100+ language models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations), Bangkok, Thailand. External Links: Link Cited by: Appendix A. W. Zhong, L. Guo, Q. Gao, H. Ye, and Y. Wang (2024) MemoryBank: enhancing large language models with long-term memory. Proceedings of the AAAI Conference on Artificial Intelligence 38 (17), p. 19724–19731. Cited by: §1, §2. H. Zou, T. Sun, C. He, Y. Tian, Z. Li, L. Jin, N. Liu, J. Zhong, and K. Wei (2026) ES-Mem: event segmentation-based memory for long-term dialogue agents. arXiv preprint arXiv:2601.07582. Cited by: §2. Appendix A Preference Extractor Training Details Model and objective. The preference extractor MextM_ext is a 0.6B-parameter Qwen3 model Team (2025) finetuned for instruction-following and structured JSON output with LLaMA-Factory Zheng et al. (2024). Given a short dialogue window WtW_t (typically the last few turns up to t), MextM_ext is trained to predict a set of preference tuples Pt=(conditionj,actionj)j=1JtP_t=\(condition_j,action_j)\_j=1^J_t in a fixed JSON schema (Section 3.3). Each tuple describes when a preference applies (condition) and what the agent should do (action). The model is trained with a standard left-to-right language modeling objective on the JSON-serialized output. Data construction. We construct a mixed dataset of 564,423564,423 examples (33%33\% positive, 67%67\% negative) from the sources listed in Table 6. Teacher labels are generated by GPT-5.1 via the OpenAI Batch API; we retain both positive examples (with extracted preferences) and negative examples (no preference) so that MextM_ext learns when not to emit any preference. All sources are converted into a unified instruction format with the dialogue window WtW_t as input and the target JSON as output, then randomly mixed during training. Source Count GPT-5.1 synthesized positives 156,489 LMSYS-Chat-1M Zheng et al. (2023) 133,086 WildChat Zhao et al. (2024) 108,677 Retry / recovery labels 68,778 Alpaca-Cleaned Wang et al. (2023) 42,013 ShareGPT-Vicuna222https://huggingface.co/datasets/anon8231489123/ShareGPT_Vicuna_unfiltered 33,025 SlimOrca Lian et al. (2023) 22,345 Manual fixes 10 Total 564,423 Table 6: Training data sources for the preference extractor. Training hyperparameters. We perform full supervised finetuning (SFT) with a global batch size of 128, AdamW optimizer, learning rate 2×10−52× 10^-5, a cosine learning rate schedule, and bf16 precision on H200 GPUs. We train for a small number of epochs until validation loss plateaus. On a held-out evaluation set of teacher-labeled examples, the resulting model achieves 99.7%99.7\% JSON validity, 97.5%97.5\% recall, 37.7%37.7\% precision, and 54.4%54.4\% F1. The high recall ensures that nearly all explicitly stated preferences are captured, while the lower precision reflects a deliberate “extract first, filter later” design: over-extracted preferences are filtered downstream by the reranker and user-vector scoring (Section 3.5). Appendix B User Profile Example This appendix provides a concrete user profile from our MultiSessionCollab math-hard experiments. The profile (user_14b429db) is one of the five users used in the main experiments (Section 4.2); it encodes 43 structured style preferences and 15 conflict groups, and was run for 20 sessions in our pilot study. We also show the subset of preferences that were explicitly revealed during the 20-session interaction, and the basic interaction statistics for this user. B.1 Full Preference Schema for user_14b429db ⬇ "user_id": "user_14b429db", "persona": "A senior backend engineer who values efficiency and directness. Prefers practical solutions over theoretical discussions.", "meta": "total_preferences": 43, "total_conflict_groups": 15, "generator": "schema_based" , "preferences": [ "id": "cs_008", "condition": "providing error handling examples", "action": "always use specific exception types, never bare except", "conflict_group": null, "priority_context": ["error", "exception", "try"] , "id": "rf_003", "condition": "providing a final answer or conclusion", "action": "put the answer first, then explanation", "conflict_group": "answer_position", "priority_context": ["direct_question", "what_is"] , "id": "ds_001", "condition": "discussing machine learning concepts", "action": "include the mathematical formulation alongside intuitive explanation", "conflict_group": null, "priority_context": ["ml", "machine learning", "model"] , "id": "ds_006", "condition": "writing or reviewing documentation", "action": "be concise, avoid marketing language, focus on usage", "conflict_group": null, "priority_context": ["documentation", "docs", "readme"] , "id": "vb_004", "condition": "I’m debugging and say ’it doesn’t work’", "action": "focus on diagnosing the specific issue, skip general explanations", "conflict_group": "explanation_depth", "priority_context": ["debugging", "error", "fix"] , "id": "ip_002", "condition": "I give a clear and specific instruction", "action": "execute directly without asking for confirmation", "conflict_group": "autonomy", "priority_context": ["do this", "make this", "specific_instruction"] , "id": "vb_002", "condition": "the topic involves complex algorithms or mathematics", "action": "provide detailed step-by-step derivation with intermediate results", "conflict_group": "response_length", "priority_context": ["complex_topic", "proof", "derivation"] , "id": "ec_001", "condition": "I make a minor error in terminology", "action": "correct it gently inline without making it a focus", "conflict_group": "correction_style", "priority_context": ["minor_error", "terminology"] , "id": "ms_002", "condition": "discussing statistics or probability", "action": "start with intuition and real-world interpretation before formulas", "conflict_group": "math_approach", "priority_context": ["probability", "statistics", "likelihood"] , "id": "ip_001", "condition": "the task is complex with multiple parts", "action": "confirm the plan before executing, break into phases", "conflict_group": "autonomy", "priority_context": ["complex", "multiple", "project"] , "id": "cs_004", "condition": "the code snippet is short (under 20 lines)", "action": "include inline comments explaining each logical block", "conflict_group": "comment_style", "priority_context": ["example", "snippet"] , "id": "vb_001", "condition": "I say ’quick question’ or ’briefly’", "action": "respond in 3 sentences or fewer, no elaboration", "conflict_group": "response_length", "priority_context": ["time_pressure", "simple_query"] , "id": "rf_002", "condition": "explaining a sequential process or procedure", "action": "use numbered steps with clear transitions", "conflict_group": "format_structure", "priority_context": ["tutorial", "how-to", "setup"] , "id": "ms_005", "condition": "discussing proofs", "action": "structure as: claim, approach sketch, formal proof, intuition recap", "conflict_group": "proof_style", "priority_context": ["prove", "proof", "show that"] , "id": "ec_004", "condition": "I ask you to correct your previous response", "action": "acknowledge the error explicitly, then provide corrected version", "conflict_group": null, "priority_context": ["you were wrong", "that’s not right", "actually"] , "id": "ec_003", "condition": "my code has a bug", "action": "show the bug location, explain why it’s wrong, provide the fix", "conflict_group": null, "priority_context": ["bug", "error", "wrong"] , "id": "cs_001", "condition": "writing Python code", "action": "use snake_case for variables and functions, include type hints", "conflict_group": "naming_convention", "priority_context": ["python", "py"] , "id": "oa_003", "condition": "any response with code", "action": "always specify the language in the code fence", "conflict_group": null, "priority_context": ["code"] , "id": "ip_006", "condition": "I thank you or say the answer was helpful", "action": "don’t add unnecessary follow-up, just acknowledge briefly", "conflict_group": null, "priority_context": ["thanks", "helpful", "great"] , "id": "rf_004", "condition": "teaching a new concept", "action": "build up intuition before giving the formal definition", "conflict_group": "answer_position", "priority_context": ["learning", "explain", "why"] , "id": "ds_004", "condition": "explaining a theoretical concept", "action": "start with definition, then example, then edge cases", "conflict_group": "example_position", "priority_context": ["concept", "theory", "what is"] , "id": "vb_005", "condition": "I explicitly share my current understanding first", "action": "acknowledge what I got right, then correct only the gaps", "conflict_group": null, "priority_context": ["validation", "checking"] , "id": "cs_006", "condition": "I ask for a code review", "action": "focus only on bugs and logic errors, ignore style issues", "conflict_group": "review_scope", "priority_context": ["review", "check", "look at"] , "id": "cs_003", "condition": "writing SQL queries", "action": "use UPPERCASE for keywords, lowercase for table/column names", "conflict_group": "naming_convention", "priority_context": ["sql", "database", "query"] , "id": "ec_002", "condition": "I have a fundamental misconception", "action": "address the misconception directly and clearly before proceeding", "conflict_group": "correction_style", "priority_context": ["misconception", "fundamental_error"] , "id": "ms_003", "condition": "I ask to verify my calculation", "action": "check my work step by step, point out where I diverged if wrong", "conflict_group": null, "priority_context": ["verify", "check", "is this right"] , "id": "ms_001", "condition": "solving algebraic equations", "action": "show each manipulation step with the operation applied noted", "conflict_group": "math_detail", "priority_context": ["solve", "equation", "algebra"] , "id": "vb_003", "condition": "I ask ’why’ or ’how come’", "action": "always explain the underlying reasoning, not just the what", "conflict_group": "explanation_depth", "priority_context": ["curiosity", "understanding"] , "id": "cs_002", "condition": "writing JavaScript or TypeScript code", "action": "use camelCase for variables, PascalCase for classes", "conflict_group": "naming_convention", "priority_context": ["javascript", "js", "typescript", "ts"] , "id": "ds_003", "condition": "discussing APIs or library usage", "action": "show a minimal working example before explaining parameters", "conflict_group": "example_position", "priority_context": ["api", "library", "how to use"] , "id": "oa_004", "condition": "providing commands to run", "action": "use bash code blocks, include expected output as comments", "conflict_group": null, "priority_context": ["command", "run", "terminal"] , "id": "ms_004", "condition": "the problem involves calculus", "action": "state the rule being applied (chain rule, integration by parts, etc.)", "conflict_group": "math_detail", "priority_context": ["derivative", "integral", "calculus"] , "id": "ms_006", "condition": "I’m practicing for an exam", "action": "after solving, give a similar practice problem", "conflict_group": null, "priority_context": ["practice", "exam", "test"] , "id": "ds_002", "condition": "discussing system design or architecture", "action": "describe components as a list first, then explain interactions", "conflict_group": null, "priority_context": ["design", "architecture", "system"] , "id": "ip_003", "condition": "I seem uncertain or ask ’what do you think’", "action": "provide a recommendation with brief rationale, not just options", "conflict_group": "guidance_style", "priority_context": ["uncertain", "should I", "what do you think"] , "id": "ds_005", "condition": "discussing data structures", "action": "always include time complexity for operations mentioned", "conflict_group": null, "priority_context": ["data structure", "array", "tree", "hash"] , "id": "ip_004", "condition": "I’m comparing alternatives", "action": "present trade-offs in a table format with clear criteria", "conflict_group": "guidance_style", "priority_context": ["compare", "vs", "or", "which"] , "id": "ip_005", "condition": "I express frustration or say ’this is annoying’", "action": "acknowledge the difficulty briefly, then provide direct help", "conflict_group": null, "priority_context": ["frustration", "annoying", "stuck"] , "id": "oa_001", "condition": "generating code that will be copied", "action": "provide code in a single copyable block, no interleaved explanation", "conflict_group": "code_presentation", "priority_context": ["copy", "use this", "give me code"] , "id": "oa_002", "condition": "teaching through code examples", "action": "break code into small chunks with explanation between each", "conflict_group": "code_presentation", "priority_context": ["teach", "learn", "understand"] , "id": "cs_005", "condition": "the code is a complete module or class", "action": "use docstrings at function/class level, minimal inline comments", "conflict_group": "comment_style", "priority_context": ["module", "class", "production"] , "id": "rf_001", "condition": "listing multiple items or options", "action": "use bullet points with consistent indentation", "conflict_group": "format_structure", "priority_context": ["enumeration", "comparison"] , "id": "cs_007", "condition": "I ask to improve or refactor code", "action": "address both logic and style, suggest modern idioms", "conflict_group": "review_scope", "priority_context": ["improve", "refactor", "better"] ], "conflict_groups": "answer_position": ["rf_003", "rf_004"], "explanation_depth": ["vb_004", "vb_003"], "autonomy": ["ip_002", "ip_001"], "response_length": ["vb_002", "vb_001"], "correction_style": ["ec_001", "ec_002"], "math_approach": ["ms_002"], "comment_style": ["cs_004", "cs_005"], "format_structure": ["rf_002", "rf_001"], "proof_style": ["ms_005"], "naming_convention": ["cs_001", "cs_003", "cs_002"], "example_position": ["ds_004", "ds_003"], "review_scope": ["cs_006", "cs_007"], "math_detail": ["ms_001", "ms_004"], "guidance_style": ["ip_003", "ip_004"], "code_presentation": ["oa_001", "oa_002"] B.2 Revealed Preferences and Per-User Metrics During the 20-session run used in our main experiments, the user simulator explicitly revealed a subset of the ground-truth preferences for user_14b429db. The table below summarizes the 10 revealed preferences for this user. ID When Then cs_008 providing error handling examples always use specific exception types, never bare except ds_001 discussing ML concepts include mathematical formulation alongside intuitive explanation ds_006 writing documentation be concise, avoid marketing language, focus on usage vb_002 complex algorithms/mathematics provide detailed step-by-step derivation with intermediate results ms_002 discussing statistics/probability start with intuition and real-world interpretation before formulas rf_003 providing a final answer put the answer first, then explanation ip_002 clear and specific instruction execute directly without asking for confirmation vb_004 debugging “it doesn’t work” focus on diagnosing specific issue, skip general explanations ip_001 complex multi-part task confirm plan before executing, break into phases ec_001 minor terminology error correct gently inline without making it a focus Table 7: Revealed preferences for user_14b429db during the 20-session MultiSessionCollab run. In this particular run, user_14b429db had 20 sessions, with a task success rate of 65% (13/20 successful conversations) and a total of 48 explicit enforcement turns from the user simulator. Appendix C Offline Style-Persona Experiments Before the MultiSessionCollab benchmark was released in Jan.6.2026, we conducted a set of offline style-persona experiments in a simplified, rule-based simulation environment. The goal was to isolate the effects of preference memory and online user vectors on cross-session style adherence, using easy tasks and discrete style preferences. C.1 Environment and personas The environment consists of synthetic users endowed with latent style preferences over four dimensions: response length, bullet usage, and language (English vs. Chinese). Each user is assigned to one of several personas such as A_short_bullets_en, B_short_no_bullets_en, C_long_bullets_en, D_short_bullets_zh, and E_long_no_bullets_zh, which specify a ground-truth StylePrefs tuple (require_short,max_chars,require_bullets,lang)( require\_short, max\_chars, require\_bullets, lang). For each persona we script multiple sessions with three phases: (i) a preference-reveal session where the user explicitly states length, bullet, and language preferences; (i) a cross-session retention session where the user only issues tasks without restating preferences; and (i) mixed sessions where the user sometimes restates preferences or complains when they are violated, providing additional feedback. Tasks are simple list and QA prompts (e.g., “List three healthy breakfast ideas.”, “What is the capital of France?”) instantiated in the persona’s preferred language. We consider three system modes: VANILLA (no preference memory), STATIC-MEM (preference memory without user vectors), and ONLINE-USER (preference memory plus online user vectors). All share the same frozen chat, embedding, and reranker models; only the external memory and user vectors differ. C.2 Metrics We evaluate personalization with the same style-oriented metrics as in the main text: turn-level satisfaction scores, violation rates for different error types (e.g., too_long, no_bullets, wrong_lang), and Recall@k of relevant preference memories. Formally, for Session 2 we compute AvgSatS2=1|TS2base|∑t∈TS2basest,AvgSatS2= 1|T^base_S2| _t∈ T^base_S2s_t, and for each violation type v ViolRateS2(v)=#t∈TS2base:v∈Violt|TS2base|,ViolRateS2(v)= \#\t∈ T^base_S2:v _t\|T^base_S2|, where sts_t is the rule-based satisfaction score and VioltViol_t are violation labels at turn t. Memory Recall@k is defined as the fraction of turns where at least one selected memory card encodes the relevant preference. C.3 Results with three-session lifetimes Table 8 reports Session 2 results for ONLINE-USER and the VANILLA baseline under a strict retention setting where complaint turns are disabled. ONLINE-USER achieves substantially higher satisfaction and lower violation rates, and retrieves relevant preference memories almost perfectly. Metric ONLINE-USER VANILLA AvgSatS2 0.95000.9500 0.72500.7250 ViolRateS2(too_long) 0.16670.1667 0.41670.4167 ViolRateS2(no_bullets) 0.00000.0000 0.50000.5000 Recall@k_S2(SHORT) 0.66670.6667 0.00000.0000 Recall@k_S2(BULLETS) 0.83330.8333 0.00000.0000 Recall@k_S2(LANG) 1.00001.0000 0.00000.0000 Table 8: Offline Session 2 results (no complaints, 6 personas). ONLINE-USER substantially improves satisfaction and reduces violations compared to a VANILLA LLM without preference memory. C.4 Longer lifetimes and user-vector alignment We also extend the simulation to ten sessions per persona (with complaint turns enabled) and again compare ONLINE-USER to VANILLA. Table 9 shows that the gains persist under longer lifetimes: ONLINE-USER maintains higher satisfaction and lower violation rates, while consistently retrieving the relevant preference memories.: Metric ONLINE-USER VANILLA AvgSatS2 0.97500.9750 0.86250.8625 ViolRateS2(too_long) 0.08330.0833 0.16670.1667 ViolRateS2(no_bullets) 0.00000.0000 0.29170.2917 Recall@k_S2(SHORT) 0.66670.6667 0.00000.0000 Recall@k_S2(BULLETS) 0.79170.7917 0.00000.0000 Recall@k_S2(LANG) 1.00001.0000 0.00000.0000 Table 9: Offline Session 2 results with longer lifetimes (10 sessions per user). ONLINE-USER continues to outperform VANILLA in satisfaction, violation rates, and preference-memory recall. Finally, we probe whether the learned user vectors capture meaningful structure by correlating cosine similarity between long-term user vectors with the ground-truth overlap of style preferences across personas. In a dedicated experiment with six synthetic personas and about 270 turns of interaction per persona, we observe a positive Spearman correlation of ρ≈0.27ρ≈ 0.27 between learned similarities and preference-overlap similarities, despite the short histories and highly saturated satisfaction scores. Appendix D Hyperparameters and Implementation Details This appendix summarizes the main hyperparameters and implementation choices for user-vector learning, preference-aware scoring, and retrieval. All experiments in Section 5 use the actual values listed below. D.1 Core REINFORCE Update Parameters The user-vector updates in Section 3.6 follow the REINFORCE-style rule ΔU(L) ^(L)_U =ηLAtretrτ(chosen,t−t), = _L A^retr_tτ (v_chosen,t- μ_t ), ΔU,t(S) ^(S)_U,t =ηSAtretrτ(chosen,t−t), = _S A^retr_tτ (v_chosen,t- μ_t ), with short-term decay U,t+1(S)=(1−λ)U,t(S)+ΔU,t(S),z^(S)_U,t+1=(1-λ)\,z^(S)_U,t+ ^(S)_U,t, and a per-user exponential moving average baseline bU←(1−α)bU+αr^t.b_U←(1-α)\,b_U+α\, r_t. Table 10 lists the corresponding hyperparameters. Setting ηL=1.0×10−2 _L=1.0× 10^-2: LR for long-term vector U(L)z^(L)_U ηS=5.0×10−2 _S=5.0× 10^-2: LR for short-term vector U,t(S)z^(S)_U,t λ=0.1λ=0.1: Exponential decay for U,t(S)z^(S)_U,t between turns α=0.05α=0.05: EMA coefficient for reward baseline bUb_U τ=1.0τ=1.0: Policy temperature in the softmax over memories Table 10: Core REINFORCE update parameters. All experiments use the code values. D.2 User-Vector Weighting and Item Space The effective user vector used in the user-aware scoring function (Section 3.5) is U,teff=βLU(L)+βSU,t(S),z^eff_U,t= _L\,z^(L)_U+ _S\,z^(S)_U,t, where βL _L and βS _S control the relative weight of long- and short-term preferences. Item vectors mv_m are obtained by projecting embedding vectors m∈ℝde_m ^d into a global k-dimensional PCA space (Section 3.4). The values used in our experiments are summarized in Table 11. Setting βL=2.0 _L=2.0: Weight of long-term vector in U,teffz^eff_U,t βS=5.0 _S=5.0: Weight of short-term vector in U,teffz^eff_U,t k (item_dim) =256=256: Dimensionality of item and user vectors Table 11: User-vector weighting and item-space dimension. D.3 Retrieval Parameters Dense retrieval returns a candidate set MtM_t of size K=dense_topkK= dense\_topk, and the reranker then selects the top rerank_topk memories (under the user-aware score s(⋅)s(·)) to inject into the LLM prompt. The values are: Setting dense_topk =64=64: Number of candidates from dense retrieval rerank_topk =3=3: Final memories fed to the LLM Table 12: Retrieval parameters used in our RAG and VARS implementations. D.4 Reward Gating Logic The reward model C outputs a scalar reward r^t r_t and a gating scalar gt∈[0,1]g_t∈[0,1] (Section 3.6). The gate controls how much of the reward is attributed to the retrieval policy versus other factors (e.g., the backbone LLM or topic shifts). In code, we implement a small set of hand-crafted gating rules based on the reward sign and a similarity signal between the chosen memories and the query: Case Condition gtg_t Retrieval failure r^t<−0.5 r_t<-0.5, low similarity 0.90.9 LLM failure r^t<−0.5 r_t<-0.5, high similarity 0.20.2 Good + retrieval helped r^t>0.5 r_t>0.5, similarity >0.4>0.4 0.60.6 Good + no retrieval help r^t>0.5 r_t>0.5, similarity ≤0.4≤ 0.4 0.30.3 Default neutral / other cases 0.50.5 Table 13: Gating cases for the retrieval-specific advantage Atretr=gt(r^t−bU)A^retr_t=g_t( r_t-b_U). “Similarity” refers to the similarity between chosen memories and the current query; in the “Good” cases we use a numerical threshold of 0.40.4. These rules are intentionally simple and were chosen heuristically: they are meant to (i) emphasize retrieval failures when the reward is strongly negative and the retrieved memories are a poor match, (i) down-weight updates when failures are likely due to the LLM rather than retrieval (negative reward but high similarity), and (i) give somewhat larger credit to retrieval when positive rewards co-occur with high memory–query similarity. As discussed in Section 6, a more systematic exploration of gating and reward design is an important direction for future work. Appendix E Theoretical Motivation and Exact Decomposition of the User-State Updates This appendix formalizes two exact properties of the update rule in Section 3.6. First, conditional on the retrieved candidate set, the implemented updates are gradient steps on a fixed-candidate surrogate objective. Second, the dual-vector recursion admits an exact two-timescale decomposition: the long-term state accumulates all past update increments, while the short-term state is an exponentially decaying sum of recent increments. These statements are about the surrogate induced by the observed retrieved set and the heuristic attribution weight AtretrA_t^retr; they are not claims that the full end-to-end retrieval-and-generation pipeline is an unbiased policy-gradient estimator. For notational simplicity, we suppress the user index when it is clear from context. E.1 Proposition 1: Fixed-Candidate Surrogate Gradient At turn t, let Mt=m1,…,mKM_t=\m_1,…,m_K\ denote the retrieved memory candidate set, and let At⊆MtA_t M_t denote the subset of memories actually injected into the prompt. Let the effective user state be zteff=βLzt(L)+βSzt(S).z_t^eff= _Lz_t^(L)+ _Sz_t^(S). (6) Define the user-aware score st(m;z)=s~(ut,m)+⟨z,vm⟩,s_t(m;z)= s(u_t,m)+ z,v_m , (7) where s~(ut,m) s(u_t,m) collects all score terms that are independent of the user state. The fixed-candidate retrieval policy is πz(m∣ut,Mt)=exp(st(m;z)/τ)∑j:mj∈Mtexp(st(mj;z)/τ). _z(m u_t,M_t)= (s_t(m;z)/τ) _j:m_j∈ M_t (s_t(m_j;z)/τ). (8) For the observed selected set AtA_t, define the surrogate objective t(z)=Atretr⋅1|At|∑m∈Atlogπz(m∣ut,Mt).J_t(z)=A_t^retr· 1|A_t| _m∈ A_t _z(m u_t,M_t). (9) Also define vchosen,t v_chosen,t =1|At|∑m∈Atvm, = 1|A_t| _m∈ A_tv_m, (10) μt(z) _t(z) =∑m∈Mtπz(m∣ut,Mt)vm. = _m∈ M_t _z(m u_t,M_t)\,v_m. Proposition 1. For any fixed candidate set MtM_t and observed selected set AtA_t, ∇zt(z)=Atretrτ(vchosen,t−μt(z)). _zJ_t(z)= A_t^retrτ (v_chosen,t- _t(z) ). (11) Consequently, evaluated at z=zteffz=z_t^eff, the implemented updates in Section 3.6 satisfy Δzt(L) z_t^(L) =ηLβL∇z(L)t(zteff), = _L _L\, _z^(L)J_t\! (z_t^eff ), (12) Δzt(S) z_t^(S) =ηSβS∇z(S)t(zteff). = _S _S\, _z^(S)J_t\! (z_t^eff ). whenever βL,βS>0 _L, _S>0. Equivalently, after absorbing the fixed factors βL,βS _L, _S into the learning rates, both implemented updates are exact gradient-ascent steps on the surrogate objective in the effective-state parameterization. Proof. For any m∈Mtm∈ M_t, ∇zlogπz(m∣ut,Mt) _z _z(m u_t,M_t) (13) =∇z[1τ⟨z,vm⟩−log∑j:mj∈Mtexp(st(mj;z)/τ)] = _z\! [ 1τ z,v_m - _j:m_j∈ M_t \! (s_t(m_j;z)/τ ) ] =1τ(vm−∑j:mj∈Mtπz(mj∣ut,Mt)vmj) = 1τ (v_m- _j:m_j∈ M_t _z(m_j u_t,M_t)\,v_m_j ) =1τ(vm−μt(z)). = 1τ (v_m- _t(z) ). Averaging over m∈Atm∈ A_t and multiplying by AtretrA_t^retr gives ∇zt(z) _zJ_t(z) =Atretrτ(1|At|∑m∈Atvm−μt(z)) = A_t^retrτ ( 1|A_t| _m∈ A_tv_m- _t(z) ) (14) =Atretrτ(vchosen,t−μt(z)). = A_t^retrτ (v_chosen,t- _t(z) ). (15) Finally, since zteff=βLzt(L)+βSzt(S),z_t^eff= _Lz_t^(L)+ _Sz_t^(S), (16) the chain rule yields ∇z(L)t(zteff)=βL∇zt(zteff), _z^(L)J_t(z_t^eff)= _L _zJ_t(z_t^eff), (17) ∇z(S)t(zteff)=βS∇zt(zteff). _z^(S)J_t(z_t^eff)= _S _zJ_t(z_t^eff). which implies the stated identities. □ Scope. Proposition 1 is a statement about the fixed-candidate surrogate induced by the observed candidate set MtM_t, the observed selected set AtA_t, and the scalar weight AtretrA_t^retr. It does not claim that the full retrieval pipeline with Top-J truncation and heuristic attribution is an unbiased policy-gradient estimator. E.2 Proposition 2: Exact Two-Timescale Decomposition Recall the update rules from Section 3.6: zt+1(L) z_t+1^(L) =zt(L)+Δzt(L), =z_t^(L)+ z_t^(L), (18) zt+1(S) z_t+1^(S) =(1−λ)zt(S)+Δzt(S), =(1-λ)z_t^(S)+ z_t^(S), 0 0 <λ≤1. <λ≤ 1. For a given session, assume the short-term state is initialized as z1(S)=0.z_1^(S)=0. (19) Proposition 2. For all t≥2t≥ 2, the long-term and short-term states admit the exact unrolled forms zt(L)=z1(L)+∑i=1t−1Δzi(L),z_t^(L)=z_1^(L)+ _i=1^t-1 z_i^(L), (20) zt(S)=∑i=1t−1(1−λ)t−1−iΔzi(S).z_t^(S)= _i=1^t-1(1-λ)^\,t-1-i z_i^(S). (21) Therefore, the effective user state can be written exactly as zteff z_t^eff =βLz1(L)+βL∑i=1t−1Δzi(L) = _Lz_1^(L)+ _L _i=1^t-1 z_i^(L) (22) +βS∑i=1t−1(1−λ)t−1−iΔzi(S). + _S _i=1^t-1(1-λ)^\,t-1-i z_i^(S). If, in addition, ‖Δzi(S)‖≤G\| z_i^(S)\|≤ G for all i, then for any H≥0H≥ 0, the contribution of short-term updates older than H turns is bounded by ‖∑i=1t−1−H(1−λ)t−1−iΔzi(S)‖≤G(1−λ)Hλ. \| _i=1^t-1-H(1-λ)^\,t-1-i z_i^(S) \|≤ G(1-λ)^Hλ. (23) Proof. The expression for zt(L)z_t^(L) follows immediately by recursively expanding zt+1(L)=zt(L)+Δzt(L).z_t+1^(L)=z_t^(L)+ z_t^(L). (24) Similarly, repeatedly unrolling zt+1(S)=(1−λ)zt(S)+Δzt(S)z_t+1^(S)=(1-λ)z_t^(S)+ z_t^(S) (25) and using z1(S)=0z_1^(S)=0 gives zt(S)=∑i=1t−1(1−λ)t−1−iΔzi(S).z_t^(S)= _i=1^t-1(1-λ)^\,t-1-i z_i^(S). (26) Substituting these two identities into zteff=βLzt(L)+βSzt(S)z_t^eff= _Lz_t^(L)+ _Sz_t^(S) (27) yields the exact decomposition of the effective state. For the tail bound, apply the triangle inequality: ‖∑i=1t−1−H(1−λ)t−1−iΔzi(S)‖ \| _i=1^t-1-H(1-λ)^t-1-i z_i^(S) \| (28) ≤∑i=1t−1−H(1−λ)t−1−i‖Δzi(S)‖ ≤ _i=1^t-1-H(1-λ)^t-1-i\| z_i^(S)\| (29) ≤G∑j=H∞(1−λ)j ≤ G _j=H^∞(1-λ)^j (30) =G(1−λ)Hλ. = G(1-λ)^Hλ. (31) Interpretation. Proposition 2 shows that the two state variables operate on different time scales. The long-term state is a persistent accumulator of past update increments, so signal that repeatedly appears across turns can be retained indefinitely. In contrast, the short-term state is an exponentially weighted sum of recent increments, with effective memory horizon on the order of 1/λ1/λ. Thus, the dual-vector parameterization separates persistent cross-turn signal from transient local context, without requiring stronger assumptions such as convexity, concavity, or dynamic-regret optimality. Appendix F System Mode Descriptions We compare six system modes under the same frozen-backbone, no-additional-training setting (rows in Table 1): • Vanilla: No preference extraction or preference memory. The agent conditions only on the current session history. • Contextual: The full conversation history is appended to the prompt, but no structured preference memory or learned user state is maintained. • All-memory: Preference extraction is enabled, but all extracted preference notes are appended to the prompt at each turn, without retrieval or user-specific selection. • Reflection: After each session, the agent generates a reflection summary that is appended to future prompts, requiring one additional LLM pass per session. • RAG: Preference cards are constructed, retrieved by dense search, reranked, and injected into the prompt. No learned user state is used; retrieval depends only on query–memory relevance. • VARS: Our full method. This mode uses the same preference-memory pipeline as RAG, but augments retrieval with the learned user state (zU(L),zU,t(S))(z_U^(L),z_U,t^(S)) described in Section 3.5, updated online from weak feedback as in Section 3.6. For each system mode, we evaluate the same 6060 user profiles over the same 6060 sessions and task sequences. Appendix G Qualitative Failure Modes We observe three recurring failure modes for our RAG-based methods, particularly as the preference memory grows over sessions: 1. Over-cautious clarification. The agent asks clarification questions instead of solving the task when many conflicting preferences are retrieved. 2. Preference overload. The agent attempts to satisfy all injected preferences simultaneously, producing verbose or unfocused responses. 3. Early user disengagement. The simulator terminates the session when initial responses are weak, preventing recovery in subsequent turns. These failure modes are more pronounced for RAG (44.3%44.3\% timeout) than VARS (26.4%26.4\%), suggesting the user vector mitigates preference overload by biasing retrieval toward preferences that have historically led to positive feedback. Appendix H Query Transformation for Dense Retrieval Dense retrieval faces a semantic gap between task-oriented queries (e.g., “solve this integral”) and preference descriptions (e.g., “when solving math problems, show step-by-step work”). To reduce this mismatch, we apply a lightweight keyword-based transformation. Given utu_t, we detect a task type (e.g., math, coding, writing, explanation) using curated keyword lists and, when matched, form a supplementary retrieval query ut′u _t by prepending a task-specific prefix such as "user preferences for coding: " to the original query. We embed both utu_t and ut′u _t, and for each memory card use the maximum cosine similarity across the two query embeddings during dense retrieval. The top-K candidates by this score are passed to the reranker, which uses only the original query utu_t. This heuristic is intended to improve recall of task-conditioned preferences without an additional LLM call. Appendix I Reward and Gating Sensitivity Analysis Using the interaction logs from the ablation experiments (Section 5.2), we re-run user-vector updates under perturbed reward and gating configurations to assess sensitivity. For each configuration, we report the final long-term vector ℓ2 _2 norm (averaged over users), the percentage change relative to the baseline, and the cosine similarity between the perturbed and baseline long-term vectors. Reward perturbations. Table 14 shows that the learned vectors are robust to moderate reward perturbations: removing half of the negative keywords or shifting the topic-coherence dampening threshold has no effect (cosine similarity =1.0=1.0). Larger perturbations—adding noisy negative keywords or tightening the reward clip range—change both vector magnitude and direction, indicating that keyword quality matters but the signal is stable under small noise. Config ‖z(L)‖\|z^(L)\| Δ% \% cos to base Baseline 0.288 — 1.000 Half neg keywords 0.288 0% 1.000 Noisy neg keywords 0.603 +109% 0.184 Clip [−0.5,0.5][-0.5,0.5] 0.374 +30% 0.490 Dampen thresh 0.10.1 0.288 0% 1.000 Dampen thresh 0.30.3 0.288 0% 1.000 Table 14: Reward sensitivity. Baseline uses the default keyword list and clip range [−1,1][-1,1] with dampening threshold 0.20.2. Gating perturbations. Table 15 shows that the retrieval-attribution gate is critical for stable vector learning. Removing gating entirely (gt=1.0g_t=1.0) causes 454%454\% vector norm inflation and severe directional drift (cos=0.41 =0.41), confirming that ungated reward noise propagates into the user state. A uniform gate (gt=0.5g_t=0.5) partially mitigates this but still inflates vectors by 168%168\%. In contrast, shifting the similarity thresholds used in the gating logic has no effect, indicating that the gating mechanism is robust to threshold choice within a reasonable range. Table 15: Gating sensitivity. Baseline uses the heuristic gating with similarity thresholds (0.2,0.5)(0.2,0.5). Config ‖z(L)‖\|z^(L)\| Δ% \% cos to base Fixed g=0.5g=0.5 0.771 +168% 0.444 Fixed g=1.0g=1.0 1.593 +454% 0.410 Thresh (0.1,0.4)(0.1,0.4) 0.288 0% 1.000 Thresh (0.3,0.6)(0.3,0.6) 0.288 0% 1.000 Appendix J Memory Card Schema and Example Each memory card stored in the preference memory has the following fields: ⬇ "id": "8475ca85-...", "note": "When presenting calculations, omit extra phrases and show only the essential steps.", "condition": "presenting calculations", "action": "omit extra phrases, show essential steps", "is_global": false, "embedding": "[4096-dim dense vector from f_emb]", "item_vec": "[256-dim PCA projection v_m]" The condition and action fields are produced by the preference extractor MextM_ext (Section 3.3). The note field is a natural-language summary used as input to the reranker MrerankM_rerank. The is_global flag determines whether the preference bypasses retrieval and is injected directly into the prompt (Section 3.4). The embedding and item_vec fields are computed from the source user query as described in Section 3.4.