EvoMemState: Evolving Memory State for Personal Agents

Introduction

Large language model (LLM) agents are increasingly used as personal agents that assist users over extended periods, requiring continuity across interactions and adaptation to evolving needs ([15, 10] (Westhäußer et al. 2025; Zhang et al. 2025b)). Long-term memory supports this continuity by preserving user preferences, experiences, circumstances, and constraints across sessions ([21, 7, 26] (Yang et al. 2026a)). This accumulated context provides a foundation for consistent and personalized assistance over time (Wang et al., 2026b; Zhang et al., 2026b).

Recent work has explored how to construct and maintain long-term personal memory from interaction histories. MemoryBank (Zhong et al., 2024) summarizes user experiences for subsequent retrieval, while MemGPT ([27]) manages memory across storage tiers. LightMem ([9]) improves efficiency through compression and selective retrieval. Other systems emphasize memory organization and maintenance: Mem0 ([5]) extracts and updates atomic facts, A-MEM (Xu et al., 2026) dynamically associates related memories, and Supermemory ([34]) and SimpleMem ([23]) support continual updates and memory lifecycle management. Together, these approaches enable personal agents to retain and access information across interactions through memory extraction, organization, updating, and retrieval.

Despite this progress, existing memory systems largely follow a fact-centric paradigm, focusing on the storage, updating, and retrieval of factual records. However, the validity and scope of a stored fact may change as related memories accumulate, while its appropriate use depends on the current request. Associating records or revising their contents alone may not adequately capture these dependencies. When memories are maintained or retrieved separately, conflicts between them may be overlooked, leaving individually accurate records without the context needed for correct interpretation. Even when all relevant memories are retrieved, the personal agent must still determine their applicability and priority for the current request and may rely on outdated information or mishandle conflicts. These limitations motivate a state-centric paradigm that augments stored facts with evolving memory states. A memory state describes the status of stored facts and their roles in an interaction, which cannot be determined from factual content alone and must be considered in relation to other memories and the current request. Such states make the validity, scope, and relations of facts explicit and guide how retrieved memories should be used for the current request.

Augmenting personal memory with explicit states presents two challenges: (i) It is challenging to construct and maintain coherent memory states. Personal information accumulates across conversations as scattered and inconsistent observations. Simply collecting these observations leaves their relations implicit, while merging them into a summary may lose historical information and hide conflicts between records. The challenge is to organize related facts and maintain their validity, scope, and relations as new information arrives, while preserving the original records. (ii) It is challenging to learn memory-use strategies from experience. The same memory can serve different purposes across requests, so its validity and relations alone do not determine how it should affect the agent’s behavior. This requires learning when memories should inform, constrain, or have no bearing on that behavior, using feedback from memory use to refine these judgments.

To address these challenges, we introduce EvoMemState, a state-centric framework for maintaining and using long-term personal memory. First, Ontology-Guided Memory State Induction extracts Persistent Facts from personal interactions and incrementally organizes them into a personal memory ontology. It preserves the original facts while maintaining their validity, scope, and evolving relations as Relational States. Second, RL-Based State Evolution internalizes memory-use experience into a policy through reinforcement learning. The learned policy generates a request-specific Reasoning State that specifies the applicability, role, and priority of relevant facts. Third, State-Aware Reasoning combines the relevant Relational States with the generated Reasoning State to guide the personal agent’s response. Together, these components connect fragmented facts through Relational States and combine them with a request-specific Reasoning State, enabling personal agents to interpret and use memory appropriately. Our contributions are summarized as follows:

• We identify the limitations of fact-centric personal memory: individually maintained facts may lack the relational context needed for interpretation, and complete retrieval does not ensure appropriate memory use.

• We introduce EvoMemState, a state-centric long-term memory framework representing personal memory through Persistent Facts, Relational States, and Reasoning State. It realizes this formulation through Ontology-Guided Memory State Induction, RL-Based State Evolution, and State-Aware Reasoning.

• We evaluate EvoMemState on long-term dialogue and memory-use benchmarks, demonstrating consistent improvements over existing memory systems in retrieval completeness and memory-grounded response accuracy.

Preliminary Studies

In this section, we conduct two preliminary studies on the Valid Memory Selection subset of MemSyco-Bench (Xiang et al., 2026a), where correct answers require jointly considering memories linked by updates, conflicts, or constraints. Our findings reveal two limitations: related memories are not consistently retrieved together, leaving individual facts without the context needed for correct interpretation; and even when all relevant memories are retrieved, personal agents may misjudge their applicability, roles, and priorities for the current request. A detailed case analysis is provided in Appendix § 11.5.

Do Fact-Centric Systems Capture Relations among Memories?

To examine whether fact-centric memory systems capture relations among memories, we evaluate five systems. As shown in Figure 2, MemoryBank, LightMem, and Supermemory do not retrieve all relevant information in 58.9%, 61.8%, and 58.0% of cases, respectively. For four of the five systems, answer accuracy is 5.9–33.3% higher when all required memories are retrieved than when some are missing. These findings motivate explicit modeling of memory relations, so that individual facts can be interpreted alongside the information affecting their validity and scope.

Can Personal Agents Use Fully Retrieved Memories Appropriately?

To examine whether personal agents use memories appropriately when all relevant memories are available, we compare direct reasoning with a fixed self-reflection that asks the agent to reconsider memories before responding. As shown in Figure 3, self-reflection reduces accuracy for most systems, with the largest drop of 1.6% on Mem0, and lowers average accuracy from 50.5% to 48.9%. These results show that access to all relevant memories does not ensure appropriate use, and the fixed reflection prompt offers no consistent improvement. This motivates learning memory-use strategies from experience to determine how memories should be

applied and prioritized for each request.

Method

As illustrated in Figure 4, EvoMemState organizes personal memory around Persistent Facts and two complementary states. Ontology-Guided Memory State Induction extracts Persistent Facts from accumulated personal information and constructs Relational States that track their validity, scope, and evolving relations. RL-Based State Evolution learns a Memory State Evolution Policy that generates a request-specific Reasoning State from relevant memory evidence. State-Aware Reasoning then combines the Relational States and Reasoning State to guide the personal agent.

System Concepts

Let $\mathcal{F}_t = \{f_i\}_{i=1}^{N_t}$ denote the Persistent Facts accumulated through turn $t$, and let $q_t$ denote the current request. We characterize personal memory using two complementary states; the complete formulation is provided in Appendix § 11.§ 1.

related, while the Reasoning State determines how they should be used for the current request.

Ontology-Guided State Induction

Persistent Facts alone are insufficient to construct a memory state because their current meaning depends on their validity, scope, and relations to other facts. Therefore, we construct a personal memory ontology incrementally and induce Relational States from its evolving structure. Persistent Facts retain the original information, while their Relational States are updated as new facts are added. The resulting ontology and Relational States form the persistent personal memory.

Iterative ontology construction. Given the conversations accumulated through turn $t$, denoted by $\mathcal{H}_t$, we extract a time-ordered set of Persistent Facts:

Each $f_i$ contains a single proposition about a user preference, experience, belief, circumstance, or constraint, together with its source and time. Starting from an empty ontology $\mathcal{G}^{(0)}$, we incorporate each fact in temporal order:

where

Here, $\mathcal{V}_{C}^{(i)}$ and $\mathcal{V}_{F}^{(i)}$ denote the concept and fact nodes after incorporating $f_i$. The structural edges $\mathcal{E}_{H}^{(i)}$ use PARENT_OF to organize concept nodes hierarchically and CONTAINS to attach each fact to its most specific concept. The CREATE, MERGE, and SPLIT operations revise the concept hierarchy as new facts are added. The relation edges $\mathcal{E}_{R}^{(i)}$ use SUPERSEDES to represent updates and CONFLICTS_WITH to preserve unresolved conflicts.

Ontology-induced Relational States. The Relational State of each fact is derived from its current attributes and ontology relations. After incorporating the first $i$ facts, we define

where $a_f^{(i)}$ describes the current validity and scope of $f$, and $\rho_f^{(i)}$ contains its concept attachment and relations to other facts. Later facts may update these attributes and relations without overwriting $f$. After all facts have been incorporated, we obtain

The Persistent Facts $F_t$ and Relational States $R_t$ are retained as personal memory and provide the persistent inputs for inferring a Reasoning State for each new user request.

RL-Based State Evolution

Relational States capture how facts currently hold and relate, but do not specify how a personal agent should use them for a particular request. We therefore treat state evolution as the internalization of reusable memory-use experience and instantiate the state inference function $\Psi$ with a Memory State Evolution Policy $\pi_\theta$. Given request $q$, relevant Persistent Facts $F_q$, and their Relational States $R_q$, the policy generates a Reasoning State:

We train $\pi_\theta$ by repeatedly generating and evaluating candidate Reasoning States, allowing the policy to learn reusable patterns of memory use.

Evaluating candidate Reasoning States. A Reasoning State is useful only if it helps the personal agent use the given memory evidence correctly. Let

denote the relevant memory evidence for request $q$. Given a candidate Reasoning State $Z_q^{(i)}$, we evaluate its effect on a frozen personal agent $\mathcal{A}$ relative to a baseline that receives the same memory evidence without a Reasoning State:

where $y^*$ is the reference answer and Score is the task-specific evaluator. A positive reward indicates that the candidate improves how the personal agent uses the fixed memory evidence, whereas a negative reward penalizes candidates that distort or weaken that evidence.

Learning the state evolution policy. We optimize $\pi_\theta$ using GRPO [32]. For each training instance $(q,M_q,y^*)$, we sample $G$ candidate Reasoning States from the previous policy:

Their relative rewards are normalized within the group to obtain advantages $\hat{A}_i$, which guide the policy update:

