EvolveLab: Evolving Memory in LLM Agents

• EvolveLab is a unified, modular platform that abstracts memory pipelines into four interchangeable modules, facilitating self-improving agent architectures.
• The framework supports bilevel meta-evolution with inner and outer loops, yielding robust performance improvements and cross-task generalization.
• A standardized API and plug-and-play benchmarking approach enable seamless integration and reproducible evaluation in diverse LLM agent systems.

EvolveLab is a unified, modular codebase and benchmarking substrate for designing, evaluating, and evolving self-improving memory systems in LLM-based agents. Created as the foundation of the MemEvolve meta-evolutionary framework, EvolveLab abstracts twelve representative memory systems into a composable four-stage design space. This enables not only the accumulation and reuse of agent experience but also architectural evolution, supporting robust, generalizable memory strategies across diverse agent frameworks, tasks, and backbones (Zhang et al., 21 Dec 2025).

1. Rationale and Historical Motivation

LLM-based agents benefit substantially from integrated memory systems that record, distill, and retrieve prior experience or reusable artifacts. Previous research established that architectures such as trajectory banks, distilled tool libraries, knowledge graphs, and dynamic cheatsheets can enhance an agent's performance and adaptivity within a task family. However, each system had a fixed memory pipeline with static ingestion and abstraction routines. This design stasis prevented agents from meta-adapting their memory strategies to varying task ecologies, limiting transfer, compositionality, and continual improvement.

EvolveLab was constructed in response to these issues. It provides a standardized, extensible substrate—capable of expressing any memory pipeline as a combination of four interchangeable modules—and an experimental environment supporting both single- and multi-agent benchmarks (e.g., GAIA, WebWalkerQA, xBench-DS, TaskCraft) (Zhang et al., 21 Dec 2025). This abstraction is designed to support "open-ended self-evolution," where agents not only refine their knowledge but also the architectural principles by which such knowledge is encoded and utilized.

2. Modular Memory System Design

EvolveLab formalizes each self-improving memory system as a quadruple of abstract functional modules: $$\Omega = (\mathcal{E}, \mathcal{U}, \mathcal{R}, \mathcal{G}),$$ where, at interaction step $t$:

• Encode $\mathcal{E}$: Maps raw experience $\epsilon_t$ (e.g., trajectory, tool output, critique) to encodings $e_t$ (structured embedding, text, or code fragment).
• Store $\mathcal{U}$: Updates the memory state $M_{t+1} = \mathcal{U}(M_t, e_t)$, e.g., inserting into a vector DB or updating a JSON store.
• Retrieve $\mathcal{R}$: Given $M_t$, state $s_t$, and query $t$0, produces context $t$1 consumed by the agent’s policy.
• Manage $t$2: Optionally consolidates, abstracts, or prunes $t$3 to form an updated $t$4.

By decomposing memory systems in this manner, EvolveLab provides a "genotype" representation for meta-evolution. The twelve reference pipelines re-implemented in EvolveLab (such as Voyager, Dynamic Cheatsheet, SkillWeaver, G-Memory, etc.) span task formats (single/multi-agent, step/trajectory granularity, online/offline update). The design enables plug-and-play experimentation, as well as meta-level optimization by MemEvolve (Zhang et al., 21 Dec 2025).

3. Software Architecture and Extensibility

EvolveLab exposes a standardized object-oriented API:

• Each memory system derives from BaseMemoryProvider, with required methods for provide_memory (Retrieve), take_in_memory (Encode+Store), and optional manage or initialize hooks.
• Data carriers MemoryItem, TrajectoryData, MemoryRequest, and MemoryResponse encapsulate communication between modules.
• A plugin registry manages all component implementations.

Pipelines are instantiated by composing modules. To add a system, implement the abstract methods and register; benchmarks and agent code require no further modification. The evaluation loop involves, for each trajectory $t$5 in batch $t$6: memory retrieval, action, memory update, and feedback aggregation. This consistent interface allows MemEvolve to orchestrate both agent learning and architectural evolution efficiently (Zhang et al., 21 Dec 2025).

4. Bilevel Meta-Evolution via MemEvolve

Within MemEvolve, EvolveLab modules enable a bilevel evolutionary process:

