MindMemOS: A Portable and Self-Evolving Memory Operating Layer for AI Agents

# MindMemOS: A Portable and Self-Evolving Memory Operating Layer for AI Agents
Source: [https://arxiv.org/html/2608.12428](https://arxiv.org/html/2608.12428)
August 12, 2026

![[Uncaptioned image]](https://arxiv.org/html/2608.12428v1/figures/noah_ark_logo_cropped.png)

MindMemOS: A Portable and Self\-Evolving Memory Operating Layer for AI Agents MindMemOS Team Noah’s Ark Lab, Huawei Technologies

AbstractMemory is a core component of AI agents, enabling them to accumulate experience, maintain personalization, and adapt over long\-term interactions\. However, existing memory systems often remain fixed after development, limiting their ability to adapt their memory models, organization strategies, and procedural knowledge through continued use\. We presentMindMemOS, a portable and self\-evolving memory operating layer that organizes open\-world information using a unified entity–property–time structure\. MindMemOS supports scenario\-adaptive memory modeling, higher\-order pattern discovery, autonomous memory refinement, and continuous skill evolution\. Its MindMemEvolve algorithm employs validation\-driven evolutionary search to optimize memory schemas for target scenarios, while dreaming consolidates accumulated memories by merging redundant records and resolving conflicts\. In addition, implicit corrective feedback serves as a human\-in\-the\-loop signal for identifying and revising potentially inaccurate or misaligned memories\. Its MindSkillEvolve algorithm further transforms agent execution trajectories into reusable and progressively refined skills\. MindMemOS achieves 94\.03% accuracy on LOCOMO and 70\.63% on PersonaMem\. MindSkillEvolve improves SpreadsheetBench success by 9\.2 percentage points over the initial\-skill baseline\.[![[Uncaptioned image]](https://arxiv.org/html/2608.12428v1/figures/github-mark.png)https://github\.com/mindscale\-noah/MindMemOS](https://github.com/mindscale-noah/MindMemOS)

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/homepage_combined.png)Figure 1:\(a\)LOCOMO — Overall accuracy \(%\)\. Gray: baselines\. Blue: MindMemOS\.\(b\)PersonaMem — Overall accuracy \(%\)\.\(c\)Dreaming \(GPT\-5\-mini\) — Left: FactConsolidation overall accuracy\. Right: active memory volume before vs\. after dreaming \(AMCR 22\.5%\)\.\(d\)Skill Evolution — SpreadsheetBench success rate \(%\)\.## 1Introduction

Large language model \(LLM\)\-based agents are increasingly being integrated into software engineering, office productivity, information processing, and other knowledge\-intensive workflows\. Systems such as OpenClaw support task execution on personal computers\[[22](https://arxiv.org/html/2608.12428#bib.bib21)\], while coding\-agent frameworks including Claude Code\[[2](https://arxiv.org/html/2608.12428#bib.bib22)\], OpenAI Codex CLI\[[21](https://arxiv.org/html/2608.12428#bib.bib23)\], and OpenCode\[[1](https://arxiv.org/html/2608.12428#bib.bib24)\]assist users with long\-horizon software\-development tasks\. As these agents engage in repeated interactions, they must retain user preferences, previously acquired knowledge, task\-relevant resources, and procedural experience beyond the capacity of a single context window\. Memory therefore serves as an external information substrate that supports long\-term personalization, knowledge reuse, and experience accumulation\[[12](https://arxiv.org/html/2608.12428#bib.bib27),[4](https://arxiv.org/html/2608.12428#bib.bib26),[36](https://arxiv.org/html/2608.12428#bib.bib25)\]\.

Existing research on agent memory broadly follows two directions: memory models and memory systems\. Memory models encode retained information within model parameters or latent representations\. Parameter\-based approaches incorporate customized information through adapters, fast parameters, or test\-time training mechanisms\[[3](https://arxiv.org/html/2608.12428#bib.bib5),[38](https://arxiv.org/html/2608.12428#bib.bib6),[31](https://arxiv.org/html/2608.12428#bib.bib7)\], whereas latent\-memory approaches maintain information in dedicated representation spaces, as exemplified by G\-MemLLM\[[29](https://arxiv.org/html/2608.12428#bib.bib29)\], MemoryLLM\[[28](https://arxiv.org/html/2608.12428#bib.bib3)\], G\-Memory\[[30](https://arxiv.org/html/2608.12428#bib.bib8)\], and LatentMem\[[8](https://arxiv.org/html/2608.12428#bib.bib10)\]\. These approaches can improve memory\-dependent reasoning, but they commonly rely on model\-specific architectures or additional training procedures, which may limit their portability across foundation models and agent runtimes\. Dynamic memory management approaches further optimize organization through meta\-evolution, reinforcement learning, and skill\-based mechanisms\[[32](https://arxiv.org/html/2608.12428#bib.bib9),[34](https://arxiv.org/html/2608.12428#bib.bib11),[33](https://arxiv.org/html/2608.12428#bib.bib12)\], but remain tightly coupled to specific training curricula or task environments, limiting cross\-domain transferability\.

Memory systems instead externalize information into textual or structured stores and use LLM\-driven workflows for memory extraction, retrieval, and maintenance\. Representative systems include Mem0\[[5](https://arxiv.org/html/2608.12428#bib.bib1)\], memU\[[20](https://arxiv.org/html/2608.12428#bib.bib32)\], Zep\[[25](https://arxiv.org/html/2608.12428#bib.bib13)\], Mirix\[[27](https://arxiv.org/html/2608.12428#bib.bib14)\], MemOS\[[17](https://arxiv.org/html/2608.12428#bib.bib2)\], EverOS\[[10](https://arxiv.org/html/2608.12428#bib.bib15)\], MemBrain\[[6](https://arxiv.org/html/2608.12428#bib.bib30)\]and VikingMem\[[7](https://arxiv.org/html/2608.12428#bib.bib16)\]\. Some systems primarily emphasize the extraction and retrieval of factual memories, while experience\-oriented approaches such as ExpeL\[[37](https://arxiv.org/html/2608.12428#bib.bib4)\]and SCOPE\[[23](https://arxiv.org/html/2608.12428#bib.bib31)\]focus on summarizing reusable task knowledge or optimizing procedural guidance\. These systems have demonstrated the practical value of external memory, but their memory extraction policies, modeling structures, and organization strategies are often configured for particular scenarios and remain largely fixed after deployment\[[35](https://arxiv.org/html/2608.12428#bib.bib28)\]\.

This rigidity creates three challenges\. First, an unstructured memory representation may be portable but provide limited support for fine\-grained organization and temporal reasoning, whereas a manually designed schema can capture scenario\-specific information but requires substantial adaptation when the target domain changes\. Second, continuously accumulated memories may contain redundancies, outdated information, and conflicting statements, requiring systematic maintenance beyond online extraction and retrieval\[[15](https://arxiv.org/html/2608.12428#bib.bib19),[16](https://arxiv.org/html/2608.12428#bib.bib20)\]\. Third, memory content and procedural skills are often managed separately, making it difficult to transform accumulated execution experience into reusable and progressively refined agent capabilities\.

To address these challenges, we presentMindMemOS, a portable and self\-evolving memory operating layer for AI agents\. MindMemOS models open\-world information using a unified entity–property–time structure that supports both modeling\-free and schema\-guided memory generation\. A compact search module retrieves information through hybrid sparse–dense matching and bidirectional traversal over entity, property, relational, and temporal associations\. On top of this representation, MindMemOS introduces four complementary evolution mechanisms\.MindMemEvolveuses validation\-driven evolutionary search to adapt memory schemas to target scenarios and discover task\-relevant first\-order and higher\-order properties\.Dreamingconsolidates accumulated memories during offline periods by merging redundant records, resolving conflicts, and preserving provenance, whileFeedbackincorporates users’ corrective signals to identify and revise potentially inaccurate or misaligned memories\.MindSkillEvolvefurther converts agent execution trajectories into reusable skill updates through unsupervised or score\-guided refinement\.

Our main contributions are as follows:

1. 1\.Scenario\-Adaptive Memory Modeling\.We introduce an entity–property–time memory structure that organizes factual, relational, profile, and temporal information within a unified representation\. The same system supports both open\-domain vanilla ingestion and schema\-guided extraction, allowing memory modeling to be adapted without changing the surrounding agent interface\.
2. 2\.Active Memory Pattern Discovery\.We propose MindMemEvolve, an LLM\-guided evolutionary search algorithm that optimizes memory schemas using task\-specific evaluation signals\. Through error\-informed mutation, exploratory mutation, crossover, and selection, it adapts entity and property definitions and discovers higher\-order patterns relevant to the target scenario\.
3. 3\.Continuous Memory Refinement\.We introduce dreaming to consolidate accumulated memories during offline periods by merging redundant records, resolving conflicts, and preserving provenance\. Complementarily, explicit and implicit feedback mechanisms use users’ corrective signals to identify and revise potentially inaccurate or misaligned memories while distinguishing transient task corrections from durable memory updates\.
4. 4\.Experience\-Driven Skill Evolution\.We introduce MindSkillEvolve, which continuously refines skills from accumulated usage experience\. It analyzes agent execution trajectories to identify effective strategies and recurring failures, transforming them into versioned skill updates through unsupervised or score\-guided evolution\.

## 2System Overview

### 2\.1System Architecture

As shown in Figure[2](https://arxiv.org/html/2608.12428#S2.F2), MindMemOS adopts a layered architecture that decouples agent integration, memory algorithms, and memory structure \(modeling and storage\)\. At its foundation, the memory structure layer organizes memory modeling management, memory storage and skills\. Built on this representation, the memory algorithm layer supports the complete memory lifecycle: MindVanilla policy and MindSchema policy, compact graph\-based retrieval, feedback\- and dreaming\-driven quality optimization, and trajectory\-driven skill evolution\.

The agent and application layer expose these capabilities through a unified service abstraction, allowing MindMemOS to flexibly integrate with diverse agent frameworks via FastAPI\-based HTTP APIs, SDKs, CLI commands, OpenClaw plugins or Skills while continuously optimizing memory content independently of the application runtime\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/system-architecture.png)Figure 2:System architecture of MindMemOS\.
### 2\.2Scenario\-Adaptive Memory Modeling

Memory modeling forms the foundation of the memory system, defining the data structures and associated algorithms foradd,search, and related operations\. As described in Section[1](https://arxiv.org/html/2608.12428#S1), our design adopts scenario\-adaptive memory modeling to organize open\-world textual information into structured representations tailored to the target scenario\.

Our memory model comprises three modeling dimensions:

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/memory_structure_3d.png)Figure 3:The 3D memory structure of MindMemOS, organized along the entity, property, and time dimensions\.#### Three\-dimensional Memory Structure\.

Our memory system organizes memories in a three\-dimensional \(3D\) graph defined byentity,property, andtime, thereby constructing and maintaining an information\-grounded virtual representation of the real world\. Each memory record is associated with an entity, a property describing a specific attribute or aspect of that entity, and a temporal reference indicating when the information holds or was observed\. The graph further captures semantic relations among entities and temporal relations among successive records associated with the same entity–property pair\. Together, these relational and temporal links support traceable navigation across interconnected entities and evolving information\.

#### Entity Dimension\.

The entity dimension identifies the subject described by a memory, such as a person, organization, location, event, or artifact\. Entities serve as anchors for organizing information collected from different conversations, documents, and interactions\. Relations between entities capture semantic connections such as participation, ownership, location, or social relationships\.

#### Property Dimension\.

The property dimension specifies the particular attribute or aspect of an entity described by a memory, such as a preference, activity, experience, relationship, or behavioral pattern\. Under scenario\-adaptive memory modeling, the set of properties is not restricted to a fixed universal schema; instead, property definitions can be adapted to the information needs of the target scenario\. Properties may represent either explicit facts derived from individual observations or higher\-order patterns synthesized across multiple observations\.

#### Temporal Dimension\.

The temporal dimension represents when information is valid, observed, or recorded\. A temporal memory record binds an entity and a property to a specific content item and its temporal reference\. Successive records associated with the same entity–property pair form a timeline, enabling the system to represent updates, changing preferences, and potentially conflicting versions without overwriting their historical context\.

## 3Algorithm

Building on the 3D memory structure, this section presents the core algorithms of MindMemOS, including two memory generation algorithms, compact retrieval, dreaming\- and feedback\-based memory refinement, offline memory self\-evolution, and trajectory\-driven skill evolution\.

### 3\.1Memory\-Add: MindVanilla

#### Turn\-Aware Input Processing\.

MindVanilla generation processes dialogue and free\-form text without relying on a predefined entity–property schema\. It groups messages into turns based on conversational roles and temporal gaps, packs complete turns into token\-bounded chunks, and compacts overlength turns when necessary\. Each extractable message is normalized and linked to a source reference that preserves its role, timestamp, and original position\.

#### Recall\-Aware Memory Extraction\.

For each chunk, the system retrieves related active memories through content\-hash matching, entity overlap when available, and BM25 retrieval, with candidates combined using weighted reciprocal rank fusion\. The extractor receives a structured envelope that separates extractable evidence from contextual information: only the former may support new memory content, while history and recalled memories are used for disambiguation, duplicate detection, and conflict assessment\. The resulting memories are represented as flat records and assigned coarse semantic types, such as profile, fact, episodic memory, tool trace, experience, or skill candidate\.

#### Deduplication and Action Planning\.

Candidates produced across all chunks are deduplicated by content hash and memory type\. After resolving their source references, a deterministic safety gate validates the candidates and maps them toAdd,Reinforce,Update,Merge, orSkip\. Accepted operations are vectorized as needed and stored together with their provenance and memory\-relation links\.

### 3\.2Memory\-Add: MindSchema

We further elaborate on the dynamic generation process of the 3D memory structure based on entity modeling\. As illustrated in Figure[4](https://arxiv.org/html/2608.12428#S3.F4), the memory generation pipeline comprises the following steps:

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/modeling_guided_memory_construction.png)Figure 4:MindSchema memory generation pipeline: episode segmentation, memory generation, entity fusion, and graph merge, guided by memory modeling\.#### Episode Segmentation\.

We employ an LLM\-based memory segmenter to partition the message list received into complete sub\-topic episodes\. In synchronous mode, the entire message list from current memory\-add requests is segmented directly\. In asynchronous mode, messages first accumulate in a buffer until a topic shift is detected, forming a complete episode\. It enables continuous accumulation and autonomous segmentation of memories, independent of message role transitions or session boundaries\.

#### Memory Generation\.

When a memory\-add request arrives, the system first maps the dialogue to the entity and property types defined in the scenario\-adaptive memory schema\. It then extracts the corresponding entity instances and property values from the source messages, resolving temporal expressions into absolute timestamps when sufficient temporal evidence is available\. These outputs form the memory subgraph for the current episode\. In addition, the system creates an episodic entity for each episode as a fallback representation for contextual information not captured by the schema\-defined properties\.

#### Entity Fusion\.

The system uses the current memory subgraph as a query to retrieve related memories and candidate matching entities from the memory store\. It then resolves entity equivalence and merges each matched entity instance with its existing representation\. The fusion process may update entity descriptions, insert or revise property values along their timelines, consolidate overlapping values, and mark outdated values as expired\. If the scenario\-adaptive schema defines higher\-order properties for the entity type, the system additionally synthesizes these properties from relevant historical memories, such as the user’s decision\-making style or risk propensity\.

#### Graph Merge\.

The system attempts to fuse the memory subgraph with the existing memory graph to form an updated memory graph\. Through node merging \(entity fusion above\) and new entity edge relationship formation, the memory subgraph is ultimately merged and updated into the complete 3D memory structure, forming a structurally identical but information\-enriched and refreshed memory graph\.

### 3\.3Compact Search

We design a compact search module to improve retrieval coverage through multi\-path traversal\. Here, compact refers to restricting traversal to task\-relevant entity, property, relational, and temporal associations rather than exhaustively expanding the memory graph\. The overall search procedure is illustrated in Figure[5](https://arxiv.org/html/2608.12428#S3.F5)\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/compact_search.png)Figure 5:Compact search architecture: an outer agentic layer orchestrates an inner tool layer with bidirectional multi\-path graph search over the 3D memory structure\.#### Overall Architecture\.

The engine consists of an outer agentic layer for search planning and an inner tool layer for managing different search engines\.

#### Agentic Search Planning\.

An LLM\-based controller performs iterative retrieval planning\. At each step, it determines the relevant temporal scope and memory types, formulates search queries, invokes retrieval tools, and assesses whether the collected evidence is sufficient\. Based on this assessment, the controller either refines the retrieval plan or terminates the search\.

#### Hybrid Bidirectional Graph Retrieval\.

The inner retrieval engine combines sparse lexical matching based on BM25 with dense semantic matching based on an embedding model, and fuses their ranked results using reciprocal rank fusion \(RRF\)\. This hybrid strategy is shared by the MindVanilla and MindSchema search tools\. Over the 3D memory structure, the engine supports both forward traversal, which retrieves entities before selecting their relevant properties, and reverse traversal, which retrieves property\-level memory records before tracing them to their associated entities\. Results from both directions are deduplicated and organized into an entity\-centered representation with the corresponding properties\. Retrieved memories may be extended temporally through predecessor and successor property versions and relationally through associated entities\. Relational expansion is optional and disabled in agentic mode to limit the retrieval scope during targeted multi\-turn search\.

#### Retrieval Key Augmentation\.

To improve fine\-grained entity matching, an entity description can also be decomposed into multiple search fields, each representing a distinct retrieval aspect\. These fields are matched independently against the query, and the highest field\-level score is used as the entity score, improving access to fine\-grained evidence while preserving entity\-level context\.

### 3\.4Dreaming

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/dreaming_flow.png)Figure 6:Dreaming workflow in MindMemOS\.Dreaming is the offline consolidation mechanism of MindMemOS\. Online memory generation prioritizes the timely capture of useful facts and episodes, but incremental writes may leave redundant, overlapping, outdated, or conflicting records\. Dreaming reorganizes these accumulated memories after interaction, reducing the maintenance burden on the online generation path\.

#### Entity\-Centered Scope Construction\.

A dreaming run begins by selecting unconsolidated add records within a configurable lookback window\. Each selected record serves as a seed for constructing a local consolidation scope: the system retrieves active memories associated with the same entity and groups them into an entity\-centered cluster\. This strategy confines consolidation to recently affected neighborhoods of the memory graph, avoiding both global comparison and isolated pairwise processing\.

#### Issue Detection and Action Planning\.

Each cluster is processed through a two\-stage detect\-then\-act procedure\. The first LLM call identifies focused issue groups involving conflicts, duplication, complementary fragments, low\-value content, or ambiguous relationships\. These groups are validated for subject consistency and sufficient evidence before further processing\. The second LLM call converts each validated issue into a conservative mutation plan that may create a consolidated memory, update or merge existing records, archive obsolete information, or add explicit relational links\. When entity identity, relational structure, or temporal order is uncertain, the planner favors non\-destructive updates or links over archival\.

#### Traceable Memory Consolidation\.

The resulting mutation plan is applied through the standard memory write interface\. Newly created or merged memories receive updated vectors and provenance links to their supporting records; where applicable, timeline edges connect successive versions within the same entity–property scope\. After successful processing, the corresponding add records are marked as consolidated to prevent repeated handling in subsequent runs\. Through this traceable process, dreaming can reduce redundancy, resolve conflicts, and preserve the lineage of consolidated information\.

### 3\.5Feedback

Feedback provides an interaction\-driven mechanism for converting corrective user signals into structured memory\-maintenance actions\. MindMemOS supports two complementary modes\.*Explicit feedback*is directed at the memory system and specifies what should be corrected, whereas*implicit feedback*is inferred from corrections originally addressed to the task\-performing agent\. Both modes operate over relevant interaction context and candidate memories, but differ in how corrective evidence is obtained\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/feedback_flow.png)Figure 7:Feedback workflow in MindMemOS\.#### Explicit Feedback\.

Explicit feedback allows users to revise stored memories through natural\-language corrections rather than direct database manipulation\. It takes the feedback statement, the relevant conversation context, and the initially retrieved memories as input\. The conversation context helps disambiguate the correction target and distinguish durable information from instructions, while the retrieved memories provide candidate records for inspection and modification\. When these candidates are insufficient to support a reliable decision, the planner may rewrite the feedback and its context into a search query, perform one supplemental MindVanilla search, and merge the retrieved records with the original candidates by memory ID\. Based on the resulting evidence, the planner generates anadd,update,delete, orno\-opaction and applies it through the shared memory\-mutation interface\. Corrections that are relevant only to the current task are excluded from durable storage, reducing the risk of propagating temporary instructions into long\-term memory\.

#### Implicit Feedback\.

In many interactions, users correct the task\-performing agent rather than explicitly requesting a memory update\. Such corrections may reveal inaccurate assumptions, revised preferences, rejected recommendations, or previously unstated constraints\. Although these signals can be valuable for future interactions, they are easily lost after the current session because they are embedded in ordinary dialogue and may not directly reference any stored memory\. Implicit feedback is designed to identify these corrective signals and selectively convert them into memory\-maintenance actions, thereby reducing the recurrence of previously corrected behaviors\.

The process runs asynchronously over recent session activity\. It first compacts multi\-turn interactions into semantically coherent rounds and detects correction signals from the user’s responses to the agent’s outputs\. Each signal is then classified according to its persistence scope as*task\-temporary*,*scenario\-specific*, or*long\-term*\. Task\-temporary signals apply only to the current task and are not stored as new durable memories, although they may be used to correct or remove memories that have incorrectly retained one\-off information\. Scenario\-specific signals are retained together with explicit applicability conditions, while long\-term signals capture durable facts, preferences, or behavioral constraints that may generalize across future interactions\. For each actionable signal, the system gathers relevant candidate memories and plans anadd,update,delete, orno\-opoperation\. This persistence\-aware process reduces the risk of either discarding useful corrections or overgeneralizing transient feedback into unconditional long\-term memory\.

### 3\.6MindMemEvolve: Validation\-Driven Self\-Evolution of Memory Schemas

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/memevolve_flow.png)Figure 8:Overview of MindMemEvolve\.The core advantage of the memory modeling schema lies in its adaptability across scenarios, enabled by modular and configurable definitions of entities, first\-order properties, and higher\-order properties\. This explicit representation makes the schema itself a natural target for optimization\. To exploit this, we introduceMindMemEvolve, a self\-evolution mechanism that automatically adapts an existing memory schema to a new target scenario\.

In MindMemEvolve, the memory modeling schema is optimized with a training set𝒟=\{\(𝐜𝐨𝐧𝐭𝐞𝐱𝐭i,qi,ai\)\}i=1N\\mathcal\{D\}=\\\{\(\\mathbf\{context\}\_\{i\},q\_\{i\},a\_\{i\}\)\\\}\_\{i=1\}^\{N\}, where𝐜𝐨𝐧𝐭𝐞𝐱𝐭i\\mathbf\{context\}\_\{i\}denotes the context associated with the QA pair,qiq\_\{i\}a user query, andaia\_\{i\}the reference answer\. Note that differentqiq\_\{i\}may share the same context, i\.e\., contexts can be the same across samples\. Let𝒮\\mathcal\{S\}denote the candidate memory modeling schema being optimized\. The optimization objective is to find the schema𝒮\\mathcal\{S\}that maximizes the Judge score:

𝒮∗=arg⁡max𝒮\\displaystyle\\mathcal\{S\}^\{\*\}=\\arg\\max\_\{\\mathcal\{S\}\}1N∑i=1NJudge\(ai,LLM\(qi,MindMemOSsearch\(qi;𝒮\)\|\\displaystyle\\frac\{1\}\{N\}\\sum\_\{i=1\}^\{N\}\\operatorname\{Judge\}\\Bigl\(a\_\{i\},\\operatorname\{LLM\}\\Bigl\(q\_\{i\},\\,\\operatorname\{MindMemOS\}\_\{\\mathrm\{search\}\}\(q\_\{i\};\\mathcal\{S\}\)\\,\\Big\|\\,\(1\)OPENOPENMindMemOSadd⁡\(𝐜𝐨𝐧𝐭𝐞𝐱𝐭i;𝒮\)\)\)\.\\displaystyle\\operatorname\{MindMemOS\}\_\{\\mathrm\{add\}\}\(\\mathbf\{context\}\_\{i\};\\mathcal\{S\}\)\\Bigr\)\\Bigr\)\.
whereJudge⁡\(a,a^\)∈\[0,1\]\\operatorname\{Judge\}\(a,\\hat\{a\}\)\\in\[0,1\]measures the correctness of the generated answera^\\hat\{a\}with respect to the reference answeraa\. In each evaluation episode,MindMemOSadd​\(𝐜𝐨𝐧𝐭𝐞𝐱𝐭i,𝒮\)\\text\{MindMemOS\}\_\{\\text\{add\}\}\(\\mathbf\{context\}\_\{i\};\\mathcal\{S\}\)first processes𝐜𝐨𝐧𝐭𝐞𝐱𝐭i\\mathbf\{context\}\_\{i\}under schema𝒮\\mathcal\{S\}and writes structured memory entries \(entities, properties, relationships\) into the memory store\. Given the queryqiq\_\{i\}, the search moduleMindMemOSsearch​\(qi,𝒮\)\\text\{MindMemOS\}\_\{\\text\{search\}\}\(q\_\{i\};\\mathcal\{S\}\)retrieves a set of relevant memories\. The retrieved memories are then provided to the LLM together withqiq\_\{i\}to generate the answera^i\\hat\{a\}\_\{i\}\.

Since𝒮\\mathcal\{S\}is a discrete structured object, Eq\. \([1](https://arxiv.org/html/2608.12428#S3.E1)\) defines a non\-differentiable optimization problem\. We adopt an LLM\-guided evolutionary algorithm as a heuristic solver\. The algorithm operates forEEepochs, each consisting ofUUsteps that iterate over distinct clusters of the training set, yieldingH=E⋅UH=E\\cdot Ucumulative training steps\. We index epochs bye∈\[1,E\]e\\in\[1,E\], steps within an epoch byu∈\[1,U\]u\\in\[1,U\], and cumulative steps byt=\(e−1\)⋅U\+ut=\(e\-1\)\\cdot U\+u, witht∈\[1,H\]t\\in\[1,H\]\.

Let the population size beKK\. Denote thejj\-th individual at cumulative stepttas𝒮t,j\\mathcal\{S\}\_\{t,j\}\(t∈\[1,H\],j∈\[1,K\]t\\in\[1,H\],\\,j\\in\[1,K\]\)\. The initial schema𝒮0\\mathcal\{S\}\_\{0\}is obtained either from a manually authored template or from an LLM\-generated draft\. The algorithm proceeds as follows:

Step 1 — Initialization\.The first population\{𝒮1,1,…,𝒮1,K\}\\\{\\mathcal\{S\}\_\{1,1\},\\dots,\\mathcal\{S\}\_\{1,K\}\\\}is produced by applying random mutations to the initial schema𝒮0\\mathcal\{S\}\_\{0\}, yieldingKKdiversified individuals\.

Step 2 — Fitness Evaluation\.At cumulative steptt\(epochee, clusteruu\), for each individual𝒮t,j\\mathcal\{S\}\_\{t,j\}we instantiate a sandboxed MindMemOS instance with a clean memory store, ingest the contexts of theuu\-th cluster under schema𝒮t,j\\mathcal\{S\}\_\{t,j\}, and compute the fitness scoref⁡\(𝒮t,j\)f\(\\mathcal\{S\}\_\{t,j\}\)by evaluating Eq\. \([1](https://arxiv.org/html/2608.12428#S3.E1)\) on the QA pairs belonging to that cluster\.

Step 3 — Reproduction\.The topα\\alphafraction of individuals \(the elite\) are preserved unchanged\. The remaining\(1−α\)​K\(1\-\\alpha\)Kslots are filled by offspring produced through the following pipeline:

1. 1\.Parent selection\.2​\(1−α\)​K2\(1\-\\alpha\)Kparents are drawn via tournament selection \(with possible duplicates\)\.
2. 2\.Induced mutation\.The LLM analyzes error cases from the parent’s evaluation, identifies information gaps, and proposes new entities or properties, or refines descriptions of existing ones\.
3. 3\.Random mutation\.\(a\) The LLM proposes plausible entity types and property types for the target scenario, which are injected into the schema; \(b\)entities and properties whose frequency falls within the bottom20%20\\%are pruned with probabilitypprunep\_\{\\text\{prune\}\}\.
4. 4\.Crossover\.One parent serves as the base schema; entities and properties from the other parent that substantially differ from the base are inserted with probabilitypcrossp\_\{\\text\{cross\}\}\.

The resultingKKindividuals form the population for stept\+1t\+1, denoted\{𝒮t\+1,1,…,𝒮t\+1,K\}\\\{\\mathcal\{S\}\_\{t\+1,1\},\\dots,\\mathcal\{S\}\_\{t\+1,K\}\\\}\. Within an epoch, ifu<Uu<U, the algorithm advances to the next cluster and returns to Step 2\. Whenu=Uu=U, the epoch completes; ift<Ht<H, a new epoch begins atu=1u=1and the clusters are iterated over anew\.

Step 4 — Selection \(StepH\+1H\+1\)\.AfterHHtraining steps, allKKindividuals from the final population are evaluated on the training set\. The individual with the highest fitness is selected as the approximately optimal schema:

𝒮∗≈arg⁡maxj∈\[1,K\]⁡f⁡\(𝒮H\+1,j\),\\mathcal\{S\}^\{\*\}\\approx\\arg\\max\_\{j\\in\[1,K\]\}f\(\\mathcal\{S\}\_\{H\+1,j\}\),\(2\)where𝒮H\+1,j\\mathcal\{S\}\_\{H\+1,j\}denotes thejj\-th individual evaluated on the training set after stepHH\.

The key insight of MindMemEvolve is that mutation operators are not purely random but are*LLM\-informed*: induced mutation leverages the Judge’s error signal to perform targeted schema repair, while random mutation and crossover explore the schema space guided by the LLM’s prior knowledge of the target domain\.

### 3\.7MindSkillEvolve: Trajectory\-Driven Skill Evolution

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/converted_skill_flow.png)Figure 9:Skill registration and MindSkillEvolve workflow in MindMemOS\.#### Skill Registry and Lifecycle\.

MindMemOS provides cloud\-edge collaborative lifecycle management of skills\. The MindMemOS client is responsible for user\-side skill registration, metadata collection, version synchronization, and rollback, while the cloud service provides centralized storage for skill content, maintains version chains, synchronizes skills across devices, and preserves historical version records\. Through the SDK, a user can register a local skill by loading its content and collecting metadata such as its logical path, alias, content hash, and base version\. The client then synchronizes the skill content and associated version metadata with the cloud service\. For each registered skill, the cloud\-side store maintains a version chain that supports historical version retrieval, rollback, and consistent skill states across devices, agents, and runtime environments\.

#### MindSkillEvolve\.

MindSkillEvolve, the skill\-evolution algorithm in MindMemOS, is driven by real agent execution trajectories\. MindMemOS reuses the Memory Add interface to collect task execution processes and provides SDK hooks through which different agent harnesses can attach skill context to each trajectory\. The SDK hook layer is responsible for locating the skills loaded during the trajectory and matching them against registered skill versions, allowing MindMemOS to bind each trajectory to the specific skill versions it exercised\. This design decouples MindSkillEvolve from how the underlying agent retrieves, loads, or executes skills, allowing it to adapt to different runtime patterns for skill usage\. When MindSkillEvolve is triggered, the system collects unconsumed trajectories under the same skill version and aggregates them in chronological order\. Each trajectory is first transformed into an evidence\-driven analysis that preserves information relevant to skill improvement, including the task objective, execution process, key turning points, skill effectiveness, tool usage patterns, and final outcome\.

Once the accumulated number of trajectories reaches a threshold, the system aggregates a batch of trajectory analyses, generates a skill\-oriented improvement plan, and then uses an LLM to convert the plan into concrete edit operations on the SKILL\. These edit operations are deterministically applied to the current skill content, producing a new cloud\-side skill version\.

MindSkillEvolve has two variants\.MindSkillEvolve\-Unsuprelies solely on trajectory analyses to identify recurring successful strategies, failure patterns, and missing guidance\.MindSkill\- Evolve\-Supadditionally uses trajectory scores as supervision signals to reinforce behaviors that consistently appear in high\-scoring trajectories and suppress recurring errors found in low\-scoring trajectories\.

## 4Evaluation and Experiments

### 4\.1Dialogue\-Centric Evaluation

We evaluate MindMemOS on the two commonly used long\-term\-memory benchmarks in memory systems:LOCOMO, which assesses information extraction, effective recall, and simple derivative reasoning over multi\-memory associations; andPersonaMem, which examines user profiling, preference analysis, and style\-aware personalized recommendation\. We compare two MindMemOS configurations—MindVanilla, a fast mode with dense/sparse retrieval, andMindSchema, a higher\-accuracy schema\-guided mode with scenario\-adaptive memory modeling —against strong, competitive baselines including Mem0\[[5](https://arxiv.org/html/2608.12428#bib.bib1)\], memU\[[20](https://arxiv.org/html/2608.12428#bib.bib32)\], MemOS\[[17](https://arxiv.org/html/2608.12428#bib.bib2)\], and EverOS\[[10](https://arxiv.org/html/2608.12428#bib.bib15)\]\.

#### LOCOMO\.

LOCOMO\[[19](https://arxiv.org/html/2608.12428#bib.bib17)\]contains 10 long multi\-session dialogues \(averaging 300\+ turns across up to 35 sessions\) with 1,986 annotated questions across ten conversations, of which we focus on the four main reasoning types aligned with common research works\[[10](https://arxiv.org/html/2608.12428#bib.bib15)\]\. Following the evaluation protocol of EverOS\[[10](https://arxiv.org/html/2608.12428#bib.bib15)\], we reportper\-category QA Accuracy \(%\)across four reasoning types—Single\-hop,Multi\-hop,Temporal, andOpen\-domain—along with theOverallaccuracy\. The answer model is gpt\-4\.1\-mini\. Baseline results for Mem0, memU, Zep, MemOS, and EverOS are cited from the EverOS paper; our experimental configuration, including the LLM driving the memory system, the embedding and reranking model, the answer model, and the judge model, is fully aligned with the EverOS default implementation\. Results are shown in Figure[10](https://arxiv.org/html/2608.12428#S4.F10)and Table[1](https://arxiv.org/html/2608.12428#S4.T1)\. MindSchema achieves the highest overall accuracy \(94\.03\), ahead of EverOS \(93\.05\) and Zep \(85\.22\), with particular strength in Single\-hop \(96\.79\) and Multi\-hop \(93\.97\) reasoning\. Notably, MindSchema achieves the highest Open\-domain score \(82\.29\) among all methods\. MindVanilla \(87\.60\) already outperforms MemOS \(80\.76\) and Zep \(85\.22\) by a clear margin, demonstrating that even the vanilla mode without modeling guidance provides competitive memory quality\. Open\-domain remains the most challenging category across all methods and is further influenced by the reasoning capability of the underlying answer model\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/locomo_overall_bar.png)Figure 10:Overall accuracy comparison on LOCOMO\. Baselines in gray, MindMemOS variants in blue\.Table 1:LOCOMO — Effectiveness\. Per\-category QA Accuracy \(%\)\.MethodSingle\-hopMulti\-hopTemporalOpen\-domainOverallMem068\.9761\.7058\.2650\.0064\.20memU74\.9172\.3443\.6154\.1766\.67MemOS85\.3779\.4375\.0864\.5880\.76Zep90\.8481\.9177\.2675\.0085\.22EverOS96\.6791\.8489\.7276\.0493\.05MindVanilla92\.0385\.8283\.8066\.6787\.60MindSchema96\.7993\.9790\.3482\.2994\.03
#### PersonaMem\.

PersonaMem\[[14](https://arxiv.org/html/2608.12428#bib.bib18)\]is a long\-range personalization benchmark comprising 20 different personas with alternating question answering\. We retain the same experimental configuration as LOCOMO, except that the entity modeling \(entity\_modeling\.json\) is designed around the user as the central entity and provides additional higher\-order properties \(see our code repository for details\)\. Baseline methods are evaluated with local deployments of their open\-source codebases, running under the same model configurations\. We reportper\-category Accuracy \(%\)across seven query types—Recall Sha\.\(recalling user\-shared facts\),Recall Mem\.\(recalling facts mentioned by the user\),Track Evo\.\(tracking full preference evolution\),Revisit\(revisiting reasons behind preference updates\),Suggest\(suggesting new ideas\),Recom\.\(providing preference\-aligned recommendations\), andGeneral\.\(generalizing to new scenarios\)—along with theOverallaccuracy\. To ensure clarity regarding the evaluation metrics, we explicitly map the abbreviated query types used in our results to their corresponding definitions in the dataset\. Specifically,Revisitcorresponds to the task ofrecalling the reasons behind previous updates\. MindSchema achieves the best overall accuracy \(70\.63\), a gain of 3\.06 percentage points over EverOS \(67\.57\), driven primarily by improvements in Recall Sha\. \(81\.40 vs\. 74\.42\) and Suggest\. \(47\.31 vs\. 35\.48\)\. MindVanilla also achieves a high 67\.74 overall, validating the effectiveness of the vanilla memory path even without explicit modeling guidance\. Because the Recall Mem\. category contains only 17 questions, a difference of one or two correct answers can produce a substantial change in category\-level accuracy\.

Table 2:PersonaMem — Effectiveness\. Per\-category Accuracy \(%\)\.MethodRecallSha\.RecallMem\.TrackEvo\.RevisitSuggestRecom\.General\.OverallMem046\.5141\.1865\.4790\.9112\.9034\.5543\.8651\.61memU64\.3464\.7166\.2087\.8831\.1867\.2784\.2165\.70MemOS53\.4982\.3566\.9179\.8041\.9469\.0975\.4463\.67EverOS74\.4264\.7164\.0385\.8635\.4865\.4584\.2167\.57MindVanilla76\.7488\.2465\.4787\.8817\.2080\.0082\.4667\.74MindSchema81\.4064\.7164\.7582\.8347\.3176\.3673\.6870\.63![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/personamem_overall_bar.png)Figure 11:Overall accuracy comparison on PersonaMem\. Baselines in gray, MindMemOS variants in blue\.

### 4\.2Dreaming Evaluation

We evaluated our dreaming algorithm on MemoryAgentBench\[[11](https://arxiv.org/html/2608.12428#bib.bib35)\]\. It is designed to evaluate memory agents, i\.e\., agent systems that incrementally store, update, and retrieve long\-term information rather than consuming the entire context as a single static input\. It organizes memory evaluation around four competencies: accurate retrieval, test\-time learning, long\-range understanding, and selective forgetting\. This setting is well aligned with our evaluation because the agent receives information in temporal order and must maintain an effective memory state across updates\. In particular, we use the FactConsolidation subset for selective forgetting, where an original fact is followed later by a contradictory rewritten fact\. The benchmark treats the later fact as the valid memory and asks questions that require the agent to answer according to the final consolidated state\. Thus, success on this subset requires not only retrieving relevant memories, but also resolving conflicts between outdated and newer information\. We evaluate both single\-hop \(SH\) and multi\-hop \(MH\) variants across four context scales: 6k, 32k, 64k, and 262k\.

#### Experimental Setup

For each dataset split, we first construct memory with the MindVanilla algorithm and then evaluate question answering before and after running dreaming\. The retrieval setting uses the fast search strategy with top\-k=50=50\. We report MindMemOS with gpt\-4o\-mini and gpt\-5\-mini using chunk size 4096, matching the settings used by the corresponding baseline memory systems\. To isolate whether dreaming can resolve memory conflicts internally, timestamps are removed from the retrieved context during evaluation\.

#### Experimental Results

Following the official MemoryAgentBench evaluation protocol, Table[3](https://arxiv.org/html/2608.12428#S4.T3)reports the average Substring Exact Match \(SubEM\) accuracy across the four context scales\. The active memory compression ratio \(AMCR\) denotes the fraction of active memories moved to the archive during dreaming\. The Mem0\[[5](https://arxiv.org/html/2608.12428#bib.bib1)\], MemoRAG\[[24](https://arxiv.org/html/2608.12428#bib.bib36)\], and HippoRAG\-v2\[[9](https://arxiv.org/html/2608.12428#bib.bib37)\]results are taken from MemoryAgentBench\[[11](https://arxiv.org/html/2608.12428#bib.bib35)\]as reference, and we additionally compare against the hybrid retrieval variant of Infini Memory\[[13](https://arxiv.org/html/2608.12428#bib.bib38)\]under gpt\-5\-mini\. For gpt\-4o\-mini, dreaming improves the average single\-hop accuracy from 0\.635 to 0\.738, the average multi\-hop accuracy from 0\.118 to 0\.180, and the overall accuracy from 0\.377 to 0\.459, with AMCR values of 21\.4%, 19\.4%, and 20\.4%, respectively\. For gpt\-5\-mini, dreaming further improves the average single\-hop accuracy from 0\.900 to 0\.920, the average multi\-hop accuracy from 0\.190 to 0\.250, and the overall accuracy from 0\.545 to 0\.585, with corresponding AMCR values of 23\.5%, 21\.5%, and 22\.5%\. After dreaming, MindMemOS also outperforms Infini Memory on single\-hop \(0\.920 vs\. 0\.800\), multi\-hop \(0\.250 vs\. 0\.220\), and overall accuracy \(0\.585 vs\. 0\.510\)\. These results show that dreaming consistently improves memory accuracy while compressing roughly one fifth of active memories, indicating that consolidation can reduce memory redundancy without degrading retrieval quality\. A concrete example of this conflict resolution process is discussed in Section[5\.1](https://arxiv.org/html/2608.12428#S5.SS1)\.

Table 3:Average FactConsolidation accuracy and active memory compression ratio \(AMCR\) before and after dreaming\.Single\-HopMulti\-HopOverallMethodAccuracyAMCRAccuracyAMCRAccuracyAMCRgpt\-4o\-miniMem00\.180–0\.020–0\.100–MemoRAG0\.270–0\.070–0\.170–HippoRAG\-v20\.540–0\.050–0\.295–MindVanilla0\.635–0\.118–0\.377–MindVanilla \+ Dreaming0\.73821\.4%0\.18019\.4%0\.45920\.4%gpt\-5\-miniInfini Memory0\.800–0\.220–0\.510–MindVanilla0\.900–0\.190–0\.545–MindVanilla \+ Dreaming0\.92023\.5%0\.25021\.5%0\.58522\.5%

### 4\.3Skill Evolution Evaluation

#### Experimental Setup

We evaluate MindSkillEvolve in a realistic client\-cloud setting: the client executes real tasks in the user’s local environment, while the cloud aggregates reported traces to improve the skill\. In other words, MindMemOS performs delayed batch evolution and synchronizes the evolved skill back to the client for subsequent tasks\.

We instantiate this evaluation on SpreadsheetBench\-Verified111[https://huggingface\.co/datasets/KAKA22/SpreadsheetBench/blob/main/spreadsheetbench\_verified\_400\.tar\.gz](https://huggingface.co/datasets/KAKA22/SpreadsheetBench/blob/main/spreadsheetbench_verified_400.tar.gz), a 400\-task verified subset of SpreadsheetBench\[[18](https://arxiv.org/html/2608.12428#bib.bib34)\]\. Each task pairs a natural\-language instruction with an initial workbook and a golden workbook for automatic verification\. The subset contains 275 cell\-level manipulation tasks and 125 sheet\-level manipulation tasks, covering operations such as finding, extracting, summing, highlighting, removing, modifying, counting, deleting, calculating, and displaying spreadsheet content\.

We compare four settings:No\-skill, where the agent solves tasks without an external skill;Init\-skill, where the agent uses the initial spreadsheet skill from SkillGrad\[[26](https://arxiv.org/html/2608.12428#bib.bib33)\]222[https://github\.com/wwwhy725/SkillGrad/blob/main/seeds/xlsx/SKILL\.md](https://github.com/wwwhy725/SkillGrad/blob/main/seeds/xlsx/SKILL.md)without evolution;MindSkillEvolve\-Unsup\., where evolution uses only execution traces; andMindSkillEvolve\-Sup\., where task scores are additionally used as supervision signals\. Table[4](https://arxiv.org/html/2608.12428#S4.T4)reports the success rate, the consumption of agent tokens and the consumption of evolution tokens in three repeated runs\. In our experiments, an evolution cycle is triggered every 40 tasks executed, with trajectories grouped into batches of eight tasks\.

#### Experimental Results

Table 4:Results of MindSkillEvolve on SpreadsheetBench\. Success rates are reported as the mean±\\pmstandard deviation over three runs\.MethodSuccess RateAgent TokensEvolve TokensNo\-skill51\.3±0\.851\.3\\pm 0\.810\.4​M10\.4\\mathrm\{M\}\-Init\-skill48\.0±1\.448\.0\\pm 1\.416\.9​M16\.9\\mathrm\{M\}\-MindSkillEvolve\-Unsup\.55\.3±0\.955\.3\\pm 0\.927\.3​M27\.3\\mathrm\{M\}5\.8​M5\.8\\mathrm\{M\}MindSkillEvolve\-Sup\.57\.2±2\.457\.2\\pm 2\.425\.2​M25\.2\\mathrm\{M\}5\.5​M5\.5\\mathrm\{M\}The results show that skill evolution consistently improves task success rate over both no\-skill execution and the unevolved initial skill\. MindSkillEvolve\-Unsup\. improves success rate from51\.3%51\.3\\%to55\.3%55\.3\\%, indicating that execution traces alone already provide useful signals for refining procedural spreadsheet knowledge\. MindSkillEvolve\-Sup\. further improves success rate to57\.2%57\.2\\%by incorporating task scores as supervision\. Notably, Init\-skill performs worse than No\-skill, which is consistent with the observation in SkillGrad\[[26](https://arxiv.org/html/2608.12428#bib.bib33)\]: an unoptimized initial skill may introduce misleading procedures or unnecessary constraints before it is adapted to the target task distribution\.

## 5Case Studies

### 5\.1Dreaming

We examine a representative case from the MemoryAgentBench\[[11](https://arxiv.org/html/2608.12428#bib.bib35)\]conflict\-resolution benchmark\. This benchmark evaluates whether a memory system can update its effective belief state when a newer memory contradicts an earlier one\. The benchmark defines the most recently ingested fact as the ground truth, even when that fact conflicts with real\-world knowledge\. For the queryWhat is Nobuhiro Watsuki famous for?, the dataset expectsThe Fairly OddParentsunder its temporal ordering\. Before dreaming, the answer model instead returnedRurouni Kenshin; after dreaming, it returned the expected answer\. The case therefore tests temporal memory consolidation rather than factual recall from the base language model\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/dreaming_case.png)Figure 12:Conceptual overview of the dreaming pipeline\. Before dreaming, conflicting active memories can be retrieved together\. Dreaming detects the conflict within an entity\-centered scope, archives the superseded memory, and records asupersedesrelation so that subsequent retrieval returns an unambiguous active context\.#### Memory state before dreaming\.

The left panel of Figure[12](https://arxiv.org/html/2608.12428#S5.F12)shows the accumulated memory state before dreaming\. The entitynobuhiro\_watsukiis connected to three active memories throughMENTIONSedges\. Two of them form the relevant conflict for the query: M1 states that Nobuhiro Watsuki is famous forThe Fairly OddParents, while M2 states that he is famous forRurouni Kenshin\. Both memories assert the same predicate, “is famous for,” but provide different objects\. M3 is also connected to the same entity, but it describes a different relation and should not compete as an answer candidate for this query\. When the query was executed against this state, retrieval returned both M1 and M2\. Because the retrieved context did not expose an explicit consolidation decision, the answer model selectedRurouni Kenshin, which matches real\-world knowledge but is incorrect under the benchmark’s temporal ordering\.

#### Dreaming consolidation\.

The middle panel of Figure[12](https://arxiv.org/html/2608.12428#S5.F12)summarizes the offline dreaming process\. Dreaming starts from recently written or unconsolidated memories and expands overMENTIONSedges to form an entity\-centered scope\. In this case, the scope contains the conflicting pair M1–M2 together with the non\-conflicting same\-entity memory M3\.

The first LLM pass performs relation detection and recognizes that M1 and M2 are competing answers to the same question: what Nobuhiro Watsuki is famous for\. M3 is left outside the issue group because it describes a different relation rather than an alternative answer to this query\. The second LLM pass performs action planning\. Since M1 was ingested later than M2, the planner applies the benchmark’s temporal supersede rule and selects M1 as the authoritative active memory\. The resulting consolidation plan sets M2’s status toarchived, creates aRELATED\_TO \[supersedes\]edge from M1 to M2, and preserves consolidation provenance by linking the action to the source add records\. The right panel of Figure[12](https://arxiv.org/html/2608.12428#S5.F12)shows the consolidated state: M1 remains active, M2 is archived, and the dashedsupersedesedge records that the newer memory replaces the earlier conflicting memory\.

#### Retrieval outcome\.

After dreaming, the same query was re\-executed\. Because archived memories are excluded from active retrieval, the answer model received only one active candidate for the “famous for” predicate: M1, which states that Nobuhiro Watsuki is famous forThe Fairly OddParents\. Other retrieved memories, such as M3, may still be present through the shared entity, but they describe different relations and do not directly answer the query\. With the conflicting earlier fact removed from the active context, the answer model producedThe Fairly OddParents, matching the benchmark ground truth\. This case illustrates the main benefit of dreaming: the system does not rely on the answer model to compare timestamps or resolve contradictions during generation\. Instead, temporal conflict resolution is converted into persistent memory state—an archived node plus a typedsupersedesedge—so ordinary retrieval returns a cleaner context for this query\.

### 5\.2Feedback

We examine a PersonaMem\[[14](https://arxiv.org/html/2608.12428#bib.bib18)\]feedback\-consistency item whose query asks:She has a free Saturday afternoon and wants a little social time without draining herself\. Which invitation would she be most likely to say yes to?Option A is an impromptu one\-on\-one thrift\-store browse and coffee with no fixed end time and an easy exit if she gets tired\. Option B is a relaxed board\-game afternoon with two or three friends\. The ground truth is Option A\. Using memories generated by the MindVanilla memory\-add pipeline, the answer model incorrectly selects Option B; after feedback, it selects the correct Option A\.

#### Conversation evidence and feedback\.

The history shows that the user still wants social connection but prefers low\-pressure, adjustable, and less group\-intensive activities\. For example, she says, “If she asked me to just get tea one\-on\-one, I’d probably feel relieved\. The big dinner is what feels impossible\.” She also notes that answering “maybe” and deciding at the last minute increases her anxiety and may appear flaky\. The durable preference is therefore flexibility with a clear, manageable plan, rather than indiscriminately delaying decisions:

> The user prefers low\-pressure, adjustable social activities; compared with group gatherings, one\-on\-one plans with an easy exit are more manageable when her energy drops\.

The user’s concern about appearing unreliable or uncaring applies specifically when explaining or modifying plans with friends\. Feedback therefore generates a conditioned communication memory without making the underlying social preference scenario\-specific:

> When helping the user explain social\-planning preferences to friends, frame the need as a preference for flexible, low\-pressure activities, not as unreliability or lack of care\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/feedback_case.png)Figure 13:Feedback enriches the top\-10 retrieval context and shifts the answer from Option B to the ground\-truth Option A\.
#### Changes in top\-10 retrieval\.

In the MindVanilla top\-10, the most relevant memories state:

> The user has been wanting to meet more people and get out of the house more\. The user wants a simple weekend planning system that still feels flexible\.

These memories capture social interest and flexibility separately, but do not clearly specify the preferred social format\. The model consequently selects Option B, a relaxed but still group\-based activity\.

After feedback, the top\-10 contains the new communication memory together with more specific evidence, including:

> The user feels overwhelmed by constant group chats and social plans locked in days ahead, and would rather leave room to adjust\. When helping the user decline or modify social plans, be warm and clear rather than leaving the decision as a vague “maybe\.”

Together, these memories provide a clearer decision boundary: the user wants social connection, but prefers one\-on\-one, low\-pressure, adjustable, and easy\-to\-exit activities\. Option A satisfies these conditions, whereas Option B remains group\-based\. The answer therefore changes from B to A, moving question\-level correctness from 0 to 1\. This single case illustrates the retrieval mechanism but does not by itself establish an aggregate benchmark gain\.

### 5\.3MindMemEvolve

We evaluate MindMemEvolve on the PersonaMem benchmark introduced in Section 4\.1\. For this experiment, we first cluster the dialogue sessions by semantic similarity and randomly select 12 clusters, comprising 196 QA pairs, as the training set\. The remaining 393 QA pairs constitute the test set\. To isolate the effect of MindSchema and MindMemEvolve, we disable the episodic fallback mechanism and the default catch\-all property, restricting memory extraction to schema\-defined entities and properties\. This ablation necessarily yields a lower pass rate than the full MindMemOS configuration\.

#### Bootstrap schema\.

The bootstrap schema𝒮0\\mathcal\{S\}\_\{0\}is a minimal manually\-authored template: a singleuserentity with one static property \(name\) and two dynamic properties—mood\_feature\(inferred emotional state\) andhabit\_feature\(inferred behavioral pattern\)\. Despite its simplicity, this design is sufficiently expressive to seed the evolutionary process\.

#### Evolution setup and results\.

MindMemEvolve runs for 5 epochs with 12 steps per epoch \(one per cluster\), using a population size ofK=10K=10\. On the training set, the bootstrap schema achieves60\.20%60\.20\\%accuracy; the best\-evolved schema after epoch 5 reaches64\.28%64\.28\\%\.

Best schema selection is based solely on training\-set fitness\. On the held\-out test set of 393 QA pairs, the bootstrap schema achieves61\.07%61\.07\\%, while the best\-evolved schema attains64\.63%64\.63\\%—a gain of3\.563\.56percentage points\. These results demonstrate modest but consistent improvement together with reasonable generalization\. The limited margin is partly attributable to PersonaMem’s reliance on inferential reasoning rather than pure historical information analysis; We are actively seeking more sensitivity\-demanding scenarios to better elucidate the method’s potential\. Figure[14](https://arxiv.org/html/2608.12428#S5.F14)summarizes these findings\.

![Refer to caption](https://arxiv.org/html/2608.12428v1/figures/memevolve_bar.png)Figure 14:Training and test pass rates of MindMemEvolve on PersonaMem\.
#### Key evolved properties\.

The evolved schema expands its dynamic properties from 2 to 49, each targeting a narrow facet of user modeling\. Two first\-order properties and two higher\-order properties are listed below to illustrate the mechanism\.

First\-order propertiescapture concrete episodes and explicit facts:activity\_participation\_recorddocuments the user’s engagement in specific routine activities with full contextual detail \(activity name, date, location, companions, role, outcome\), andcreative\_cultural\_activity\_decision\_recordtracks explicit decisions to start, join, pause, or quit creative or cultural pursuits\. These replace the monolithichabit\_featureof𝒮0\\mathcal\{S\}\_\{0\}, whose unstructured text field conflated participation facts with activity preferences and creative decisions\.

Higher\-order propertiessynthesize recurring patterns across multiple first\-order observations\.social\_energy\_management\_stylecaptures the user’s enduring pattern for regulating social exposure, solitude, and recovery time—a trait that no single episode can reveal but that strongly informs personalized recommendations\.novelty\_seeking\_tendencyaggregates evidence across domains \(learning, leisure, travel, food\) into a stable cross\-situational tendency\. This first\-orderversushigher\-order distinction emerges autonomously during evolution: properties requiring multi\-episode synthesis are automatically assignedorder=2\\text\{order\}=2through mutation operations, without manual annotation\.

The full baseline and evolved schemas are provided in Appendix[A](https://arxiv.org/html/2608.12428#A1)\.

### 5\.4Skill Evolution

We compare the skill optimization results produced by MindMemOS on SpreadsheetBench\. This case study focuses on two contrasts: the difference between the original skill and self\-evolved skills, and the difference between unsupervised and supervised self\-evolution\. In the prompts,redmarks rules introduced by self\-evolution relative to the original skill; in the supervised prompt,bluefurther marks rules that appear only after supervised evolution, beyond the unsupervised version\.

#### Original skill\.

The original skill only provides basicopenpyxlandpandasusage and a small number of generic cautions\. It tells the agent how to open, edit, and save a workbook, but it does not cover the failure modes that appear most often in SpreadsheetBench: formulas are not recalculated byopenpyxl,ws\.max\_rowcan be inflated by formatted empty rows, reading and writing on a live worksheet can move rows or overwrite source data, and the saved workbook must be reopened and verified in the same mode used by evaluation\.

#### Unsupervised self\-evolved skill\.

Unsupervised evolution uses execution traces but not task scores\. Its changes mainly come from repeated workflow failures: the agent writes formulas and assumes thatwb\.save\(\)has produced computed results; it treats formula text as numeric values; it reads and writes on a live worksheet during filtering, lookup, sorting, deletion, or expansion tasks; and it only checks whether the script ran successfully instead of reopening the output file for verification\. Compared with the original skill, the unsupervised version distills these experiences into more concrete operational constraints, highlighted inred\.

#### Supervised self\-evolved skill\.

Supervised evolution additionally uses task scores, so it not only summarizes recurring trace patterns but also separates rules that prevent task failures from rules that may damage user intent\. Compared with the unsupervised version, the supervised version emphasizes two boundaries\. The first is the boundary between formulas and hardcoded values, which prevents the skill from sacrificing explicitly requested reusable formulas merely to pass cached\-value evaluation\. The second is the semantic confirmation boundary before writing, which requires multiple concrete examples to confirm source columns, target columns, grouping structure, or mapping relations in complex spreadsheets\. In this prompt,reddenotes evolved rules shared with the unsupervised prompt, whilebluedenotes supervised\-only additions\.

#### Case analysis\.

From the original skill to unsupervised self\-evolution, the main change is a shift from tool API instructions to executable error\-avoidance rules\. Theredrules directly correspond to failures that recur in spreadsheet tasks: empty formula caches, formatted rows that inflatemax\_row, row movement on live worksheets that causes skipped or duplicated writes, merged cells that cannot be assigned directly, and missing post\-save verification\. In other words, unsupervised signals are already sufficient to summarize local failures in trajectories into general operational constraints\.

From unsupervised to supervised evolution, the change is not simply that more rules are added; rather, the rules become more bounded\. After observing task scores, the supervised version avoids overgeneralizing “literal values are easier to pass cached\-value checks” into “all formulas should be hardcoded\.” It therefore addsbluesupervised\-only rules such aspreserve reusable formulas,distinguish formula\-text grading from saved\-value grading, andstate materialization limitations\. At the same time, it strengthens the pre\-write check from a generic “inspect workbook” instruction intoconfirm mappings with at least two concrete source\-to\-target examples, and it expresses dangerous operations asBlacklisted behavior\. This suggests that supervised signals mainly help the skill learn when to apply a rule, when to stop, and how to avoid sacrificing user intent for local scoring gains\.

The full skill contents for all three versions are provided in Appendix[B](https://arxiv.org/html/2608.12428#A2)\.

## 6Conclusion and Future Work

### 6\.1Conclusion

Memory is an important infrastructure component for persistent context management, personalization, and agent adaptation\. In this work, we presented MindMemOS, a portable and self\-evolving memory operating layer that integrates scenario\-adaptive memory modeling, memory generation and retrieval, offline consolidation, and feedback\-driven correction within a shared memory lifecycle\. MindMemEvolve adapts memory schemas using task\-specific validation signals, while MindSkillEvolve transforms accumulated execution trajectories into progressively refined and versioned skills\. Through scenario\-adaptive modeling and compact agentic search, MindMemOS achieves state\-of\-the\-art performance under the reported evaluation protocols, particularly on multi\-hop questions that require synthesizing evidence distributed across multiple memories\. Dreaming and feedback further support the consolidation, correction, and traceable maintenance of accumulated information\. Evaluations across dialogue memory, personalization, memory consolidation, and task execution, together with representative case studies, demonstrate the effectiveness of MindMemOS under the evaluated settings\.

### 6\.2Future Work

In future work, we will focus on the following directions:

#### Experience\-to\-Skill Evolution\.

Future work will further connect experiential memory with the skill system by synthesizing execution trajectories, tool\-use records, failures, and user corrections into reusable skills\. These skills can be continuously validated and refined based on execution outcomes, improving task success and knowledge transfer across related tasks\.

#### File\-System\-Level Memory Management\.

We also plan to incorporate files and documents as first\-class memory artifacts, linking their content, metadata, versions, and provenance to the memory structure\. This extension will support incremental indexing, cross\-file reasoning, and traceable updates between source files and derived memories\.

## 7Author Contributions

#### Author List\.

Kaichao Liang1, Yuqi Cui1, Hao Kong1, Xinyuan Huang1, Guohaotian Hou1, Qingcan Kang1, Liang Chen1, Yiyang Yin1, Ke Ye1, Jiaquan Guo1, Da Chen1, Xinduo Liu1, Lingan Zeng1, Yixing Peng1, Rong Yao1, Shixiong Kai1,\*, Mingxuan Yuan1,\*\.

1Noah’s Ark Lab, Huawei Technologies\.\*Project Leader\. Corresponding author

#### Division of Work\.

- •MindSchema:Kaichao Liang, Yiyang Yin\.
- •Scenario\-Adaptive Memory Modeling:Kaichao Liang\.
- •Prototype:Kaichao Liang, Yiyang Yin, Qingcan Kang, Lingan Zeng, Yixing Peng\.
- •MindVanilla:Hao Kong, Liang Chen\.
- •Dreaming & Feedback:Yuqi Cui, Xinyuan Huang, Guohaotian Hou\.
- •MindSkillEvolve:Yuqi Cui, Ke Ye\.
- •Product Design & Engineering:Yuqi Cui, Kaichao Liang, Hao Kong, Xinyuan Huang, Guohaotian Hou, Qingcan Kang, Liang Chen, Yiyang Yin, Ke Ye, Jiaquan Guo, Da Chen, Xinduo Liu, Lingan Zeng, Yixing Peng, Rong Yao\.
- •Technical Leads:Shixiong Kai, Mingxuan Yuan\.

## References

- \[1\]AnomalyCo\(2026\)OpenCode\.Note:[https://github\.com/anomalyco/opencode](https://github.com/anomalyco/opencode)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[2\]Anthropic\(2025\)Claude Code\.Note:[https://docs\.anthropic\.com/en/docs/claude\-code/overview](https://docs.anthropic.com/en/docs/claude-code/overview)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[3\]A\. Behrouz, M\. Razaviyayn, P\. Zhong, and V\. Mirrokni\(2025\)Nested Learning: The Illusion of Deep Learning Architectures\.InAdvances in Neural Information Processing Systems 38 \(NeurIPS 2025\),Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[4\]A\. Bering\(2026\)ZenBrain: A Neuroscience\-Inspired 7\-Layer Memory Architecture for Autonomous AI Systems\.Note:[https://arxiv\.org/abs/2604\.23878](https://arxiv.org/abs/2604.23878)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[5\]P\. Chhikara, D\. Khant, S\. Aryan, T\. Singh, and D\. Yadav\(2025\)Mem0: Building Production\-Ready AI Agents with Scalable Long\-Term Memory\.Note:[https://arxiv\.org/abs/2504\.19413](https://arxiv.org/abs/2504.19413)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1),[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.p1.1),[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.SSS0.Px2.p1.1)\.
- \[6\]FeelingAI Team\(2026\)MemBrain: Agent\-Native Memory for AI Agents\.Note:[https://github\.com/feelingai\-team/MemBrain](https://github.com/feelingai-team/MemBrain)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[7\]J\. Fu, J\. Chen, M\. Wang, A\. He, M\. Sheng, X\. Ke, Y\. Zhu, and Y\. Gao\(2026\)VikingMem: A Memory Base Management System for Stateful LLM\-based Applications\.Note:[https://arxiv\.org/abs/2605\.29640](https://arxiv.org/abs/2605.29640)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[8\]M\. Fu, G\. Zhang, X\. Xue, Y\. Li, Z\. He, S\. Huang, X\. Qu, Y\. Cheng, and Y\. Yang\(2026\)LatentMem: Customizing Latent Memory for Multi\-Agent Systems\.Note:[https://arxiv\.org/abs/2602\.03036](https://arxiv.org/abs/2602.03036)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[9\]B\. J\. Gutiérrez, Y\. Shu, W\. Qi, S\. Zhou, and Y\. Su\(2025\)From RAG to Memory: Non\-Parametric Continual Learning for Large Language Models\.Note:[https://arxiv\.org/abs/2502\.14802](https://arxiv.org/abs/2502.14802)Cited by:[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.SSS0.Px2.p1.1)\.
- \[10\]C\. Hu, X\. Gao, Z\. Zhou,et al\.\(2026\)EverMemOS: A Self\-Organizing Memory Operating System for Structured Long\-Horizon Reasoning\.Note:[https://arxiv\.org/abs/2601\.02163](https://arxiv.org/abs/2601.02163)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1),[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.SSS0.Px1.p1.1),[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.p1.1)\.
- \[11\]Y\. Hu, Y\. Wang, and J\. McAuley\(2026\)Evaluating Memory in LLM Agents via Incremental Multi\-Turn Interactions\.InThe Fourteenth International Conference on Learning Representations,External Links:[Link](https://openreview.net/forum?id=DT7JyQC3MR)Cited by:[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.SSS0.Px2.p1.1),[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.p1.1),[§5\.1](https://arxiv.org/html/2608.12428#S5.SS1.p1.1)\.
- \[12\]W\. Huang, W\. Zhang, Y\. Liang,et al\.\(2026\)Rethinking Memory Mechanisms of Foundation Agents in the Second Half: A Survey\.Note:[https://arxiv\.org/abs/2602\.06052](https://arxiv.org/abs/2602.06052)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[13\]S\. Ji, B\. Wu, Z\. Wang, L\. Xia, Q\. Li, R\. Wang, W\. Ding, Z\. Zhu, B\. Li, G\. Dai, and Y\. Wang\(2026\)Infini Memory: Maintainable Topic Documents for Long\-Term LLM Agent Memory\.Note:[https://arxiv\.org/abs/2606\.10677](https://arxiv.org/abs/2606.10677)Cited by:[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.SSS0.Px2.p1.1)\.
- \[14\]B\. Jiang, Z\. Hao, Y\. Cho, B\. Li, Y\. Yuan, S\. Chen, L\. Ungar, C\. J\. Taylor, and D\. Roth\(2025\)Know Me, Respond to Me: Benchmarking LLMs for Dynamic User Profiling and Personalized Responses at Scale\.Note:[https://arxiv\.org/abs/2504\.14225](https://arxiv.org/abs/2504.14225)Cited by:[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.SSS0.Px2.p1.1),[§5\.2](https://arxiv.org/html/2608.12428#S5.SS2.p1.1)\.
- \[15\]Q\. Kang, M\. Liu, S\. Kai, K\. Liang, Z\. Tang, Y\. Cui, T\. Zhong, and M\. Yuan\(2026\)Retain or Consolidate? Budget\-Dependent Operator Selection for Language Agent Memory\.Note:[https://arxiv\.org/abs/2607\.17545](https://arxiv.org/abs/2607.17545)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p4.1)\.
- \[16\]Q\. Kang, L\. Mingyang, S\. Kai, K\. Liang, T\. Zhong, and M\. Yuan\(2026\)Learning What to Remember: Observability\-Safe Memory Retention via Constrained Optimization for Long\-Horizon Language Agents\.Note:[https://arxiv\.org/abs/2606\.10616](https://arxiv.org/abs/2606.10616)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p4.1)\.
- \[17\]Z\. Li, C\. Xi, C\. Li,et al\.\(2025\)MemOS: A Memory OS for AI System\.Note:[https://arxiv\.org/abs/2507\.03724](https://arxiv.org/abs/2507.03724)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1),[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.p1.1)\.
- \[18\]Z\. Ma, B\. Zhang, J\. Zhang, J\. Yu, X\. Zhang, X\. Zhang, S\. Luo, X\. Wang, and J\. Tang\(2024\)SpreadsheetBench: Towards Challenging Real World Spreadsheet Manipulation\.arXiv preprint arXiv:2406\.14991\.Cited by:[§4\.3](https://arxiv.org/html/2608.12428#S4.SS3.SSS0.Px1.p2.1)\.
- \[19\]A\. Maharana, D\. Lee, S\. Tulyakov, F\. Barbieri, Y\. Fang, and M\. Bansal\(2024\)Evaluating Very Long\-Term Conversational Memory of LLM Agents\.Note:[https://arxiv\.org/abs/2402\.17753](https://arxiv.org/abs/2402.17753)Cited by:[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.SSS0.Px1.p1.1)\.
- \[20\]NevaMind\-AI\(2025\)memU: Your Personal Memory, Across Every Agent\.Note:[https://github\.com/NevaMind\-AI/memU](https://github.com/NevaMind-AI/memU)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1),[§4\.1](https://arxiv.org/html/2608.12428#S4.SS1.p1.1)\.
- \[21\]OpenAI\(2025\)OpenAI Codex CLI\.Note:[https://github\.com/openai/codex](https://github.com/openai/codex)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[22\]OpenClaw Team\(2026\)OpenClaw: An Open Platform for AI Agent Task Execution\.Note:[https://docs\.openclaw\.ai/](https://docs.openclaw.ai/)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[23\]Z\. Peiet al\.\(2025\)SCOPE: Prompt Evolution for Enhancing Agent Effectiveness\.Note:[https://arxiv\.org/abs/2512\.15374](https://arxiv.org/abs/2512.15374)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[24\]H\. Qian, Z\. Liu, P\. Zhang, K\. Mao, D\. Lian, Z\. Dou, and T\. Huang\(2025\)MemoRAG: Boosting Long Context Processing with Global Memory\-Enhanced Retrieval Augmentation\.InProceedings of the ACM on Web Conference 2025,pp\. 2366–2377\.External Links:[Document](https://dx.doi.org/10.1145/3696410.3714805)Cited by:[§4\.2](https://arxiv.org/html/2608.12428#S4.SS2.SSS0.Px2.p1.1)\.
- \[25\]P\. Rasmussen, P\. Paliychuk, T\. Beauvais, J\. Ryan, and D\. Chalef\(2025\)Zep: A Temporal Knowledge Graph Architecture for Agent Memory\.Note:[https://arxiv\.org/abs/2501\.13956](https://arxiv.org/abs/2501.13956)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[26\]H\. Wang, Y\. Lan, B\. Cao, L\. Lin, and J\. Chen\(2026\)SkillGrad: Optimizing Agent Skills Like Gradient Descent\.Note:[https://arxiv\.org/abs/2605\.27760](https://arxiv.org/abs/2605.27760)Cited by:[§4\.3](https://arxiv.org/html/2608.12428#S4.SS3.SSS0.Px1.p3.1),[§4\.3](https://arxiv.org/html/2608.12428#S4.SS3.SSS0.Px2.p1.1)\.
- \[27\]Y\. Wang, X\. Chen, R\. Takanobu, Z\. Liang,et al\.\(2025\)Mirix: Multi\-Agent Memory System for LLM\-Based Agents\.Note:[https://arxiv\.org/abs/2507\.07957](https://arxiv.org/abs/2507.07957)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[28\]Y\. Wang, Y\. Gao, X\. Chen, H\. Jiang, S\. Li, J\. Yang, Q\. Yin, Z\. Li, X\. Li, B\. Yin, J\. Shang, and J\. McAuley\(2024\)MemoryLLM: Towards Self\-Updatable Large Language Models\.InProceedings of the 41st International Conference on Machine Learning \(ICML\),Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[29\]X\. Xu\(2026\)G\-MemLLM: Gated Latent Memory Augmentation for Long\-Context Reasoning in Large Language Models\.Note:[https://arxiv\.org/abs/2602\.00015](https://arxiv.org/abs/2602.00015)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[30\]G\. Zhang, M\. Fu, G\. Wan, M\. Yu, K\. Wang, and S\. Yan\(2025\)G\-Memory: Tracing Hierarchical Memory for Multi\-Agent Systems\.InAdvances in Neural Information Processing Systems \(NeurIPS\), Spotlight,Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[31\]G\. Zhang, M\. Fu, and S\. Yan\(2026\)MemGen: Weaving Generative Latent Memory for Self\-Evolving Agents\.InThe Fourteenth International Conference on Learning Representations \(ICLR\),Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[32\]G\. Zhang, H\. Ren, C\. Zhan, Z\. Zhou, J\. Wang, H\. Zhu, W\. Zhou, and S\. Yan\(2025\)MemEvolve: Meta\-Evolution of Agent Memory Systems\.Note:[https://arxiv\.org/abs/2512\.18746](https://arxiv.org/abs/2512.18746)Accepted at ICML 2026Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[33\]H\. Zhang, Q\. Long, J\. Bao, T\. Feng, W\. Zhang, H\. Yue, and W\. Wang\(2026\)MemSkill: Learning and Evolving Memory Skills for Self\-Evolving Agents\.Note:[https://arxiv\.org/abs/2602\.02474](https://arxiv.org/abs/2602.02474)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[34\]S\. Zhang, J\. Wang, R\. Zhou, J\. Liao, Y\. Feng, Z\. Li, Y\. Zheng, W\. Zhang, Y\. Wen, Z\. Li, F\. Xiong, Y\. Qi, B\. Tang, and M\. Wen\(2026\)MemRL: Self\-Evolving Agents via Runtime Reinforcement Learning on Episodic Memory\.Note:[https://arxiv\.org/abs/2601\.03192](https://arxiv.org/abs/2601.03192)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.
- \[35\]X\. Zhang, G\. Wang, Y\. Cui, W\. Qiu, Z\. Li, B\. Zhu, and P\. He\(2026\)Experience Compression Spectrum: Unifying Memory, Skills, and Rules in LLM Agents\.Note:[https://arxiv\.org/abs/2604\.15877](https://arxiv.org/abs/2604.15877)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[36\]Z\. Zhang, Q\. Dai, X\. Bo, C\. Ma, R\. Li, X\. Chen, J\. Zhu, Z\. Dong, and J\. Wen\(2025\)A Survey on the Memory Mechanism of Large Language Model\-based Agents\.ACM Transactions on Information Systems\.Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p1.1)\.
- \[37\]A\. Zhao, D\. Huang, Q\. Xu, M\. Lin, Y\. Liu, and G\. Huang\(2024\)ExpeL: LLM Agents Are Experiential Learners\.InProceedings of the AAAI Conference on Artificial Intelligence,Vol\.38,pp\. 19632–19642\.Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p3.1)\.
- \[38\]T\. Zhao and L\. Jones\(2026\)Fast\-weight Product Key Memory\.arXiv preprint arXiv:2601\.00671\.External Links:[Link](https://arxiv.org/abs/2601.00671)Cited by:[§1](https://arxiv.org/html/2608.12428#S1.p2.1)\.

## Appendix ASchema Definitions for MindMemEvolve Case Study

### Baseline Schema \(𝒮0\\mathcal\{S\}\_\{0\}\)

Baseline Schema𝒮0\\mathcal\{S\}\_\{0\}\(2 dynamic properties\)\{"entity\_type": "user","entity\_instruction": "Two kinds of properties: XXX\_event / XXX\_record = \[Factual Record\]; XXX\_feature = \[Analytical Summary\]\. Infer implicit attitudes from behavioral signals\.","static\_property": \{ "name": "User name or identifier" \},"dynamic\_property": \{"first\_order": \["mood\_feature","habit\_feature"\]\}\}

### Evolved Schema \(𝒮∗\\mathcal\{S\}^\{\*\}\)

Evolved Schema𝒮∗\\mathcal\{S\}^\{\*\}— 49 dynamic properties\{"entity\_type": "user","entity\_instruction": "Maintain exactly one user entity per conversation\. Properties are divided into first\_order \(single\-episode facts\) and higher\_order \(cross\-episode syntheses\)\. Every property value must be an atomic, evidence\-grounded, semantically complete sentence\.","static\_property": \{ "name": "User name or identifier" \},"dynamic\_property": \{// \-\-\- First\-order: single\-episode facts \(41 properties\) \-\-\-"first\_order": \["activity\_participation\_record","creative\_cultural\_activity\_decision\_record","participation\_format\_preference\_feature","activity\_fit\_preference\_feature","explicit\_preference\_transition\_record","shared\_activity\_transition\_record","leisure\_environment\_fit\_feature","recommendation\_relevance\_profile\_feature","engagement\_reward\_driver\_feature","domain\_social\_exchange\_orientation\_feature","pursuit\_engagement\_record","interest\_engagement\_trajectory\_record","narrative\_interpretive\_engagement\_feature","pursuit\_engagement\_lifecycle\_record","creative\_format\_transition\_record","participation\_role\_comfort\_feature","pursuit\_lifecycle\_record","supportive\_discussion\_norm\_preference\_feature","learning\_engagement\_preference\_feature","expressive\_processing\_fit\_feature","creative\_life\_feature","learning\_format\_affinity\_feature","peer\_learning\_collaboration\_record","creative\_structure\_spontaneity\_fit\_feature","creative\_workflow\_preference\_feature","learning\_preference\_feature","narrative\_media\_self\_reflection\_feature","learning\_method\_trial\_record","contextual\_interpretive\_analysis\_feature","feedback\_motivation\_sensitivity\_feature","creative\_project\_record","expressive\_feedback\_impact\_record","creative\_critique\_orientation\_feature","knowledge\_sharing\_initiative\_record","informational\_learning\_impact\_record","information\_response\_record","information\_effect\_record","personal\_health\_status\_record","child\_development\_guidance\_motivation\_feature","residence\_situation\_record","work\_education\_status\_record"\],// \-\-\- Higher\-order: cross\-episode syntheses \(8 properties\) \-\-\-"higher\_order": \["social\_energy\_management\_style","novelty\_seeking\_tendency","commitment\_sustainability\_pattern","self\_reflection\_orientation","decision\_making\_style","resilience\_adaptation\_pattern","autonomy\_orientation","generativity\_orientation"\]\}\}

## Appendix BFull Skill Contents for Skill Evolution Case Study

This appendix provides the complete skill contents referenced in the Skill Evolution case study \(Section[5\.4](https://arxiv.org/html/2608.12428#S5.SS4)\)\. Text inredmarks rules introduced by self\-evolution relative to the original skill; in the supervised prompt,bluefurther marks rules that appear only after supervised evolution\.

Initial Skill for SpreadsheetBench— name: xlsx description: Use this skill whenever the user wants to do anything with Excel spreadsheet files \(\.xlsx, \.xls, \.csv\)\. This includes reading data, writing formulas, manipulating cells, formatting, filtering, creating charts, pivot tables, and any spreadsheet automation tasks\. — \# Excel Spreadsheet Processing Use ‘openpyxl‘ to read and write \.xlsx files\. \#\# Quick Start “‘python from openpyxl import load\_workbook wb = load\_workbook\(”input\.xlsx”\) ws = wb\[”Sheet1”\] value = ws\[”A1”\]\.value ws\[”B2”\] = 42 ws\[”C2”\] = ”=SUM\(A2:B2\)” wb\.save\(”output\.xlsx”\) “‘ Use this for direct cell edits, formula updates, and simple workbook changes\. \#\# Reading Data with pandas “‘python import pandas as pd df = pd\.read\_excel\(’file\.xlsx’\) \# First sheet all\_sheets = pd\.read\_excel\(’file\.xlsx’, sheet\_name=None\) \# All sheets as dict “‘ \#\# Common Pitfalls \- \*\*Cell indices are 1\-based\*\*: ‘ws\.cell\(row=1, column=1\)‘ is A1\. \- \*\*‘data\_only=True‘ destroys formulas on save\*\*: Use a separate workbook object for reading calculated values\. \- \*\*‘ws\.max\_row‘ overcounts\*\*: May include formatted\-but\-empty rows\. Scan the column to find the last non\-empty cell when you need the true data range\.

Evolved Skill by MindMemOS\-unsup— name: xlsx description: Use this skill whenever the user wants to do anything with Excel spreadsheet files \(\.xlsx, \.xls, \.csv\)\. This includes reading data, writing formulas, manipulating cells, formatting, filtering, creating charts, pivot tables, and any spreadsheet automation tasks\. — \# Excel Spreadsheet Processing Use ‘openpyxl‘ to read and write \.xlsx files\. If the workbook will be judged from saved/cached values, write computed literal values in Python\. Only write formulas when you know Excel will recalculate them on open\. Never assume wb\.save\(\) computes formulas\. High\-risk action: do not silently replace a user\-requested reusable formula with hardcoded values unless the task is explicitly graded from saved cached values or recalculation is unavailable\. \- \*\*High\-risk action: do not leave formula cells as the only source of truth when the workbook will be checked from saved/displayed values\.\*\* If you cannot guarantee recalculation on open, compute the result in Python and write literal values instead\. If the task will be judged from the saved workbook’s displayed/cached values, write the final computed value directly into the cell\. After saving, reopen with ‘data\_only=True‘ to confirm the stored value is present\. \#\# Quick Start “‘python from openpyxl import load\_workbook wb = load\_workbook\(”input\.xlsx”\) ws = wb\[”Sheet1”\] value = ws\[”A1”\]\.value ws\[”B2”\] = 42 ws\[”C2”\] = ”=SUM\(A2:B2\)” wb\.save\(”output\.xlsx”\) “‘ Use this for direct cell edits, formula updates, and simple workbook changes\. High\-risk action: do not mutate openpyxl style objects in place; create a new ‘PatternFill‘/‘Border‘ or ‘copy\(\)‘ the style, then assign it back to the cell\. For filtering, lookup, mapping, row moves, deduping, or sorting, first read the full source table into Python, confirm headers and the true data extent, compute the result in memory, and write once\. If source cells may contain formulas, read them in two separate passes: one normal load for formula text, and one ‘data\_only=True‘ load for cached results\. Never use the same ‘\.value‘ as both a formula string and a computed input\. Do not replace a requested dynamic spreadsheet behavior with one\-off hardcoded outputs; this can make current cells look correct but break the workbook when inputs change\. \- \*\*For deletions, insertions, row duplication, or ”expand each row” tasks, read the full source rows into Python, compute the transformed table in memory, then clear and rewrite the destination range once\.\*\* \#\# Before Editing \- \*\*Before writing into a target range, inspect ‘ws\.merged\_cells\.ranges‘\.\*\* Never assign to a merged placeholder cell \(‘MergedCell‘\)\. \- Do not rely on ‘ws\.max\_row‘ when empty formatted rows may exist\. Scan upward from the bottom to find the last row with any non\-empty relevant cell\. \- If the target sheet, range, or transformation pattern is not fully explicit, do a read\-only inspection pass first and confirm the real data extent, headers, and any example mappings before writing\. \- After saving, reopen the file twice when needed: once normally to confirm formulas/styles, and once with ‘data\_only=True‘ to confirm displayed values\. \#\# Common Pitfalls \- \*\*Cell indices are 1\-based\*\*: ‘ws\.cell\(row=1, column=1\)‘ is A1\. \- \*\*‘data\_only=True‘ destroys formulas on save\*\*: Use a separate workbook object for reading calculated values\. \- \*\*Never treat a formula cell’s ‘\.value‘ as a plain literal when the workbook contains formulas\.\*\* \- Do not trust ‘ws\.max\_row‘ alone\. To find the real data extent, scan upward from the bottom until the last row with any non\-empty cell\. \- If the task includes formatting or structural edits, verify those changes with a normal workbook reload; ‘data\_only=True‘ only confirms values, not formatting\. \- Do not use a ‘data\_only=True‘ workbook as the source for edits\.

Evolved Skill by MindMemOS\-sup— name: xlsx description: Use this skill whenever the user wants to do anything with Excel spreadsheet files \(\.xlsx, \.xls, \.csv\)\. This includes reading data, writing formulas, manipulating cells, formatting, filtering, creating charts, pivot tables, and any spreadsheet automation tasks\. — \# Excel Spreadsheet Processing Use ‘openpyxl‘ to read and write \.xlsx files\. If the workbook will be judged from saved/cached values, write computed literal values in Python\. Only write formulas when you know Excel will recalculate them on open\. Never assume wb\.save\(\) computes formulas\. High\-risk action: do not silently replace a user\-requested reusable formula with hardcoded values unless the task is explicitly graded from saved cached values or recalculation is unavailable\. \*\*If the user explicitly asks for a reusable formula, do not silently replace it with hardcoded values\.\*\* Before writing, decide whether the grader will check formula text or saved cell values\. If cached values are graded and recalculation on open is not confirmed, materialize literal results in Python and state that limitation in the final note\. If reusable formulas are explicitly required, preserve formulas\. If reusable formulas are required and recalculation on open is not confirmed, do not silently materialize values; instead, write the formula, verify it separately with a ‘data\_only=True‘ read, and state that cached results may not update until Excel recalculates\. \*\*If the user asks to fix or rewrite formulas, do not silently replace them with literal values just because cached values are graded\.\*\* If the user’s instruction or example could be interpreted more than one way, do a read\-only check against at least 2 concrete examples and resolve the exact semantics before writing\. \#\# Quick Start “‘python from openpyxl import load\_workbook wb = load\_workbook\(”input\.xlsx”\) ws = wb\[”Sheet1”\] value = ws\[”A1”\]\.value ws\[”B2”\] = 42 ws\[”C2”\] = ”=SUM\(A2:B2\)” wb\.save\(”output\.xlsx”\) “‘ Use this for direct cell edits, formula updates, and simple workbook changes\. For any nontrivial write, do a read\-only pass that confirms: \(a\) the true used range, \(b\) the header row, \(c\) merged cells, and \(d\) at least 2 concrete source\-to\-target examples\. For any transformation that changes row order, filters rows, dedupes, expands rows, or maps one table to another, first do a read\-only inspection pass to confirm the true data bounds, header row, merged cells, and at least 2 concrete source\-to\-target examples\. High\-risk action: do not mutate openpyxl style objects in place; create a new ‘PatternFill‘/‘Border‘ or ‘copy\(\)‘ the style, then assign it back to the cell\. For filtering, lookup, mapping, row moves, deduping, sorting, or flattening tasks, first do a read\-only inspection pass, then read the full source table into Python, compute the final output in memory, and write once\. \*\*Blacklisted behavior:\*\* iterating over a live worksheet while simultaneously reading and writing rows/cells for filtering, lookup, deduping, sorting, row moves, deletion/insertion, or row expansion\. \*\*Blacklisted behavior:\*\* replacing a user\-requested reusable formula with hardcoded values, or writing a formula when the task is explicitly graded as final values only, without stating the limitation\. \*\*If a source column may contain formulas, inspect it in two separate passes: load once normally to see formula text, and once with ‘data\_only=True‘ to see cached results\. Before looking up or matching values, verify that the chosen key column actually contains the intended identifiers in the workbook, not a similarly named but different field\. High\-risk action: do not generate or extend formulas by naive string replacement on existing formula text; build each target formula explicitly from the row number\. After saving, reopen the workbook in the mode the grader will use and verify at least 2–3 representative source\-to\-target pairs by actual value or formula text\. \#\# Before Editing \*\*For any task that depends on row/column relationships, month/category grouping, block boundaries, or lookup criteria, do a read\-only inspection pass first and confirm the real headers, data extent, and at least 2 concrete source\-to\-target examples before writing\.\*\* \*\*If the target sheet, range, header row, or data extent is not fully explicit, do a read\-only inspection pass first and confirm the real headers, used range, and any merged cells before writing\.\*\* High\-risk action: do not infer the transformation from a single sample cell, nearby labels, or visible formatting alone\. \*\*Before any transformation, inspect the actual source rows/columns and confirm the real header row, data extent, and at least 2 concrete source\-to\-target examples\.\*\* \*\*Before writing, inspect ‘ws\.merged\_cells\.ranges‘\. Do not assign into a merged placeholder cell \(‘MergedCell‘\)\.\*\* \- If a named sheet, cell, column, header, row, or target range is missing or ambiguous, stop and inspect the workbook contents before editing\. \- If the target sheet, range, or transformation pattern is not fully explicit, do a read\-only inspection pass first and confirm the real data extent, headers, and any example mappings before writing\. \- After reopening the output, verify that the result matches the intended transformation on at least 2–3 representative examples from the source\. \#\# Common Pitfalls \- \*\*Cell indices are 1\-based\*\*: ‘ws\.cell\(row=1, column=1\)‘ is A1\. \- \*\*‘data\_only=True‘ destroys formulas on save\*\*: Use a separate workbook object for reading calculated values\. \- \*\*Never treat a formula cell’s ‘\.value‘ as a plain literal when the workbook contains formulas\.\*\* \- Do not trust ‘ws\.max\_row‘ alone\. To find the real data extent, scan upward from the bottom until the last row with any non\-empty cell\.

## Appendix CMindMemEvolve Algorithms

Algorithm 1MindMemEvolve — LLM\-Guided Evolutionary Schema Optimization1:Training set

𝒟=\{\(𝐜𝐨𝐧𝐭𝐞𝐱𝐭i,qi,ai\)\}i=1N\\mathcal\{D\}=\\\{\(\\mathbf\{context\}\_\{i\},q\_\{i\},a\_\{i\}\)\\\}\_\{i=1\}^\{N\}, initial schema

𝒮0\\mathcal\{S\}\_\{0\}, epochs

EE, clusters

UU, population size

KK, elite fraction

α\\alpha, prune prob\.

pprunep\_\{\\text\{prune\}\}, crossover prob\.

pcrossp\_\{\\text\{cross\}\}
2:Approximately optimal schema

𝒮∗\\mathcal\{S\}^\{\*\}
3:

H←E⋅UH\\leftarrow E\\cdot U⊳\\trianglerightTotal cumulative training steps

4:

ℂ←PartitionClusters​\(𝒟,U\)\\mathbb\{C\}\\leftarrow\\textsc\{PartitionClusters\}\(\\mathcal\{D\},U\)⊳\\trianglerightPartition𝒟\\mathcal\{D\}intoUUclusters

5:for

j←1j\\leftarrow 1to

KKdo

6:

𝒮1,j←RandomMutate​\(𝒮0\)\\mathcal\{S\}\_\{1,j\}\\leftarrow\\textsc\{RandomMutate\}\(\\mathcal\{S\}\_\{0\}\)⊳\\trianglerightKKdiversified individuals from𝒮0\\mathcal\{S\}\_\{0\}

7:endfor

8:for

e←1e\\leftarrow 1to

EEdo

9:for

u←1u\\leftarrow 1to

UUdo

10:

t←\(e−1\)⋅U\+ut\\leftarrow\(e\-1\)\\cdot U\+u⊳\\trianglerightCumulative step index

11:for

j←1j\\leftarrow 1to

KKdo

12:

InitSandbox​\(𝒮t,j\)\\textsc\{InitSandbox\}\(\\mathcal\{S\}\_\{t,j\}\)⊳\\trianglerightClean memory store

13:

AddMemories\(ℂu\.𝐜𝐨𝐧𝐭𝐞𝐱𝐭𝐬,𝒮t,j\)\\textsc\{AddMemories\}\(\\mathbb\{C\}\_\{u\}\.\\\!\\mathbf\{contexts\},\\mathcal\{S\}\_\{t,j\}\)⊳\\trianglerightIngest clusteruu

14:

𝐬←\[\]\\mathbf\{s\}\\leftarrow\[\]
15:for all

\(qi,ai\)∈ℂu\(q\_\{i\},a\_\{i\}\)\\in\\mathbb\{C\}\_\{u\}do

16:

𝐫i←SearchMemories​\(qi,𝒮t,j\)\\mathbf\{r\}\_\{i\}\\leftarrow\\textsc\{SearchMemories\}\(q\_\{i\},\\mathcal\{S\}\_\{t,j\}\)
17:

a^i←GenerateAnswer​\(qi,𝐫i\)\\hat\{a\}\_\{i\}\\leftarrow\\textsc\{GenerateAnswer\}\(q\_\{i\},\\mathbf\{r\}\_\{i\}\)
18:

AppendScore​\(𝐬,ai,a^i\)\\textsc\{AppendScore\}\(\\mathbf\{s\},a\_\{i\},\\hat\{a\}\_\{i\}\)
19:endfor

20:

f​\(𝒮t,j\)←Mean​\(𝐬\)f\(\\mathcal\{S\}\_\{t,j\}\)\\leftarrow\\textsc\{Mean\}\(\\mathbf\{s\}\)
21:endfor

22:

SortDescending​\(\{𝒮t,1,…,𝒮t,K\},f\)\\textsc\{SortDescending\}\(\\\{\\mathcal\{S\}\_\{t,1\},\\dots,\\mathcal\{S\}\_\{t,K\}\\\},f\)
23:

nelite←⌈α⋅K⌉n\_\{\\text\{elite\}\}\\leftarrow\\lceil\\alpha\\cdot K\\rceil
24:for

j←1j\\leftarrow 1to

neliten\_\{\\text\{elite\}\}do

25:

𝒮t\+1,j←𝒮t,j\\mathcal\{S\}\_\{t\+1,j\}\\leftarrow\\mathcal\{S\}\_\{t,j\}⊳\\trianglerightElite preservation

26:endfor

27:for

j←nelite\+1j\\leftarrow n\_\{\\text\{elite\}\}\+1to

KKdo

28:

\(𝒫a,𝒫b\)←TournamentSelect​\(\{𝒮t,j\}j=1K\)\(\\mathcal\{P\}\_\{a\},\\mathcal\{P\}\_\{b\}\)\\leftarrow\\textsc\{TournamentSelect\}\(\\\{\\mathcal\{S\}\_\{t,j\}\\\}\_\{j=1\}^\{K\}\)
29:for all

𝒫∈\{𝒫a,𝒫b\}\\mathcal\{P\}\\in\\\{\\mathcal\{P\}\_\{a\},\\mathcal\{P\}\_\{b\}\\\}do

30:

𝒫←InducedMutate​\(𝒫,ℂu\)\\mathcal\{P\}\\leftarrow\\textsc\{InducedMutate\}\(\\mathcal\{P\},\\mathbb\{C\}\_\{u\}\)
31:

𝒫←InjectPlausibleTypes​\(𝒫\)\\mathcal\{P\}\\leftarrow\\textsc\{InjectPlausibleTypes\}\(\\mathcal\{P\}\)
32:

𝒫←PruneLowFrequency​\(𝒫,pprune\)\\mathcal\{P\}\\leftarrow\\textsc\{PruneLowFrequency\}\(\\mathcal\{P\},p\_\{\\text\{prune\}\}\)
33:endfor

34:

𝒮t\+1,j←CrossoverInsert​\(𝒫a,𝒫b,pcross\)\\mathcal\{S\}\_\{t\+1,j\}\\leftarrow\\textsc\{CrossoverInsert\}\(\\mathcal\{P\}\_\{a\},\\mathcal\{P\}\_\{b\},p\_\{\\text\{cross\}\}\)
35:endfor

36:endfor

37:endfor

38:for

j←1j\\leftarrow 1to

KKdo

39:

f⁡\(𝒮H\+1,j\)←f\(\\mathcal\{S\}\_\{H\+1,j\}\)\\leftarrowevaluate

𝒮H\+1,j\\mathcal\{S\}\_\{H\+1,j\}on full training set

𝒟\\mathcal\{D\}⊳\\trianglerightOver allNNsamples

40:endfor

41:

𝒮∗←arg⁡maxj∈\[1,K\]⁡f⁡\(𝒮H\+1,j\)\\mathcal\{S\}^\{\*\}\\leftarrow\\arg\\max\_\{j\\in\[1,K\]\}\\;f\(\\mathcal\{S\}\_\{H\+1,j\}\)
42:return

𝒮∗\\mathcal\{S\}^\{\*\}