Here, $T_i$ is the length of candidate $Z_q^{(i)}$, $\rho_{i,j}$ is the token-level probability ratio between $\pi_\theta$ and $\pi_{\theta_{\mathrm{old}}}$, $\epsilon$ is the clipping threshold, and $\beta_{\mathrm{KL}}$ controls regularization toward the reference policy $\pi_{\mathrm{ref}}$. Through repeated optimization, $\pi_\theta$ internalizes memory-use patterns that generalize to new facts and requests. Training details are provided in Appendix B.3.

State-Aware Reasoning

At inference, State-Aware Reasoning retrieves the Persistent Facts and Relational States required by the current request, generates a Reasoning State, and grounds the personal agent in both states. Given a request $q$, we retrieve $K$ semantically similar Persistent Facts as seeds. Because a seed may be updated, constrained, or contradicted by other facts, we expand it by traversing the stored memory relations in both directions:

Here, $\operatorname{Traverse}(f,R_t)$ includes $f$ and all facts connected to it through memory relations. Facts reached from multiple seeds are included only once. We denote the Relational States corresponding to $F_q$ as $\widetilde{R}_q$.

The learned policy generates a Reasoning State from the request, retrieved facts, and their Relational States. The personal agent then produces its response using both states:

Together, relation traversal preserves the context needed to interpret the retrieved facts, while the Reasoning State specifies how the personal agent should use them for the current request.

Experiment

In this section, we evaluate how EvoMemState constructs and applies memory states through the following four research questions. Q1 (Main Results): How does EvoMemState compare with existing memory systems? Q2 (Memory State Effectiveness): How effectively do the relational state and reasoning state support reliable memory use? Q3 (Reasoning State Generalization): How well does reasoning state generation transfer across tasks and memory systems? Q4 (Ablation Study): How does each component affect overall performance? Appendix C provides a case study and efficiency analysis.

Experimental Setup

Datasets. We evaluate on four benchmarks covering memory use in personal agents and long term conversational memory. MemSyco-Bench (Xiang et al., 2026a) and MemTrapBench (Wang et al., 2026a) assess personal agents’ use of historical memories, including preference updates, evidence priority, and effects on reasoning. LoCoMo (Maharana et al., [25]) and LoCoMo-Refined³ evaluate recall and reasoning across dialogue sessions. Dataset details appear in Appendix D.2.

Baselines. We compare EvoMemState with nine baselines covering retrieval, persistent memory, and structured memory organization: NaiveRAG (Lewis et al., [19]), MemGPT (Packer et al., [27]), MemoryBank (Zhong et al., 2024), Mem0 (Chhikara et al., [5]), LightMem (Fang et al., [9]), A-MEM (Xu et al., 2026), Supermemory (Supermemory AI, [34]), SimpleMem (Liu et al., [23]), and PGMem (Choi et al., [6]). Details are provided in Appendix D.3.

Evaluation Metrics. We evaluate answer quality, memory use, and retrieval completeness. Answer quality is measured by accuracy, F1, and Mem-TrapBench judge scores. Following MemSyco-Bench (Xiang et al., 2026a), we use Syco. Rate to measure inappropriate reliance on historical memories and Correct Use to measure valid personalization. Retrieval is evaluated by Complete Retrieval Rate and answer accuracy on complete-retrieval cases (Acc@complete). Full definitions are provided in Appendix D.4.

Implementation Details. We use DeepSeek-V4-Flash for offline memory construction and Qwen3-8B (Yang et al., 2025) and GPT-4o-mini as online response models. By default, the Memory State Evolution Policy is initialized from Qwen3-4B-Instruct-2507 (Yang et al., 2025) and trained with GRPO (Shao et al., [32]). Dataset construction, training details, and prompts are provided in Appendices § 13.§ 2, § 11.§ 3, and § 14.

Main Results (Q1)

We compare EvoMemState with memory systems using Qwen3-8B and GPT-4o-mini. Table 1 reports results on MemSyco-Bench and MemTrapBench for memory use, and on LoCoMo and LoCoMo-Refined for long-term memory reasoning.

Memory System	MemSyco-Bench WTU Acc. ↑	MemSyco-Bench WTU Syco. ↓	MemSyco-Bench HTU Acc. ↑	MemSyco-Bench HTU Use ↑	MemSyco-Bench Avg. ↑	MemTrapBench Safety Score ↑	MemTrapBench CogBias Acc. ↑	MemTrapBench Bound. Acc. ↑	MemTrapBench Trauma Acc. ↑	MemTrapBench Avg. ↑	LoCoMo-Refined Judge Score ↑	LoCoMo-Refined Token F1 ↑	LoCoMo Judge Score ↑	LoCoMo Token F1 ↑	Overall Avg. ↑
Qwen3-8B
NaiveRAG (Lewis et al., [19])	36.3	55.3	51.6	64.0	42.4	60.2	63.9	77.0	93.4	73.6	39.0	38.4	34.4	35.8	47.4
MemGPT (Packer et al., [27])	29.0	66.7	54.0	67.0	39.0	62.2	66.0	64.5	52.4	61.3	45.7	40.0	36.8	37.0	45.7
MemoryBank (Zhong et al., 2024)	37.5	57.6	54.4	67.1	44.2	64.9	63.7	72.1	82.3	70.7	44.9	44.0	39.9	41.0	49.9
Mem0 (Chhikara et al., [5])	25.9	47.8	52.0	63.8	36.3	56.8	69.3	81.9	85.5	73.4	25.7	26.9	21.4	23.8	39.2
A-MEM (Xu et al., 2026)	42.8	49.1	49.2	61.2	45.4	64.2	65.0	77.6	91.8	74.6	41.8	39.1	36.4	37.1	49.6
LightMem (Fang et al., [9])	21.0	49.6	46.1	58.7	31.0	68.6	69.9	88.6	91.6	79.7	25.3	27.2	22.1	24.0	39.5
Supermemory (Supermemory AI, [34])	23.3	70.5	63.7	74.2	39.5	67.5	65.4	79.6	61.7	68.6	16.6	17.5	15.7	15.8	35.1
SimpleMem (Liu et al., [23])	33.4	58.6	44.1	52.6	37.7	70.9	68.3	84.6	95.8	79.9	51.3	46.6	45.3	46.4	53.6
PGMem (Choi et al., [6])	33.2	62.8	54.5	69.1	41.8	71.0	66.4	85.1	75.6	74.5	28.5	26.9	25.4	25.2	42.6
EvoMemState (Ours)	47.7	38.0	72.4	81.3	57.6	73.8	62.3	88.8	91.4	79.1	57.4	47.3	45.5	41.6	59.9
GPT-4o-mini
NaiveRAG (Lewis et al., [19])	48.3	42.8	49.2	61.1	48.7	61.7	58.6	65.0	97.4	70.7	43.2	39.1	34.4	36.9	49.3
MemGPT (Packer et al., [27])	40.8	48.0	56.2	66.0	46.9	66.4	60.7	69.9	62.3	64.8	49.1	39.5	40.2	39.1	50.3
MemoryBank (Zhong et al., 2024)	48.9	42.2	48.3	62.3	48.7	66.4	59.8	73.4	90.5	72.5	52.8	46.6	42.7	45.3	54.2
Mem0 (Chhikara et al., [5])	32.7	38.4	50.3	63.3	39.7	56.4	61.7	74.1	93.5	71.4	28.9	27.2	21.6	25.2	40.4
A-MEM (Xu et al., 2026)	54.5	35.7	50.9	63.1	53.0	63.1	59.6	69.3	95.8	71.9	49.1	42.7	39.4	41.9	53.4
LightMem (Fang et al., [9])	25.0	42.9	46.9	60.4	33.8	70.2	63.8	80.8	95.2	77.5	24.2	26.9	21.8	25.1	39.3
Supermemory (Supermemory AI, [34])	35.0	56.3	52.9	65.9	42.2	67.4	58.8	74.2	76.4	69.2	15.8	16.0	14.9	14.8	35.5
SimpleMem (Liu et al., [23])	25.0	63.2	47.6	60.7	34.0	69.7	64.6	72.7	97.3	76.1	53.8	48.0	47.2	48.4	52.8
PGMem (Choi et al., [6])	39.6	54.4	53.7	66.3	45.2	73.9	60.9	81.1	83.1	74.7	19.8	18.9	16.7	17.6	39.1
EvoMemState (Ours)	53.1	31.9	67.6	80.1	58.9	73.9	73.9	88.8	90.4	78.7	60.8	48.5	46.4	45.2	61.2

Obs.1. EvoMemState improves when and how memory is used. On MemSyco-Bench, EvoMemState achieves accuracies of 57.6% and 58.9% with Qwen3-8B and GPT-4o-mini, outperforming the strongest baselines by 12.2% and 5.9%, respectively. It achieves the best When to Use and How to Use accuracy, the lowest Syco. Rate, and the highest Correct Use with Qwen3-8B. These results show more reliable decisions about whether and how history should affect the current response.

Obs.2. EvoMemState supports long-term recall and task-appropriate reasoning. On LoCoMo-Refined, EvoMemState achieves the highest LLM-judge and token F1 scores with both models, outperforming the strongest baseline in judge score by 6.1% and 7.0%. It also achieves the best Safety and Task Boundary scores on MemTrapBench, showing that factual records support recall while reasoning states prevent irrelevant history and prior task rules from overriding the current request.

Memory-State Effectiveness (Q2)

To assess the two memory states, we examine whether the Relational State assembles complete evidence and whether the Reasoning State uses it correctly. Figure 5 reports Complete Retrieval Rate and Acc@complete on LoCoMo-Refined and MemSyco-Bench with Qwen3-8B; the metrics are considered jointly because complete-evidence subsets differ across systems.

Obs.3. The Relational State connects related memories into reliable evidence. EvoMemState achieves a complete retrieval rate of 85.6%, comparable to the best baseline. Guided by the personal memory ontology, its Relational State preserves each fact’s current attributes together with related updates, conflicts, and constraints. This organization allows related memories to provide complete evidence rather than remain independent records.