• Inner Loop (Experience Evolution): For each architecture $t$7 in generation $t$8, experience is accumulated and memory updated as agents interact with tasks. For each trajectory, feedback vectors (success, token cost, latency) are calculated and aggregated into fitness scores.
• Outer Loop (Architectural Evolution): Candidate memory architectures are evaluated via Pareto-sorted fitness vectors. Survivors (by pass@k accuracy, cost, delay) undergo meta-design: their defect profiles $t$9 trigger the generation of child architectures via architectural mutations or recombinations.

This simultaneous evolution of both experience and memory infrastructure yields architectures tuned not just to specific problems or agents, but robust to transfer across new benchmarks and LLMs. For example, architectures evolved on TaskCraft + Flash-Searcher directly improved performance in WebWalkerQA and xBench-DS, and transferred across agent frameworks such as OWL and Cognitive Kernel-Pro (Zhang et al., 21 Dec 2025).

5. Experimental Protocol and Benchmark Results

Meta-evolution experiments are performed under tightly controlled parameters ($\mathcal{E}$0 iterations, $\mathcal{E}$1 survivors, $\mathcal{E}$2 children per round; 60-trajectory batches). Benchmarks include:

• GAIA: 165 multi-step tasks (3 levels)
• WebWalkerQA: 170 sampled web queries
• xBench-DS: 100 search and reasoning tasks
• TaskCraft: 300 synthetic planning tasks

EvolveLab is integrated into agent systems including Flash-Searcher (single-agent), SmolAgent (two-agent), Cognitive Kernel-Pro, and OWL (multi-agent). Core metrics are pass@k accuracy, average token cost, latency, and execution steps. The MemEvolve + EvolveLab combination achieves up to +17.06% pass@1 accuracy improvement (e.g., Kimi K2 on WebWalkerQA) without compromising cost or latency. Transferred memory systems yield +4–7% gains across benchmarks and +2–5% gains cross-framework (Zhang et al., 21 Dec 2025).

6. Cross-Task, Cross-LLM, and Cross-Framework Generalization

Memory architectures evolved in one context (e.g., TaskCraft) are demonstrably transferable across orthogonal benchmarks and model backbones. Notably:

• WebWalkerQA + SmolAgent: 58.82% → 61.18% (+4.1%)
• xBench-DS + Flash-Searcher: 69.0% → 74.0% (+7.2%)
• Kimi K2 + Flash-Searcher on WebWalkerQA: +17.06%
• DeepSeek V3.2 + SmolAgent on TaskCraft: +10.0%

The evolutionary genotype distilled by EvolveLab thus captures generic design principles, such as hierarchical indexing and agent-driven retrieval, that are robust to distribution shift and model heterogeneity (Zhang et al., 21 Dec 2025).

7. Technical Impact and Limitations

EvolveLab marks a shift from hand-engineered, monolithic memory systems toward decomposed, evolvable architectures that facilitate continual adaptation and transfer. It provides an experimental substrate for principled benchmarking, comparison, and meta-optimization of memory systems in LLM-based agents.

Empirical results indicate strong gains in agentic benchmarks and robustness to task/LLM shift. A plausible implication is that continued refinement of this modular approach may yield even greater cross-domain generalization and specialization.

Limitations center on the evaluation domain: experiments primarily address agentic tasks (search, question answering, planning), and additional work is required to validate the generality of evolved memory systems in open-ended, multi-modal, or adversarial environments (Zhang et al., 21 Dec 2025).

Table: EvolveLab Design Modules and Example Implementations

Module	Function	Example Methods
$\mathcal{E}$3 (Encode)	Processes raw experience into reusable form	Embedding state-action, text distillation
$\mathcal{E}$4 (Store)	Updates memory with new encodings	Vector DB insert, JSON update
$\mathcal{E}$5 (Retrieve)	Supplies relevant memory to policy given context	Nearest-neighbor, sequenced retrieval
$\mathcal{E}$6 (Manage)	Consolidates or prunes stored memory	Abstraction, controlled forgetting

EvolveLab thus provides the foundation for systematic, flexible research into the meta-evolution of memory systems, supporting reproducible evaluation and direct architectural transferability in the broader field of agentic LLM systems (Zhang et al., 21 Dec 2025).