MemEvolve: Meta-Evolution of Agent Memory Systems — part 2/3
Cleaned-text code points [15974, 31214). Bibliography omitted here; source.md includes it.
Based on the above design space, we introduce EvolveLab , a unified and extensible codebase designed for the systematic implementation and evaluation of self-evolving memories, serving as a standardized resource for the community.
Implementation. The cornerstone of EvolveLab is its modular and hierarchical design. Every memory architecture re-implemented in our codebase (see Table 1 ) inherits from a singular abstract base class, BaseMemoryProvider , which enforces the unified four-component interface: ♣ Encode, ♠ Store, ♥ Retrieve, and ♠ Manage. This ensures that diverse memory mechanisms can be managed, modified, and evolved under a consistent programmatic structure. More details on the implementations can be found at Section 8 .
Evaluation. Beyond unified implementation, EvolveLab provides a standardized testbed for rigorously assessing memory architectures across diverse agentic tasks. The framework offers out-of-the-box support for multiple challenging benchmarks, including GAIA ( Mialon et al.,, 2023 ) , xBench ( Chen et al.,, 2025 ) , and DeepResearchBench ( Du et al.,, 2025 ) . EvolveLab accommodates two evaluation paradigms: an ◼ online mode, where the experiential memory base is updated on-the-fly as the agent system processes a continuous stream of tasks, and an ◼ offline mode, where the memory system first accumulates experience from a static set of trajectories before being assessed on separate, unseen tasks. To ensure robust and versatile assessment, we support multiple evaluation protocols, including exact string matching and flexible LLM-as-a-Judge.
## 4 MemEvolve: A Meta-Evolving Memory Framework
### 4.1 Dual-Evolution Process
Traditional self-improving memory systems operate under a fixed memory architecture , where the memory interface Ω \Omega is predefined and remains static. Within this architecture, the agent iteratively populates and updates its memory state M t M_{t} through interaction with the environment and task experiences. For a trajectory τ \tau induced by a query 𝒬 \mathcal{Q} , the memory evolution follows M t + 1 = Ω ( M t , ϵ τ ) , ϵ τ ∈ ℰ ( τ ) , M_{t+1}=\Omega(M_{t},\epsilon_{\tau}),\quad\epsilon_{\tau}\in\mathcal{E}(\tau), where ℰ ( ⋅ ) \mathcal{E}(\cdot) denotes an experience extraction operator that maps a trajectory to a set of experience units, and ϵ τ \epsilon_{\tau} is an element sampled from this set. While this enables the accumulation of knowledge, it fundamentally precludes architectural adaptation , as the memory interface Ω \Omega itself remains immutable.
To transcend this limitation, we propose a dual-evolution process that jointly evolves (i) the agent’s memory base and (ii) the underlying memory architectures (as illustrated in Figure 3 ). Instead of a single static Ω \Omega , we maintain, at each evolutionary iteration k k , a finite set of candidate memory systems { Ω j ( k ) } j ∈ 𝒥 ( k ) \{\Omega_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}} , where each Ω j ( k ) \Omega_{j}^{(k)} is instantiated as a concrete realization of the four-component memory interface Ω j ( k ) ≜ ( ℰ j ( k ) , 𝒰 j ( k ) , ℛ j ( k ) , 𝒢 j ( k ) ) \Omega_{j}^{(k)}\triangleq\big(\mathcal{E}_{j}^{(k)},\mathcal{U}_{j}^{(k)},\mathcal{R}_{j}^{(k)},\mathcal{G}_{j}^{(k)}\big) . The initial iteration start from a singleton set | 𝒥 ( 0 ) | = 1 |\mathcal{J}^{(0)}|=1 , corresponding to a hand-designed baseline memory, while later iterations admit multiple competing candidates. Given a batch of trajectories 𝒯 j ( k ) \mathcal{T}_{j}^{(k)} independently generated by executing the agent with memory system Ω j ( k ) \Omega_{j}^{(k)} , the dual-evolution process consists of two nested loops:
• Inner Loop (Experience Evolution). For each candidate memory system Ω j ( k ) \Omega_{j}^{(k)} , the associated memory state M t , j ( k ) M_{t,j}^{(k)} , initialized as an empty memory at the beginning of iteration k k , is updated along trajectories τ ∈ 𝒯 j ( k ) \tau\in\mathcal{T}_{j}^{(k)} via M t + 1 , j ( k ) = Ω j ( k ) ( M t , j ( k ) , ϵ τ ) , ϵ τ ∈ ℰ j ( k ) ( τ ) . M_{t+1,j}^{(k)}=\Omega_{j}^{(k)}\big(M_{t,j}^{(k)},\epsilon_{\tau}\big),\quad\epsilon_{\tau}\in\mathcal{E}_{j}^{(k)}(\tau). Executing the agent with Ω j ( k ) \Omega_{j}^{(k)} over 𝒯 j ( k ) \mathcal{T}_{j}^{(k)} yields, for each trajectory τ \tau , a feedback vector 𝐟 j ( τ ) ∈ ℝ d \mathbf{f}_{j}(\tau)\in\mathbb{R}^{d} , where d = 3 d=3 corresponds to the number of evaluation metrics ( i.e. , task success, token consumption, and latency). An aggregation operator 𝒮 \mathcal{S} summarizes the inner-loop outcomes for each candidate as 𝐅 j ( k ) = 𝒮 ( { 𝐟 j ( τ ) } τ ∈ 𝒯 j ( k ) ) , j ∈ 𝒥 ( k ) . \mathbf{F}_{j}^{(k)}=\mathcal{S}\big(\{\mathbf{f}_{j}(\tau)\}_{\tau\in\mathcal{T}_{j}^{(k)}}\big),\quad j\in\mathcal{J}^{(k)}.
• Outer Loop (Architectural Evolution). The set of memory architectures is then updated based on the collection of summaries { 𝐅 j ( k ) } j ∈ 𝒥 ( k ) \{\mathbf{F}_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}} . A meta-evolution operator ℱ \mathcal{F} selects high-performing candidates and proposes new variants, producing the next iteration’s candidate set: { Ω j ′ ( k + 1 ) } j ′ ∈ 𝒥 ( k + 1 ) = ℱ ( { Ω j ( k ) } j ∈ 𝒥 ( k ) , { 𝐅 j ( k ) } j ∈ 𝒥 ( k ) ) . \big\{\Omega_{j^{\prime}}^{(k+1)}\big\}_{j^{\prime}\in\mathcal{J}^{(k+1)}}=\mathcal{F}\!\left(\{\Omega_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}},\;\{\mathbf{F}_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}}\right). Specifically, ℱ \mathcal{F} ranks candidates according to 𝐅 j ( k ) \mathbf{F}_{j}^{(k)} , retains the top- K K memory systems, and generates new architectures by modifying or recombining all four components ( ℰ , 𝒰 , ℛ , 𝒢 ) (\mathcal{E},\mathcal{U},\mathcal{R},\mathcal{G}) of the selected candidates, where K K denotes a fixed survivor budget. We detail the implementation of ℱ ( ⋅ ) \mathcal{F}(\cdot) in Section 4.2 .
Unified view. At a higher level, each iteration k k alternates between (i) evolving the memory experience base from an empty initialization under a fixed set of architectures, and (ii) evolving the memory architectures themselves based on the induced performance: ( { ∅ } j ∈ 𝒥 ( k ) , { Ω j ( k ) } j ∈ 𝒥 ( k ) ) → inner ( { M t + 1 , j ( k ) } j ∈ 𝒥 ( k ) , { Ω j ( k ) } j ∈ 𝒥 ( k ) ) → outer ( { M t + 1 , j ( k ) } j ∈ 𝒥 ( k ) , { Ω j ′ ( k + 1 ) } j ′ ∈ 𝒥 ( k + 1 ) ) . \big(\{\varnothing\}_{j\in\mathcal{J}^{(k)}},\,\{\Omega_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}}\big)\;\xrightarrow{\text{inner}}\;\big(\{M_{t+1,j}^{(k)}\}_{j\in\mathcal{J}^{(k)}},\,\{\Omega_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}}\big)\;\xrightarrow{\text{outer}}\;\big(\{M_{t+1,j}^{(k)}\}_{j\in\mathcal{J}^{(k)}},\,\{\Omega_{j^{\prime}}^{(k+1)}\}_{j^{\prime}\in\mathcal{J}^{(k+1)}}\big). By iterating this dual-evolution process, the agent does not merely accumulate experience within a fixed memory system; instead, both the memory base and the governing memory architectures co-evolve, yielding increasingly adaptive and resource-aware memory-driven behavior over time.
### 4.2 Diagnose-and-Design Evolution
We now detail the meta-evolution operator ℱ \mathcal{F} , which governs the architectural update in each evolutionary iteration. Conceptually, ℱ \mathcal{F} decomposes into two coordinated components: (i) architectural selection , which identifies a subset of high-performing memory systems to serve as evolutionary parents, and (ii) diagnose-and-design evolution , which generates new memory architectures from each selected parent through a structured diagnosis procedure followed by a constrained redesign within the modular memory design space.
Architectural Selection. Given the candidate set { Ω j ( k ) } j ∈ 𝒥 ( k ) \{\Omega_{j}^{(k)}\}_{j\in\mathcal{J}^{(k)}} and their corresponding summaries { 𝐅 j ( k ) } \{\mathbf{F}_{j}^{(k)}\} , we define each summary vector as 𝐅 j ( k ) ≜ ( Perf j ( k ) , − Cost j ( k ) , − Delay j ( k ) ) , \mathbf{F}_{j}^{(k)}\triangleq\big(\text{Perf}_{j}^{(k)},\;-\text{Cost}_{j}^{(k)},\;-\text{Delay}_{j}^{(k)}\big), where higher values are preferred in all dimensions. Candidates are first ranked by non-dominated sorting over 𝐅 j ( k ) \mathbf{F}_{j}^{(k)} , yielding a Pareto rank ρ j ( k ) \rho_{j}^{(k)} . Within the same Pareto rank, candidates are further ordered by the primary performance metric Perf j ( k ) \text{Perf}_{j}^{(k)} . The top- K K candidates are selected as the parent set: 𝒫 ( k ) = Top - K j ∈ 𝒥 ( k ) ( ρ j ( k ) , Perf j ( k ) ) . \mathcal{P}^{(k)}=\operatorname*{Top\text{-}K}_{j\in\mathcal{J}^{(k)}}\Big(\rho_{j}^{(k)},\;\text{Perf}_{j}^{(k)}\Big). This selection step ensures that architectural evolution is guided by systems that exhibit favorable trade-offs between task effectiveness and resource efficiency, while prioritizing task performance among Pareto-equivalent candidates.
Diagnose-and-Design Evolution. For each parent architecture Ω p ( k ) ∈ 𝒫 ( k ) \Omega_{p}^{(k)}\in\mathcal{P}^{(k)} , ℱ \mathcal{F} generates a set of S S descendants { Ω p , s ( k + 1 ) } s = 1 S \{\Omega_{p,s}^{(k+1)}\}_{s=1}^{S} through a two-phase process:
• Diagnosis. Each parent architecture is examined using trajectory-level evidence from its own execution batch 𝒯 p ( k ) \mathcal{T}_{p}^{(k)} . For each trajectory, the agent provides outcome statistics (e.g., success indicators, token costs) together with a structured description of the associated task query. A replay interface grants access to the corresponding trajectories τ ∈ 𝒯 p ( k ) \tau\in\mathcal{T}_{p}^{(k)} , enabling targeted inspection of memory behavior, including retrieval failures, ineffective abstractions, or storage inefficiencies. The diagnosis phase thus produces a structured defect profile 𝒟 ( Ω p ( k ) ) \mathcal{D}(\Omega_{p}^{(k)}) , characterizing architectural bottlenecks across the four memory components ( ℰ p ( k ) , 𝒰 p ( k ) , ℛ p ( k ) , 𝒢 p ( k ) ) \big(\mathcal{E}_{p}^{(k)},\mathcal{U}_{p}^{(k)},\mathcal{R}_{p}^{(k)},\mathcal{G}_{p}^{(k)}\big) .
• Design. Conditioned on the defect profile 𝒟 ( Ω p ( k ) ) \mathcal{D}(\Omega_{p}^{(k)}) , a redesigned architecture is constructed by modifying only the permissible implementation sites within the modular interface, thereby ensuring compatibility and isolating architectural changes to the designated design space. The design step produces S S variants by instantiating distinct but valid configurations of the four components: Ω p , s ( k + 1 ) = Design ( Ω p ( k ) , 𝒟 ( Ω p ( k ) ) , s ) , s ∈ { 1 , … , S } . \Omega_{p,s}^{(k+1)}=\operatorname{Design}\!\left(\Omega_{p}^{(k)},\,\mathcal{D}(\Omega_{p}^{(k)}),\,s\right),\quad s\in\{1,\dots,S\}. These variants differ in encoding strategies, storage rules, retrieval constraints, or management policies, yet all conform to the unified memory-system interface and remain executable by the agent.
Resulting update. Aggregating all descendants across parents yields the next set of candidate architectures: { Ω j ′ ( k + 1 ) } j ′ ∈ 𝒥 ( k + 1 ) = ⋃ Ω p ( k ) ∈ 𝒫 ( k ) { Ω p , s ( k + 1 ) } s = 1 S . \{\Omega_{j^{\prime}}^{(k+1)}\}_{j^{\prime}\in\mathcal{J}^{(k+1)}}=\bigcup_{\Omega_{p}^{(k)}\in\mathcal{P}^{(k)}}\;\{\Omega_{p,s}^{(k+1)}\}_{s=1}^{S}. This diagnose-and-design evolution operationalizes ℱ \mathcal{F} for producing increasingly adaptive memory systems, ensuring that architectural updates are both empirically grounded and structurally constrained within the unified design space.
## 5 Experiments
### 5.1 Experiment Setup
Benchmarks. We evaluate the proposed framework across four challenging agentic benchmarks, including GAIA ( Mialon et al.,, 2023 ) , WebWalkerQA ( Wu et al., 2025a, ) , xBench-DeepSearch (xBench-DS) ( Chen et al.,, 2025 ) , as well as TaskCraft ( Shi et al., 2025a, ) . Further statistics and details are provided in Section 9.1 .
Method Configurations. We run the dual-evolution process for K max = 3 K_{\max}=3 iterations. In the outer loop, the survivor budget is set as K = 1 K=1 ; at each iteration, only the top-ranked architecture is retained and expanded to S = 3 S=3 descendants. In the inner loop, each candidate architecture Ω j ( k ) \Omega_{j}^{(k)} is evaluated on a batch 𝒯 j ( k ) \mathcal{T}_{j}^{(k)} of 60 task trajectories, consisting of 40 newly sampled tasks and 20 tasks reused from the previous iteration to stabilize inter-iteration comparison.
Agent Framework. We integrate MemEvolve into two representative agentic frameworks: SmolAgent ( Roucher et al.,, 2025 ) , a lightweight two-agent architecture, and Flash-Searcher ( Qin et al.,, 2025 ) , a high-performance single-agent deep research system. To assess the generalization and plug-and-play capability of MemEvolve , we further evaluate it on two held-out multi-agent systems: Tencent’s Cognitive Kernel-Pro (CK-Pro) ( Fang et al., 2025c, ) , a three-agent framework comprising main/file/web agents; and OWL ( Hu et al., 2025b, ) , a hierarchical system including planner, coordinator, web, document, and coding agents. This diversity in architecture and system complexity enables a comprehensive examination of the adaptability of MemEvolve across heterogeneous agentic scaffolds.
Model Configurations. We instantiate MemEvolve using GPT-5-mini ( OpenAI,, 2025 ) as the LLM backbone for the underlying agentic frameworks, and for supporting the meta-evolution operator ℱ ( ⋅ ) \mathcal{F}(\cdot) . To further evaluate the cross-LLM generalization capability of MemEvolve , we additionally consider alternative backbones, including DeepSeek V3.2 ( DeepSeek-AI et al.,, 2025 ) , and Kimi K2 ( Team et al., 2025a, ) . For clarity, we explicitly report the specific LLM backbone used by each agentic framework in the following experiments.
### 5.2 Main Results
We report the pass@1–3 performance of MemEvolve integrated with SmolAgent and Flash-Searcher in Table 2 , together with its generalization results when paired with unseen LLMs ( Kimi K2 , DeepSeek V3.2 ). Notably, on the relatively simple TaskCraft benchmark, we evolve two distinct memory systems using MemEvolve+ and MemEvolve+ , respectively. These evolved memory systems are then fixed and evaluated on WebWalkerQA and xBench-DS, i.e. , without conducting dataset-specific meta-evolution.
Memory System Matters For Agent Systems. As shown in Table 2 , equipping agentic systems with effective memory architectures is critical to performance. On xBench, + GPT-5-Mini achieves an initial pass@1 of 51 % 51\% ; after integrating MemEvolve , pass@1 increases by 6 % 6\% , while pass@3 goes up to 68.0 % 68.0\% . Similarly, + GPT-5-Mini improves from 69 % 69\% to 74 % 74\% on xBench when augmented with MemEvolve . These results clearly demonstrate the substantial impact of a well-designed memory system on agent performance. At the same time, memory is not a panacea and remains bounded by the capabilities of the underlying agentic framework. On GAIA, MemEvolve + attains a pass@3 of 72.12 % 72.12\% , comparable to AgentKB, while avoiding the construction of large and costly offline knowledge bases. In contrast, the gains with MemEvolve + are even more pronounced, achieving a pass@3 of 80.61 % 80.61\% , surpassing several strong multi-agent systems such as OWL-Workforce and CK-Pro under the same metric.