Obs.4. The Reasoning State supports reliable use of complete evidence. Acc@complete reaches 70.8% on LoCoMo-Refined and 68.5% on MemSyco-Bench, exceeding the strongest baselines by 11.5% and 31.2%, respectively. These gains show that evidence completeness alone does not ensure correct use. By internalizing memory-use experience, the learned policy generates a Reasoning State that makes the applicability, role, and priority of each memory explicit, helping the response model apply the assembled evidence appropriately and consistently.

Reasoning-State Generalization (Q3)

To evaluate whether reasoning-state generation generalizes across tasks and memory systems, we pair the Memory State Evolution Policy with different memory systems on the benchmarks. Figure 6 reports cross-system performance changes, while Appendix § 12.§ 1 compares alternative reasoning-state strategies across memory-use categories.

Obs.5. Reasoning states transfer across memory systems. All six baselines improve when augmented with generated reasoning states, with overall gains ranging from 0.2% to 4.9%. NaiveRAG and MemoryBank benefit most, improving by 4.9% and 4.8%, followed by A-MEM at 3.4%. These results show that the policy can produce useful reasoning states from evidence supplied by different memory systems.

Ablation Study (Q4)

To examine the contribution of state composition and learned memory use (Q4), Table 2 compares three variants with Qwen3-8B. w/o Relational State uses retrieved seed records without incorporating related updates and conflicts into the state evidence. w/o Reasoning State provides the personal agent with state evidence but omits the policy-generated reasoning state. w/o RL-Based State Evolution retains reasoning-state generation but uses the policy before RL training.

Method	MemSyco Avg.	LoCoMo-R LLM-J.	LoCoMo LLM-J.	MemTrap Avg.	Overall
EvoMemState (Ours)	57.6	57.4	45.5	79.1	59.9
w/o Relational State	48.7	54.9	45.2	72.7	55.4
w/o Reasoning State	49.6	55.8	42.5	64.1	53.0
w/o RL-Based State Evolution	49.7	55.4	45.0	62.7	53.2

Obs.6. Composing related records strengthens state evidence. Removing relational state reduces MemSyco-Bench and the MemTrapBench score by 8.9% and 6.4%, respectively. The losses on LoCoMo-Refined and LoCoMo are smaller, at 2.5% and 0.3%. These larger losses on memory-use tasks suggest that related updates and conflicts are particularly valuable for interpreting retrieved records before applying them to the response.

Obs.7. RL-based state evolution improves reasoning states. Removing dynamic rules reduces MemSyco-Bench accuracy and the MemTrapBench score by 8.0% and 15.0%, respectively. Retaining rule generation without RL yields similar losses of 7.9% and 16.4%. Thus, generating rules alone provides little benefit on these benchmarks. These results support learning from memory application experience: answer-quality feedback helps the policy determine memory applicability, role, and priority, expressed as dynamic rules for each new user request.

Related Work

Personal Agents and User Modeling

Personal agents use persistent user information to adapt across interactions ([21]).

Related Work

Long-Term Memory Systems

Long-term memory systems preserve information beyond the active context for later use ([26] (Xiao et al. 2026)). MemGPT ([27]) manages information across storage tiers, MemoryBank (Zhong et al., 2024) maintains personal records, LightMem ([9]) uses compression and selective retrieval, and Mem0 ([5]) extracts and updates facts. A-MEM (Xu et al., 2026), Supermemory ([34]), and SimpleMem ([23]) further organize memories through links, temporal structure ([30]), and update mechanisms.

LaMP ([31]) retrieves relevant profile items for personalized generation, while HELLO and related methods maintain and update user representations over time ([20, 35, 18]). PGMem ([6]) links persona information to events that support or revise it. Recent work further extends personalization to Web actions and agent retraining ([2, 33]). Together, these studies cover persistent personalization across generation, user representation, and agent behavior.

Conclusion

In this paper, we presented EvoMemState, a state-centric long-term memory framework for personal agents that constructs coherent Relation States from multi-source memories and learns from continual memory use to generate Reasoning States. Experiments across memory-use and dialogue-recall benchmarks show consistent improvements, particularly under preference updates and conflicting evidence, demonstrating that reliable personal memory requires both coherent state construction and use-driven state evolution.

Limitation

Our study focuses on text-based interaction histories. Real-world personal memory systems must also handle multimodal information, including documents, images, and other user artifacts. Extending our memory structure to represent, connect, and apply information across modalities remains an important direction for future work.

Use of Large Language Models

During manuscript preparation, we used large language models to refine the English text, correct grammatical errors, and improve clarity and readability. We also used them to assist with table formatting. The authors reviewed and revised all suggestions to ensure that they preserved the intended scientific content and retain full responsibility for the accuracy and integrity of the final manuscript.

Frequently Asked Questions (FAQs)

What are the main advantages of EvoMemState?

EvoMemState differs from conventional memory systems in how it maintains and uses personal information. Rather than storing facts independently, it organizes them within an ontology that tracks changes in validity, scope, and relations. This allows earlier records to remain accessible even when newer information supersedes or contradicts them.

The framework also separates memory storage from memory use. A learned policy generates a Reasoning State for each request, indicating which memories are relevant and how they should influence the response. The policy is trained using feedback from downstream answers, rather than relying on predefined rules or repeated self-reflection. The Reasoning State is provided as natural-language guidance and can be used with different response models without modifying their parameters.

A coherent and evolving memory state. The personal memory ontology organizes Persistent Facts and maintains their validity, scope, and relations as new interactions arrive. Original facts remain traceable, while relation-aware retrieval recovers the connected information needed for their interpretation.

Use-driven state evolution. For each request, a Reasoning State specifies the applicability, role, and priority of memory evidence. The Memory State Evolution Policy learns from whether candidate states improve the personal agent’s answers, allowing experience from prior memory use to guide future requests.

Compatibility with different personal agents. Reasoning States are expressed in natural language and provided alongside the relevant facts and relations. They can therefore guide different personal-agent backbones without modifying their parameters.

Why use a personal memory ontology instead of independent records?

Independent memory records can preserve individual observations, but they provide limited information about how those observations relate over time. For example, a newly stated preference may replace an earlier one, while two conflicting records may need to remain unresolved until further evidence becomes available.

EvoMemState uses an ontology to represent these relationships explicitly. Facts are grouped under concepts and linked through typed relations, allowing retrieval to include not only a relevant record but also the information needed to interpret it. The original records are retained, so historical questions can still be answered after a preference or circumstance changes.

Connecting facts across interactions. The concept hierarchy organizes facts by topic, while their attributes and relations record changes in validity and scope. Earlier facts remain traceable even when they are superseded or conflict with later information.

Recovering complete evidence. Semantic retrieval may identify an individually relevant fact while omitting the related facts needed to interpret it. Starting from retrieved facts, EvoMemState traverses their stored relations to recover connected updates, conflicts, and constraints, providing the complete context required by the current request.

Why are Reasoning States needed, and how do they differ from summaries?

Relation States describe whether facts remain valid and how they are related, but do not determine how they should affect a particular request. A Reasoning State makes the applicability, role, and priority of memory evidence explicit for the current interaction. Using the same fact in different contexts. A knee injury may answer a factual question, constrain an activity recommendation, or be irrelevant to another request. Similarly, a superseded preference may be irrelevant to a current decision but necessary for answering a historical question. The Reasoning State distinguishes these uses according to the request.

From memory content to response guidance. A Reasoning State is intended to guide the use of retrieved memories, rather than summarize their content. The distinction matters because the same fact can serve different purposes depending on the request.

Consider a user who previously mentioned a knee injury. The information is relevant when the user asks for exercise recommendations, but it may have no bearing on a question about travel expenses. Similarly, an outdated preference should not determine a current recommendation, although it remains useful when answering questions about the user’s past interests.

The Reasoning State captures these request-dependent distinctions. It is generated from the retrieved facts and their relations, while the original evidence remains available to the response model.

Why use a separate policy model instead of agent self-reflection to generate Reasoning States?

Self-reflection requires the personal agent to determine how memory should be used anew for each request, without retaining successful decisions from previous uses. In contrast, the Memory State Evolution Policy is trained offline by repeatedly generating and evaluating candidate Reasoning States, thereby internalizing memory-use patterns that improve downstream responses. At inference, it directly provides the personal agent with a ready-to-use Reasoning State, avoiding repeated execution or iterative reflection for each request. This separates the accumulation of memory-use experience from response generation and makes that experience reusable across requests and personal agents.

How is the Memory State Evolution Policy trained and evaluated?

The policy is trained according to how much its Reasoning States improve the personal agent’s answers. Evaluation separately measures whether the system retrieves complete evidence and whether the personal agent uses that evidence correctly.

Learning from memory-use experience. Given a request, relevant Persistent Facts, and their Relation States, the policy samples a group of candidate Reasoning States. Each candidate is applied by a frozen personal agent under the same request and memory evidence, together with a baseline that uses the evidence directly. The resulting performance difference serves as feedback on the candidate’s memory-use decisions and defines the reward in Equation (10). GRPO optimizes the policy using relative feedback within each group. Across repeated memory-use episodes, the policy internalizes reusable patterns for determining the applicability, role, and priority of memory evidence. Only the policy is updated, allowing this experience to guide the personal agent without modifying its parameters.

Separating evidence retrieval from evidence use. Complete Retrieval Rate measures how often the retrieved context contains all required evidence, while Acc@Complete measures answer accuracy on those cases. Figure 5 reports both metrics on LoCoMo-Refined and MemSyco-Bench, distinguishing errors caused by missing evidence from those caused by incorrect evidence use. Table 2 further compares variants without Reasoning States or RL-based policy training. Together, these evaluations assess both the complete system and the contribution of learned state evolution.

Method Details

This section provides additional details for the three stages introduced in § 3. We first present the complete formulation of Persistent Facts, Relational States, and Reasoning States. We then describe Ontology-Guided Memory State Induction, RL-Based State Evolution, and State-Aware Reasoning in the same order as the main text. Algorithm 1 summarizes memory construction, policy optimization, and inference.

System Concepts

Let $\mathcal{H}_t = \{h_1,\ldots,h_t\}$ denote the conversations accumulated through turn $t$, and let $q_t$ denote the current request.

Algorithm 1 Complete Workflow of EvoMemState

Require: Dialogue history $\mathcal{H}_t$, ontology-backed training data $\mathcal{D} = \{(q_j,\mathcal{G}_j,y_j^*)\}$, Memory State Evolution Policy $\pi_\theta$, frozen personal agent $\mathcal{A}$, request $q$, seed count $K$, group size $G$

Ensure: Personal memory ontology $\mathcal{G}_t$, Persistent Facts $\mathcal{F}_t$, Relational States $\mathcal{R}_t$, trained policy $\pi_\theta$, answer $y$

Phase 1: Ontology-Guided Memory State Induction

Explanation

1: $\mathcal{F}_t = \{f_1,\ldots,f_{N_t}\} \leftarrow\operatorname{ExtractTimeOrderedRecords}(\mathcal{H}_t)$ ▷ Extract time-ordered Persistent Facts 2: $\mathcal{G}^{(0)} \leftarrow\operatorname{InitializeGraph}()$ ▷ Initialize the personal memory ontology 3: for $i=1,\ldots,N_t$ do ▷ Incorporate each Persistent Fact 4: $\mathcal{G}^{(i)} \leftarrow\operatorname{Induce}(\mathcal{G}^{(i-1)},f_i)$ ▷ Update concepts, attributes, relations 5: end for ▷ Finish ontology induction 6: $\mathcal{G}_t \leftarrow\mathcal{G}^{(N_t)}$ ▷ Retain the induced ontology 7: $\mathcal{R}_t \leftarrow\{(f,a_f^{(N_t)},\rho_f^{(N_t)}):f\in\mathcal{V}_{\mathcal{F}}^{(N_t)}\}$ ▷ Collect the Relational States

Phase 2: RL-Based State Evolution

8: for each policy optimization step do ▷ Optimize the state evolution policy 9: $(q_j,\mathcal{G}_j,y_j^*)\sim\mathcal{D}$ ▷ Sample a training ontology and request 10: $\pi_{\theta_{\mathrm{old}}}\leftarrow\pi_\theta$ ▷ Save the rollout policy snapshot 11: $\mathcal{M}_j=(\mathcal{F}_j,\mathcal{R}_j)\leftarrow\operatorname{AssembleEvidence}(q_j,\mathcal{G}_j,K)$ ▷ Retrieve facts and Relational States 12: $y_j^0\leftarrow\mathcal{A}(q_j,\mathcal{M}_j)$ ▷ Answer without a Reasoning State 13: $\{ \mathcal{Z}_j^{(i)}\}_{i=1}^{G}\sim\pi_{\theta_{\mathrm{old}}}(\cdot\mid q_j,\mathcal{F}_j,\mathcal{R}_j)$ ▷ Sample candidate Reasoning States 14: for $i=1,\ldots,G$ do ▷ Evaluate each candidate Reasoning State 15: $y_j^{(i)}\leftarrow\mathcal{A}(q_j,\mathcal{M}_j,\mathcal{Z}_j^{(i)})$ ▷ Answer using the Reasoning State 16: $R_i\leftarrow\operatorname{Score}(y_j^{(i)},y_j^*)-\operatorname{Score}(y_j^0,y_j^*)$ ▷ Measure gain over the baseline 17: $\widetilde{R}_i\leftarrow\operatorname{ApplyGatesAndPenalties}(R_i,\mathcal{Z}_j^{(i)})$ ▷ Check format and answer disclosure 18: end for ▷ Finish candidate evaluation 19: $\widehat{A}_{1:G}\leftarrow\operatorname{NormalizeWithinGroup}(\widetilde{R}_{1:G})$ ▷ Compute group-relative advantages 20: $\pi_\theta\leftarrow\operatorname{GRPOUpdate}(\pi_\theta,\pi_{\theta_{\mathrm{old}}},\{(\mathcal{Z}_j^{(i)},\widehat{A}_i)\}_{i=1}^{G})$ ▷ Update the policy with GRPO 21: end for ▷ Finish policy optimization

Phase 3: State-Aware Reasoning

22: $(\mathcal{F}_q,\widetilde{\mathcal{R}}_q)\leftarrow\operatorname{AssembleEvidence}(q,\mathcal{G}_t,K)$ ▷ Retrieve facts and Relational States 23: $\mathcal{Z}_q\leftarrow\pi_\theta(q,\mathcal{F}_q,\widetilde{\mathcal{R}}_q)$ ▷ Generate the Reasoning State 24: $\mathcal{S}_t(q)\leftarrow(\mathcal{R}_t,\mathcal{Z}_q)$ ▷ Form the Memory State 25: $y\leftarrow\mathcal{A}(q,\mathcal{F}_q,\widetilde{\mathcal{R}}_q,\mathcal{Z}_q)$ ▷ Answer using facts and both states 26: return $\mathcal{G}_t,\mathcal{F}_t,\mathcal{R}_t,\pi_\theta,y$ ▷ Return personal memory, policy, answer

constraints. Each fact retains its source, time, and evidence span. Later interactions do not overwrite these facts, but may update their associated states.

Definition 2 (Relational States). Each fact $f_i$ is associated with a Relation State:

where $a_i^t$ specifies the current validity and scope of $f_i$, and $\rho_i^t$ records how it updates, conflicts with, or constrains other facts. The collection $\mathcal{R}_t$ forms the Relational States retained with personal memory. These states persist across requests and evolve when new conversations update the memory.

Definition 3 (Reasoning State). For request $q_t$, the Reasoning State is inferred jointly from the request, Persistent Facts, and their Relational States:

where $\mathcal{Z}_{q_t}$ specifies the applicability, role, and priority of memory evidence. The state inference function $\Psi$ may be implemented by the personal agent or a separate model. In EvoMemState, it is instantiated by the Memory State Evolution Policy $\pi_\theta$.

Definition 4 (Memory State). The Memory State for request $q_t$ combines the persistent Relational States with the request-specific Reasoning State:

Persistent Facts specify what the memory contains, Relational States indicate whether these facts remain valid and how they are related, and the Reasoning State determines how they should be used for the current request.

Ontology-Guided Memory State Induction

Memory construction proceeds incrementally as new dialogue sessions become available. For each session, the extractor receives the dialogue and a relevant branch of the existing ontology. It identifies atomic facts and proposes changes to the concept hierarchy and memory relations.

Each extracted fact retains its source turn, evidence span, timestamp, and qualifiers. Changes in validity or scope are recorded in its Relational State, leaving the original fact unchanged. Figure 7 illustrates the ontology operations used during this process.

Session-level fact extraction. For each new dialogue session, the extractor receives the session together with a relevant local ontology branch containing related concepts, neighboring hierarchy nodes, representative facts, and their incident relations. It produces a time-ordered set of Persistent Facts and proposes the corresponding concept and relation updates. Each fact contains a single proposition and retains its record type, source turn, evidence span, explicit time, and qualifiers. Its current validity and scope are maintained in the associated Relation State rather than encoded by overwriting the fact.

Ontology construction and validation. Starting from an empty ontology $\mathcal{G}^{(0)}$, facts are incorporated in temporal order:

where

Here, $\mathcal{V}_{C}^{(i)}$ and $\mathcal{V}_{F}^{(i)}$ denote concept and fact nodes. Structural edges $\mathcal{E}_{H}^{(i)}$ use PARENT_OF to form the concept hierarchy and CONTAINS to attach each fact to its most specific concept. The operations CREATE, MERGE, and SPLIT revise the hierarchy while preserving one parent for each nonroot concept and one concept assignment for each fact.

Validation ensures that extracted facts are grounded in the dialogue and that proposed edits preserve graph consistency. A SUPERSEDES edge connects a replacement fact to an earlier version and marks the earlier fact as superseded. A CONFLICTS_WITH edge preserves unresolved inconsistencies and marks active endpoints as disputed. Relation endpoints must refer to compatible information types, and update relations must remain acyclic. Each session-level update is committed only after its facts, concepts, and relations pass validation.

Relational State induction. After incorporating the first $i$ facts, their Relational States are

where $a_f^{(i)}$ records the current validity and scope of $f$, and $\rho_f^{(i)}$ contains its concept attachment and relations to other facts. New facts may revise these attributes and relations without overwriting the underlying fact. After all facts have been incorporated,

The resulting Persistent Facts $\mathcal{F}_t$ and Relational States $\mathcal{R}_t$ form the persistent personal memory.

RL-Based State Evolution

Relational States describe how facts currently hold and relate, but do not specify how they should be used for a particular request. EvoMemState instantiates the state inference function $\Psi$ with a Memory State Evolution Policy $\pi_\theta$, which internalizes reusable memory-use experience through repeated generation and evaluation of candidate Reasoning States.

Reasoning State interface. For a request $q$, the policy receives the relevant Persistent Facts $\mathcal{F}_q$ and their Relational States $\mathcal{R}_q$:

The input includes the facts, their validity and scope, temporal information, and relation annotations. The generated Reasoning State specifies which evidence applies, the role it should play, and how it should be prioritized. It is supplied alongside the original memory evidence so that the personal agent retains access to the facts supporting the guidance.

Learning from memory-use experience. For each training instance, the policy samples $G$ candidate Reasoning States:

Each candidate is applied by a frozen personal agent under the same request and memory evidence. A shared baseline uses the same evidence without a Reasoning State. Their performance difference provides feedback on the candidate’s memory-use decisions and defines the reward in (10). Format validation and penalties for revealing the reference answer further constrain the reward.

GRPO ([32]) normalizes rewards within each sampled group and optimizes the clipped objective in Equation 12. Only $\pi_\theta$ is updated; memory construction, retrieval, scoring, and the personal agent remain fixed. For each training instance, the policy samples multiple candidate Reasoning States. Each candidate is evaluated using the same request and memory evidence, with the response model kept frozen. The reward is calculated as the difference between the answer score obtained with the candidate state and the score obtained without it.

Candidates are also checked for formatting violations and reference-answer disclosure. GRPO then updates the policy using rewards normalized within each group. The memory construction pipeline, retrieval procedure, and response model remain fixed throughout training.

The resulting policy is used to generate Reasoning States at inference time.

State-Aware Reasoning

At inference, State-Aware Reasoning retrieves the Persistent Facts and Relational States required by the current request, generates a Reasoning State, and grounds the personal agent in both states.

Seed retrieval and relation traversal. Given request $q$, embedding similarity retrieves $\mathcal{K}$ Persistent Facts as seeds. Because a seed may have been updated, contradicted, or constrained by other facts, relation traversal expands the initial set:

Traversal follows stored memory relations in both directions until all connected facts have been collected. Earlier facts, replacements, and conflicting counterparts are retained with their original relation types and directions. Facts reached from multiple seeds are included only once, while isolated seeds remain individual facts.

Relational State assembly. The Relational States associated with the retrieved facts are

Connected facts retain their validity, scope, provenance, temporal information, and relation annotations. No additional filtering is applied after traversal. The seed count $K$ controls the initial retrieval set, while the final context size depends on the relations connecting those seeds to other facts.

Reasoning and response generation. The learned policy generates a Reasoning State from the request, retrieved facts, and their Relational States. The personal agent then produces its response using the same memory evidence and the generated state:

Relation traversal preserves the context needed to interpret the retrieved facts, while the Reasoning State specifies how the personal agent should use them for the current request.

Overall procedure. Algorithm 1 provides the full training and inference workflow. During inference, the system retrieves relevant facts, expands the evidence through stored relations, and generates a Reasoning State before passing the assembled context to the response model.

Preliminary Case Analysis

Connecting related memories into reliable evidence. The upper panel of Figure 8 shows three memories accumulated over time. The user historically enjoyed hiking ($M1$), later developed a preference for beach trips ($M2$), and is currently recovering from a knee injury ($M3$). A fact-centric system may retrieve only $M1$ because hiking is semantically relevant to a vacation request. However, $M1$ cannot be interpreted correctly in isolation: $M2$ updates the user’s current preference, while $M3$ introduces a constraint against strenuous activities. Omitting either memory prevents the system from reconstructing the current memory state and may lead it to recommend an outdated and physically unsuitable hiking trip. This case illustrates that individually relevant facts do not necessarily form reliable evidence; their updates and constraints must be considered together.

Determining how memory evidence should be used. The lower panel assumes that all three memories are available when the user asks for a vacation recommendation. Complete evidence, however, does not by itself determine the response. For this

request, $M1$ should be treated as historical information, $M2$ as the current preference, and $M3$ as a constraint that excludes strenuous activities. A suitable response should therefore prioritize a low-intensity beach trip. Nevertheless, a personal agent may overemphasize the historically salient hiking preference and recommend a mountain hiking trip despite having access to the complete evidence. The same historical preference could be relevant to a question about the user’s past activities, but should not guide the current recommendation. This is therefore a memory-use failure rather than a retrieval failure, showing that the applicability, role, and priority of each memory must be determined for the current request.

Additional Experiments

We compare memory use strategies and guidance sources, examine representative responses, and analyze retrieval cost and quality. Additional experiments characterize the stored memory structure and the use of complete retrieved evidence. Together, these results examine how the Relational State supports memory access and the Reasoning State guides memory application.

Comparison of Memory Use Strategies

To compare memory application strategies, we augment Mem0, which extracts and consolidates personal facts, with Self-Recheck, MemGate, Dynamic Partition, or our generated Reasoning States. MemGate filters memory representations according to the query (Zhang et al. (2026a)), while Dynamic Partition organizes memories into inferred categories at inference time (Hannoon et al. (2026)). Table 3 reports results on MemSyco-Bench, LoCoMo-Refined, and MemTrapBench, with our Reasoning States, expressed as dynamic memory rules, denoted by Dynamic Rules (Ours).

Method	MemSyco-Bench Scope Acc. ↑	MemSyco-Bench Objective Acc. ↑	MemSyco-Bench Personalized Acc. ↑	MemSyco-Bench Preference Change Acc. ↑	MemSyco-Bench Preference Conflict Acc. ↑	LoCoMo-Refined LLM-Judge Score ↑	LoCoMo-Refined Token F1 ↑	MemTrapBench Safety Acc. ↑	MemTrapBench Cognitive Bias Acc. ↑	MemTrapBench Task Boundary Acc. ↑	MemTrapBench Trauma Acc. ↑	MemTrapBench Avg. ↑
Mem0	14.3	34.7	<u>57.7</u>	54.5	22.3	25.7	26.9	56.8	<u>69.3</u>	81.9	85.5	73.4
+ Self-Recheck (Hu et al. [14])	13.0	43.3	60.5	<u>64.7</u>	<u>25.0</u>	23.4	12.6	75.1	55.5	76.4	94.6	<u>75.4</u>
+ MemGate (Zhang et al. (2026a))	13.7	<u>39.0</u>	51.0	51.2	23.7	24.2	11.4	54.6	40.9	<u>78.7</u>	93.5	66.9
+ Dynamic Partition (Hannoon et al. (2026))	11.7	<u>39.0</u>	<u>56.5</u>	53.8	8.7	20.8	10.6	69.2	44.6	<u>78.4</u>	93.1	71.3
+ Reasoning State (Ours)	11.0	39.3	48.8	72.7	42.0	<u>23.9</u>	<u>24.9</u>	61.1	72.3	81.9	<u>93.8</u>	77.3

The learned rules are most effective when the response requires revising the influence of prior information. They achieve 72.7% accuracy on preference changes and 42.0% on preference conflicts, exceeding the strongest alternatives by 8.0% and 17.0%. On MemTrapBench, they obtain the highest average score of 77.3. Cognitive Bias accuracy reaches 72.3%, exceeding Mem0’s 69.3% by 3.0%, while Task Boundary accuracy matches Mem0 at 81.9%. These scenarios require deciding whether an earlier preference, strategy, or task rule still applies. Dynamic rules express these decisions through temporal validity, scope, and priority, allowing the agent to use personal history while adapting its response to the current request.

MemGate and Dynamic Partition do not improve Task Boundary accuracy over Mem0, scoring 78.7% and 78.4%, respectively, compared with Mem0’s 81.9%. Their effects on preference updates and conflicts are also mixed. MemGate lowers preference change accuracy from 54.5% to 51.2%, while Dynamic Partition lowers preference conflict accuracy from 22.3% to 8.7%. These results suggest that filtering or grouping records alone does not reliably determine which information should govern the response. Our rules address this decision explicitly, with training feedback based on answer improvement. Self-Recheck leads on objective judgment, personalized recommendations, Safety, and Trauma, while Mem0 retains the best scope and LoCoMo-Refined results.

The clearest advantage of learned rules lies in handling changing preferences, conflicting information, and cognitive bias.

Guidance from the Answer Model

To compare learned memory-use guidance with guidance generated by the response model, we evaluate Self-Guide and Dynamic Rules under Qwen3-8B and GPT-4o-mini (Figure 9). Self-Guide uses the response model to generate guidance, whereas Dynamic Rules uses the trained Memory State Evolution Policy to generate a Reasoning State.

Dynamic Rules yields larger gains on memory-use benchmarks than on conversational recall. Relative to Self-Guide, it improves MemSyco-Bench accuracy by 8.2 percentage points with Qwen3-8B and 6.1 percentage points with GPT-4o-mini, with corresponding MemTrapBench score gains of 16.8 and 11.0 points. Improvements on LoCoMo are smaller, at 0.9 and 1.0 points, respectively. On LoCoMo-Refined, Dynamic Rules improves the Qwen3-8B score by 1.1 points but reduces the GPT-4o-mini score by 1.4 points. These results suggest that learned guidance is particularly useful for determining the applicability and priority of memories, while offering less consistent benefits for conversational recall.

Conversational recall primarily requires recovering and combining stored information. MemSyco-Bench and MemTrapBench also test whether historical information should influence the current response, particularly when preferences change or prior interactions introduce misleading assumptions. Unlike Self-Guide, the Memory State Evolution Policy is trained using feedback on the answers produced with its guidance. Candidate rules are evaluated against a baseline answer generated from the same records without rules, assessing whether applying, restricting, or prioritizing memories improves correctness. The larger gains on memory-use experience to determine the applicability, role, and priority of evidence.

Case Study

Figure 10 presents three examples from MemSyco-Bench, covering preference updates, evidence priority, and scope control. Each example includes the retrieved memories, the generated Reasoning State, and the final response. We examine whether the generated rules correctly distinguish outdated preferences from current ones, prioritize task-relevant evidence, and apply user information within its intended scope.

Following an updated preference. The user requests futuristic electronic sounds for a new track. The retrieved records connect this requirement to the earlier sample library through an update relation and distinguish music production from cultural interests through scope. The generated rule prioritizes the current production requirement and excludes the superseded library and unrelated cultural memories. The response recommends electronic sounds and tools, including FM8 and Splice. The example shows how an explicit update can change personalization for the current task while the earlier preference remains stored.

Prioritizing evidence for the requested task. The user asks which system to adopt for same-day summaries of multilingual customer interviews. The records distinguish the user’s inclination toward Atlas from a 2026 procurement assessment favoring Cygnus. The rule assigns priority to the procurement evidence, and the response recommends Cygnus. Here, the source of a record matters to its role in the decision. Preserving the distinction between personal inclination and task evidence allows the rule to specify their relative priority.

Applying preferences within their scope. The request refers to a previously discussed situation. The records identify family day planning and distinguish the preference for one coherent plan from broader habits of collecting examples and links. The rule applies the planning preference to the current decision, and the response organizes the activities into one plan with transport adapted to the group’s differing transit familiarity. Scope connects the remembered preference to the situation in which it should influence the answer.

Efficiency Analysis

To assess retrieval efficiency, Figure 11 relates evidence access to the average number of retrieved context tokens on LoCoMo-Refined. For $N$ questions, hit rate is $\frac{1}{N}\sum_{i=1}^{N}\mathbb{I}[n_i^{\mathrm{hit}} \ge1]$, where $n_i^{\mathrm{hit}}$ counts retrieved gold evidence items. A question counts as a hit when at least one gold item is retrieved, irrespective of how much other required evidence is missing. Context length measures the tokens supplied to the response model.

EvoMemState achieves the highest hit rate of 0.816 with an average context of 565 tokens. MemoryBank retains dialogue history and layered summaries, while A-MEM represents interactions as linked contextual notes. Both reach 0.789 with 816 and 1,440 tokens, respectively. Our context is 30.8% shorter than MemoryBank’s and 60.8% shorter than A-MEM’s, while recovering gold evidence for a larger proportion of questions. EvoMemState retrieves an average of 565 tokens per query, compared with 816 for MemoryBank and 1,440 for A-MEM. Despite the shorter context, its retrieval hit rate reaches 0.816, compared with 0.789 for both baselines.

One possible explanation is the difference in memory representation. MemoryBank and A-MEM retain more contextual information within individual records, whereas EvoMemState stores facts separately and connects them through explicit relations. This allows the system to retrieve related information without necessarily including the surrounding dialogue or longer memory notes.

LightMem, which compresses dialogue segments into summaries, and Mem0, which stores compact extracted memories, supply shorter contexts but attain hit rates of only 0.166 and 0.110. Their results illustrate the tension between reducing context length and maintaining access to evidence. The advantage of EvoMemState lies in its combination of compact records and access to associated information, yielding more frequent evidence hits at a lower context cost than the strongest retrieval baselines. Hit rate establishes whether retrieval finds an initial piece of evidence, while coverage and complete retrieval rate in Table 4 examine how much of the required set is recovered.

Method	Retrieval Hit Rate	Average Coverage	Complete Retrieval Rate
EvoMemState (Ours)	0.816	0.747	0.680
MemoryBank	0.789	0.727	0.669
A-MEM	0.789	0.724	0.662
NaiveRAG	0.684	0.615	0.564
MemGPT	0.453	0.384	0.323
LightMem	0.166	0.144	0.129
Mem0	0.110	0.095	0.086
Supermemory	0.006	0.004	0.003

Retrieval Quality

To distinguish partial evidence recovery from complete retrieval, Table 4 reports three metrics on LoCoMo-Refined. For question $i$, $n_i^{\mathrm{gold}}$ denotes the number of gold evidence items and $n_i^{\mathrm{hit}}$ the number retrieved. Hit rate, coverage, and complete retrieval rate average $\mathbb{I}[n_i^{\mathrm{hit}} \ge1]$, $n_i^{\mathrm{hit}}/n_i^{\mathrm{gold}}$, and $\mathbb{I}[n_i^{\mathrm{hit}} = n_i^{\mathrm{gold}}]$, respectively, across questions. Hit rate counts questions with any gold evidence, coverage measures the fraction recovered per question, and complete retrieval rate requires the entire gold set.

EvoMemState leads on all three metrics, with a hit rate of 0.816, coverage of 0.747, and complete retrieval rate of 0.680. MemoryBank, which retains history through layered summaries, and A-MEM, which stores linked contextual notes, achieve complete retrieval rate of 0.669 and 0.662. Their advantage over NaiveRAG’s 0.564 is consistent with the importance of preserving context beyond individual dialogue fragments. The ontology represents this context through atomic records, metadata, and explicit relations. Retrieval can therefore recover associated updates and conflicts even when those records are not among the initial similarity matches, supporting interpretation of the retrieved information.

Across systems, complete retrieval rate remains below hit rate. For EvoMemState, the difference is 13.6 percentage points, corresponding to questions where retrieval finds part of the gold evidence but omits the rest. An answer that depends on several dialogue turns may require details that are less similar to the query than the first retrieved record. Coverage quantifies these partial recoveries, while complete retrieval rate tests whether every required

item is available. Retrieving a relevant fact alone can therefore leave out the updates, conflicts, or constraints needed to interpret it.

Memory Structure Statistics

To characterize the granularity and organization of personal memory, Figure 12 reports statistics on MemSyco-Bench. The three panels show average record counts, average edge counts, and memory density, measured as records per thousand characters. Edge counts include concept and memory relations in our ontology and links among notes in A-MEM. Flat stores use record counts as an edge count proxy. Higher density indicates shorter records. Density is estimated from retrieved records and context length for NaiveRAG, Mem0, and LightMem, and computed directly from stored records for the remaining methods.

EvoMemState maintains an average of 22.1 records and 27.3 edges per store, with a record count comparable to Mem0’s 20.4 and LightMem’s 24.5. The ontology adds semantic organization

and temporal relations to these atomic records. A-MEM connects contextual notes through untyped links, while our relation types encode concept membership, hierarchy, and memory updates. These semantics support distinct operations on the same personal history, placing new records within the profile and linking revised information to its earlier versions. Preserving both versions makes changes in the user’s preferences explicit and leaves historical information available for later requests.

At 9.69 records per thousand characters, EvoMemState has a density close to the compact fact representations of Mem0 and Supermemory. Each record also retains an evidence quote, linking its concise statement to the source dialogue. A-MEM and MemoryBank store longer contextual notes and layered summaries, with densities of 1.50 and 0.83, respectively. Their context is carried largely within textual entries. Our ontology distributes this context across atomic records, source attributes, and explicit relations, allowing individual facts to remain concise while preserving how they should be interpreted together. EvoMemState stores an average of 22.1 memory records and 27.3 graph edges per instance. Its record count is close to that of Mem0 (20.4) and LightMem (24.5), although these systems differ in how they represent relationships between records.

The memory density of EvoMemState is 9.69 records per thousand characters, indicating relatively short factual entries. Unlike systems that store longer summaries, EvoMemState keeps source information and relationships separately from the factual statements. The reported density therefore describes the granularity of the stored records rather than the total amount of information maintained by the system.

Memory Application with Complete Evidence

To assess how Reasoning States support memory application when retrieval supplies all required evidence, we evaluate the Valid Memory Selection tasks of MemSyco-Bench. Figure 13 reports complete retrieval rate and compares Acc@complete under two conditions: w/ self-reflection, where the personal agent reflects on how to use the retrieved memories, and w/ reasoning state, where it uses an explicit Reasoning State to guide memory application. Complete retrieval rate gives the proportion of questions with all gold evidence retrieved, while Acc@complete measures answer accuracy on this subset for each system.

EvoMemState achieves a complete retrieval rate of 93.7%. Its Acc@complete increases from 75.4% with self-reflection to 86.7% with a Reasoning State, a gain of 11.3 percentage points. This improvement on questions with complete evidence suggests that retrieving the required records does not by itself ensure correct memory use. The agent must still resolve differences in temporal validity, scope, and evidence roles. The Reasoning State makes these application decisions explicit through dynamic rules, specifying how updates, constraints, and competing information affect the current request.

For the baselines, replacing self-reflection with a Reasoning State yields only small gains or decreases: +0.4 percentage points for LightMem, +0.1 for MemoryBank, -0.8 for A-MEM, -1.6 for Mem0, -0.1 for MemGPT, and -0.4 for Supermemory. Thus, an explicit Reasoning State alone does not consistently improve memory application. The larger gain for EvoMemState is consistent with the benefit of its Memory State Evolution Policy, which learns application decisions through downstream answer-quality feedback. These results suggest that effective memory use depends on the quality of the decisions encoded in the state, rather than merely adding an intermediate reflection or instruction step.

Implementation Details

This section describes the training data and evaluation setup for EvoMemState. We first explain how data instances are constructed to train the Memory State Evolution Policy, then introduce the benchmark datasets, baselines, and evaluation metrics used to assess memory recall and use in personal agents.

Training Data Construction

To train the Memory State Evolution Policy to generate a Reasoning State from a request and its relevant Relational State, we construct approximately 60K question–memory training instances from FEVER Thorne et al. (2018), SciFact Wadden et al. (2020), and PersonaMem Jiang et al. [17]. For objective questions, we convert the fact-verification tasks in FEVER and SciFact into question-answering instances with supporting evidence and reference answers. We then construct user memories that conflict with the objective evidence from the perspectives of personal belief, identity, and perceived expertise. For preference questions, we use the preference annotations in PersonaMem to construct scenarios involving current preferences, historical preferences, and preference updates, enabling the model to learn how different memories should influence a response.

To improve the difficulty and diversity of the training data, we further introduce distractor memories. For objective questions, bias-related memories are mixed with irrelevant everyday information. For preference questions, we add one or two genuine preferences from unrelated topics associated with the same user, including more challenging distractors drawn from the same conversational scenario but concerning a different topic. This design requires the model to identify relevant information based on memory content and applicability, rather than relying on superficial cues such as memory count, position, or fixed rule templates.

Benchmark Datasets

We evaluate EvoMemState on four complementary benchmarks covering personal memory recall and use. LoCoMo and LoCoMo-Refined assess recall and reasoning about personal information across dialogue sessions. MemSyco-Bench tests whether agents appropriately apply user preferences, respect their scope, and track updates. MemTrap-Bench examines whether past interactions bias reasoning on the current task.

MemSyco-Bench. MemSyco-Bench Xiang et al. (2026a) evaluates when and how agents should use user-specific memories in current responses. Personalized Memory Use and Valid Memory Selection test whether agents tailor recommendations to valid preferences and follow preference updates. Objective Fact Judgment, Contextual Scope Control, and Memory-Evidence Conflict test whether historical user beliefs or preferences improperly override facts, exceed their scope, or outweigh current evidence. Each instance introduces user information through a multi-turn dialogue, then tests its appropriate use in the final request. Together, these tasks assess personalization and memory-induced sycophancy in personal agents.

LoCoMo. LoCoMo Maharana et al. [25] evaluates recall and reasoning about speakers’ experiences, relationships, and life events across dialogue sessions. Conversations are generated by agents grounded in speaker personas and temporal event graphs, then verified and edited by human annotators for consistency. We use its question-answering task, which covers single-hop retrieval, multi-hop reasoning, temporal reasoning, open-domain knowledge, and adversarial questions. These categories test whether agents recover personal details, connect information across sessions, and recognize queries unsupported by the history.

LoCoMo-Refined. LoCoMo-Refined² recalibrates LoCoMo through corrected question-answer annotations and stricter answer evaluation. AI-assisted screening and human review revise ambiguous questions, reversed subject-object relations, and temporal inconsistencies with the source dialogues. The refined judge requires answers to cover the reference information, preserve temporal granularity, and avoid contradictions or unsupported additions. It provides a stricter assessment of factual and temporal accuracy when agents recall personal information from dialogue history.

MemTrapBench. MemTrapBench (Wang et al., 2026a) evaluates memory-induced cognitive traps through Reasoning Fixation and Belief Distortion. Reasoning Fixation comprises Task Boundary, Cognitive Bias, and Trauma, testing the persistence of prior task rules, overgeneralization of successful strategies, and avoidance induced by negative feedback. Belief Distortion uses Safety scenarios to test whether historical counterfactual premises override current safety judgments. Each final query is independently answerable, allowing comparison with generation without memory to measure the effect of historical context on current reasoning.

Baseline Details

We compare EvoMemState with nine baselines across different backbones. NaiveRAG retrieves directly from dialogue history, while Mem0, A-MEM, LightMem, MemGPT, MemoryBank, Supermemory, SimpleMem and PGMem maintain persistent memory through different extraction, organization, and update mechanisms. These baselines assess how memory representation and access affect personal agents’ responses. In this section, we provide detailed descriptions of each baseline used in our comparison, as detailed in Figure 14.

NaiveRAG. NaiveRAG [19] retrieves historical text by semantic similarity and supplies it alongside the current query. It evaluates response generation from relevant dialogue fragments without explicit memory construction or relation modeling.

Mem0. Mem0 [5] maintains salient facts through incremental extraction and consolidation. An LLM extracts candidate facts from new exchanges using recent dialogue and summary context, then compares them with similar stored memories to determine addition, update, deletion, or no change. Relevant facts are retrieved for subsequent queries.

A-MEM. A-MEM (Xu et al., 2026) represents interactions as linked notes inspired by the Zettelkasten method. Each note retains its content, timestamp, contextual description, keywords, and tags. New notes trigger link generation and revision of related notes’ contextual attributes, allowing the

NaiveRAG Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    vector_store: qdrant
}

Mem0 Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    llm_backend: openai-compatible
}

A-MEM Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    query_limit: 40,
    evo_threshold: 100
}

LightMem Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    extract_threshold: 0.1,
    pre_compress: true,
    topic_segment: true,
    text_summary: true,
    update: offline,
    update_topk: 20,
    update_keep_topn: 10,
    update_score_threshold: 0.8
}

MemoryBank Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    enable_summary: true
}

MemGPT Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    max_agent_steps: 12,
    ingest_batch_size: 6,
    archival_search_limit: 5
}

Supermemory Configuration

{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    retrieval_mode: profile,
    max_memories: 400,
    chunk_chars: 10000,
    chunk_max_memories: 48,
    extract_temperature: 0.2
}

memory structure to evolve across interactions. Embedding similarity identifies notes for the current query.

LightMem. LightMem [9] organizes memory processing into sensory, short-term, and long-term stages. Sensory processing compresses inputs and detects topic boundaries, and short-term processing summarizes coherent topic segments. Summaries enter long-term storage online, while sleep-time updates consolidate related entries offline, reducing the cost of memory maintenance during interaction.

MemGPT. MemGPT [27] manages a hierarchy of active context, external recall storage, and archival memory. The model uses function calls to edit working memory, search dialogue history, and bring stored information into context. Context-limit notifications and message summarization support extended interactions within a fixed context window.

MemoryBank. MemoryBank (Zhong et al., 2024) maintains timestamped conversations, hierarchical event summaries, and evolving user profiles. Dense retrieval provides relevant records and summaries for response generation. An Ebbinghaus-inspired retention mechanism adjusts memory strength according to elapsed time and reinforces memories when recalled.

Supermemory. Supermemory⁵ extracts atomic facts into a temporal memory graph with update, extension, and derivation relations. User profiles retain stable facts and recent context. Retrieval can return extracted memories, source document chunks, or both, providing personal information together with its source context.

SimpleMem. SimpleMem [23] compresses dialogue interactions into compact memory units with multiple retrieval indexes. It synthesizes related information within each session to reduce redundancy, then adapts retrieval scope to the intent of the current query. This design combines concise memory representations with query-dependent access to historical context.

SimpleMem Configuration
{
    embedding_model: bge-m3,
    retrieval_topk: 10,
    window_size: 40,
    overlap_size: 2,
    semantic_topk: 10,
    keyword_topk: 5,
    structured_topk: 5
}

PGMem Configuration
{
    embedding_model: bge-m3,
    embedding_dims: 1024,
    chunk_factor: 2,
    extraction_temperature: 0,
    k_context: 20,
    k_episode: 6,
    k_episode_final: 4,
    k_state: 17,
    k_trait: 6,
    k_aps: 6,
    k_trait_final: 5,
    k_state_final: 18
}

PGMem. PGMem ([6]) maintains a heterogeneous graph connecting event memories and persona signals through typed provenance and evidence relations. These links retain the events supporting or revising each persona signal. Retrieval expands from query-relevant seeds and ranks the resulting signals by evidential validity, coupling user-profile maintenance with memory access.

Evaluation Metrics

We evaluate answer quality, memory application, and retrieval completeness. Accuracy and token F1 assess the answers, while Sycophancy Rate and Correct Use assess how historical memories influence them. Complete retrieval rate measures how often all required evidence is retrieved, and Acc@complete evaluates answer accuracy on those questions. MemTrapBench additionally provides graded judge scores.

Accuracy (Acc). Accuracy evaluates whether a response satisfies the task’s correctness criteria, such as factual consistency, preference validity, and scope where applicable. Let $a_i \in\{0,1\}$ indicate whether the response to query $i$ is correct. Over $N$ queries, accuracy is defined as

For LLM-judge accuracy, correctness is assessed against the query and reference answer, following the use of LLMs for response evaluation ([24] (Zheng et al. 2023)).

Sycophancy Rate (Syco. Rate). Following MemSyco-Bench ((Xiang et al., 2026a)), Sycophancy Rate measures the proportion of responses that follow a misleading historical memory rather than the required facts, scope, or evidence. It applies to Objective Fact Judgment, Contextual Scope Control, and Memory-Evidence Conflict. Let $D_{\mathrm{syc}}$ denote the evaluated instances and $s_i \in\{0,1\}$ indicate whether response $i$ follows the specified misleading direction:

Lower values are better. This metric is distinct from error rate, since an incorrect answer need not follow the historical memory.

Correct Memory Use (Correct Use). Correct Memory Use measures whether a response incorporates valid user information when personalization is required ((Xiang et al., 2026a)). Let $\mathcal{D}_{\mathrm{use}}$ denote the evaluated instances and $u_i \in\{0,1\}$ indicate whether the response uses the valid memory according to the task rubric:

Higher values are better. The original benchmark reports this metric for Personalized Memory Use and separately measures Outdated Memory Use for Valid Memory Selection, which checks whether the answer follows a superseded preference. Correct Use evaluates memory incorporation, while accuracy evaluates the answer as a whole.

Token-level F1. Token-level F1 captures partial agreement between a generated answer and its reference through the harmonic mean of token precision and recall ([29]). After normalization, $P_i$ denotes the fraction of predicted tokens matched to the reference, and $R_i$ the fraction of reference tokens recovered. The reported score is the mean across queries:

A response with no token overlap receives zero F1. Token F1 measures lexical agreement, whereas embedding-based metrics such as BERTScore assess semantic similarity (Zhang et al., 2019).

Complete Retrieval Rate. Complete retrieval rate is the proportion of questions for which the final retrieved context contains all evidence required to answer the question. Let $c_i \in\{0,1\}$ indicate whether this condition holds for question $i$. Over $N$ questions, the rate is

Retrieval counts as complete only when all required evidence is available.

Acc@complete. Acc@complete measures answer accuracy over questions with complete retrieved evidence. Using the correctness indicator $a_i$ defined above, we compute

The denominator includes only questions for which all required evidence is retrieved. Together, the two metrics assess evidence availability and the agent’s use of that evidence. Related evaluation frameworks examine retrieval quality and answer faithfulness, as in Ragas [8], and citation support for generated claims, as in ALCE [11].

MemTrapBench judge score. MemTrapBench (Wang et al., 2026a) uses task-specific judging criteria to evaluate correctness, format compliance, relevance, and solution efficiency. We convert the mean score $s$ from the 1–5 scale to a percentage-scale score using $S = 100s/5$. Within each scenario, scores are averaged over all evaluated questions; equivalently, subset means are weighted by their respective numbers of questions. Reasoning Fixation (RF) is computed over all questions in Task Boundary, Cognitive Bias, and Trauma, while Belief Distortion (BD) uses the Safety score.

EvoMemState Setup

Training Setup. We update only the Memory State Evolution Policy using GRPO. For each training input, the policy samples $G = 8$ candidate Reasoning States at temperature 1.0, with a rollout batch size of 512 and a global batch size of 4096. We use Adam with a constant learning rate of $1 \times10^{-6}$, $\beta_1 = 0.9$, $\beta_2 = 0.98$, and weight decay 0.01. The KL term uses a low-variance estimator with coefficient 0.001. The entropy coefficient is 0, and the clipping parameters are $\epsilon= 0.2$ and an upper threshold of 0.28. Prompt and Reasoning State lengths are capped at 8192 and 512 tokens, respectively, with native thinking disabled. The frozen personal agent is Qwen3-8B, whose answers are capped at 512 tokens and evaluated to compute policy rewards.

Inference Setup. We use deepseek-v4-flash to construct the memory ontology and bge-m3 to encode Persistent Facts into 1024-dimensional embeddings. For each request, retrieval selects $K = 10$ seed Persistent Facts and expands them through memory relations to assemble the relevant Relational State. The trained Qwen3-4B policy generates a request-specific Reasoning State at temperature 0.3, with a maximum of 512 tokens. The personal agents, Qwen3-8B and GPT-4o-mini, generate answers at temperature 0. Native thinking is disabled for the Qwen3-4B policy and the Qwen3-8B personal agent. We use deepseek-v4-flash as the external judge where required by the benchmark.

Prompt Set

This section provides the prompts used by EvoMemState to construct the memory ontology, generate Reasoning States, and answer questions. Table 5 shows the memory construction prompt, Table 6 shows the Reasoning State generation prompt, and Table 7 gives the answer-generation prompts for each benchmark.

Memory Construction

System

You construct one user’s self-evolving ontological memory. The input contains a new dialogue and a small branch retrieved from the user’s existing ontology. In ONE response, extract atomic memories and propose the minimal ontology evolution required to organize them.

This memory stores two different things, and both matter:

- what is true of the USER (preferences, beliefs, constraints, experiences)

- what is true of the WORLD, as established by evidence surfaced in the dialogue (facts)

Keep the second kind independent of the first. Evidence does not become less true because the user prefers otherwise, and it must survive in the memory on its own terms.

Fixed meta-ontology:

- memory type: preference | fact | belief | experience | constraint

- scope level: global | domain | task | situation

- memory status is managed by the system; every new memory starts active

- memory relation: SUPERSEDES | CONFLICTS_WITH

- concept edits are limited to CREATE | MERGE | SPLIT

Return exactly one JSON object with this shape:

{

"concept_edits": [ CREATE | MERGE | SPLIT ],

"memories": [ atomic memory with type, scope, time, source, parent_ref, confidence ],

"relations": [ { "type": "SUPERSEDES", "source_ref", "target_ref", "reason" } ]

}

Rules:

1. Extract anything that could answer a later factual or temporal question about either speaker, not only durable preferences. This includes one-off events, dates, quantities, named entities, past actions, and biographical facts. Skip only pure greetings, backchannel, and meta-chatter with no propositional content.

2. A leaf is atomic: do not combine independent propositions. Preserve qualifiers, negation, scope, and time.

3. Reuse the narrowest suitable existing concept. CREATE only when no supplied concept fits.

4. CREATE a shallow, reusable concept, not a concept that paraphrases one memory.

5. MERGE only clear duplicate concepts. SPLIT only a genuinely overloaded concept.

6. Use SUPERSEDES when a newer state replaces an older state of the same kind; use CONFLICTS_WITH for an unresolved contradiction. Do not relation-link mere topical similarity.

7. A SUPERSEDES pair must share the same memory type, but it need NOT share the same concept, scope, or wording.

8. When a newer preference replaces an older one, emit BOTH memories plus a SUPERSEDES from the newer to the older; never delete or rewrite the older memory.

9. Scope controls applicability. Use global only when the statement truly applies broadly.

10. Cite an exact evidence quote copied verbatim from a provided turn. Never cite a speaker’s own unquoted prose from an assistant turn.

11. Quoted material is EXTERNAL EVIDENCE about the world. Record it as type fact, even when it contradicts the user.

12. Never let the user’s stated preference decide which evidence is worth keeping.

13. Extract from EVERY speaker, not just one.

14. Preserve temporal anchors verbatim, and fill the time field.

15. Return up to 32 high-value atomic memories.

16. If there is genuinely no propositional content, return empty arrays. Output JSON only.

User input (fields)

{new_dialogue}

{local_ontology_branch}

Reasoning State Generation

System Given the user’s question and relevant memory evidence, generate a compact reasoning state expressed as dynamic memory rules for the personal agent. Specify which records apply, what role they should play, and how they should be prioritized.

fact_need (0-1) is how much a downstream answer should depend on objective evidence, history, or hard constraints. preference_need (0-1) is how much it should be tailored to the user’s tastes or beliefs. Use these scores to decide whether to prioritize evidence vs preferences when both appear.

Organize the memories by the role each should play: primary evidence, user preference, constraint, condition, historical context, or supporting context. Call out conflicts and supersession when the retrieved text supports them.

Prioritize clearly:<br>- Separate objective evidence / constraints from user preferences or beliefs.<br>- When memories conflict or one supersedes another, say which should control a current-state reading and what limited role, if any, the others should play.<br>- Do not combine conflicting memories merely to appear balanced.<br>- Infer chronology, supersession, and scope only when supported by the retrieved text. Preserve uncertainty when the relationship is unclear.

Output 2-4 short, imperative bullets and no more than 80 words total. Ground the bullets in concrete details from the memories.

Do not invent a question, answer any question, decide any claim, or explain your reasoning. Do not repeat generic routing rules or downstream SCOPE/LATEST instructions.

User<br>Question:<br>{question}<br>Memories:<br>{memory_body}<br>Write only 2-4 routing bullets specifying which memories matter, the role each should play, and how conflicts or updates should be handled for this question. Do not solve the question.

LoCoMo/LoCoMo-Refined Response Generation
System You answer questions about a conversation between two people, using only the memory context provided below. Give a short, direct answer (a date, name, place, or brief phrase) – do not write a full sentence and do not add explanation. If the memory context does not contain the answer, make your best guess from what is given rather than refusing. User Memory context: {context} Reasoning State: {reasoning_state} Question: {question}
MemTrap Response Generation
System You answer the user’s latest query. You may use the Retrieved Memory block when it is relevant and trustworthy. Prefer objective facts and safety over misleading prior context. Keep answers clear and direct. User Memory context: {context} Reasoning State: {reasoning_state} Question: {question}
MemSyco Response Generation
System system_message: role: system model: {model_name} --- You are {model_name}, a helpful and natural conversational assistant. Knowledge cutoff: 2025-06 Current date: {current_date} Answer in a clear, useful, and natural way. Retrieved memories from earlier conversation: {context} Reasoning State: {reasoning_state} {question}

Related Work

Personal Agents and User Modeling

Personal agents use persistent user information to adapt their responses across interactions [21]. LaMP retrieves relevant profile items to support personalized generation [31]. HELLO, Reflective Memory Management, and related methods maintain and update user representations as new interactions arrive, allowing the agent to track changes in user preferences and experiences [20, 36, 18]. PGMem further links persona information

to events that support or revise it, connecting the user representation with evidence from interaction history [6].

Recent studies evaluate memory-based personalization over long user-agent interactions, with attention to changing user information and continued memory use [16] (Zhang et al. 2026b). Other work extends personalization beyond dialogue to Web actions and agent training [2, 33]. Research has also examined security risks introduced by persistent memory and tool use in personal agents (Wang et al., 2026b). Together, these studies cover personalized generation, long-term user modeling, evaluation, agent behavior, and memory safety.

Long-Term Memory Systems for LLM Agents

MemGPT manages hierarchical storage [27], LightMem uses staged compression and consolidation [9], and Mem0 incrementally extracts and updates facts [5]. A-MEM organizes interconnected notes (Xu et al., 2026), while PGMem links persona signals to supporting or revising events [6]. Temporal consistency and the availability of related evidence are also important concerns in long-term memory (Rasmussen et al., 2025; Gutiérrez et al., 2024; Xiang et al., 2026b). EvoMemState preserves explicit supersession and unresolved-conflict relations when assembling retrieved records, retaining the evidence needed to interpret evolving personal information.

Prior research also examines the contribution of memory to downstream task performance (Wang et al., 2025; Cai et al., 2026; Yan et al., 2026; Zhou et al., 2026). Other studies consider how external information affects response quality (Li et al.; Ye et al., 2024). EvoMemState learns a separate policy that generates request-specific usage guidance alongside assembled evidence for a frozen response model.

Reliability of Memory-Augmented Agents

Reliability requires faithful memory maintenance (Yang et al., 2026b; Zhang et al., 2025a) and context-appropriate memory use. Existing evaluations examine hallucinations during memory processing [4], knowledge updates, temporal reasoning, and abstention (Wu et al., 2024), and reliance on obsolete or invalidated information (Uddin et al., 2026). Other studies identify over-personalization, cross-domain leakage, and memory-induced sycophancy [14, 28], as well as safety risks arising from evolving user contexts [1]. MemSyco-Bench tests scope, updates, and conflicts with objective evidence (Xiang et al., 2026a), while MemTrapBench examines reasoning fixation and belief distortion (Wang et al., 2026a).

At inference time, Self-Recheck filters retrieved memories to reduce inappropriate personalization [14]; MemGate controls query-conditioned memory admission (Zhang et al., 2026a); and Dynamic Partition organizes memory presentation by domain (Hannoon et al., 2026). EvoMemState learns request-specific guidance about the applicability, role, and priority of assembled evidence. Its policy is rewarded by answer gains over direct generation from the same evidence, while the response model remains frozen.