💬 NLP

MemPro: Agentic Memory Systems as Evolvable Programs

MemPro is a system-level evolution framework that treats the entire memory construction-retrieval pipeline as an evolvable program, enabling autonomous agents to iteratively diagnose failures and refine their memory systems to outperform static and prompt-level baselines in long-horizon tasks.

Original authors: Qingshan Liu, Guoqing Wang, Wen Wu, Jingqi Huang, Xinqi Tao, Dejia Song, Jie Zhou, Liang He

Published 2026-06-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Qingshan Liu, Guoqing Wang, Wen Wu, Jingqi Huang, Xinqi Tao, Dejia Song, Jie Zhou, Liang He

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are hiring a brilliant but forgetful research assistant to help you solve a massive, multi-year mystery. You give them a notebook (the "memory bank") to write down clues as they find them.

The Problem with Current Assistants
Right now, most AI assistants work like this: You tell them, "Write down the clues in your notebook," and later, "Look in your notebook to find the answer."

The Flaw: Once you hire them, the way they write and read is fixed. If the mystery changes (e.g., from tracking a person's location to understanding a complex family tree), the assistant keeps using the same old notebook habits. They might write too much, forget the order of events, or look in the wrong section of the notebook.
The Current Fix: Researchers usually try to fix this by just telling the assistant, "Try writing the clues differently," or "Try reading the clues differently." This is like giving the assistant a new sticky note with instructions, but the assistant's brain and their actual notebook-keeping habits remain rigid.

The MemPro Solution: The "Self-Improving Apprentice"
The paper introduces MemPro, a system that treats the entire assistant's workflow not just as a set of instructions, but as a living, editable program.

Think of MemPro as a master coach who doesn't just give the assistant a new sticky note. Instead, the coach watches the assistant fail, diagnoses why they failed, and then rewrites the assistant's actual job description and tools.

Here is how MemPro works, step-by-step:

1. The "Version Tree" (The Family Tree of Ideas)

Instead of just trying one new way of working and hoping it sticks, MemPro creates a family tree of different versions of the assistant.

The Root: Starts with the original assistant.
The Branches: If the assistant fails at a specific type of task, MemPro doesn't just fix that one mistake. It creates a "child" version of the assistant that tries a completely different approach.
The Benefit: If one branch of the family tree discovers a great way to handle "time-based" clues, but another branch discovers a great way to handle "relationship-based" clues, MemPro keeps both. It doesn't force the assistant to choose just one path; it lets the best ideas branch out and survive.

2. The "Evolving Agent" (The Detective Coach)

MemPro uses a special AI (the "Evolving Agent") that acts like a detective coach.

Diagnosis: It looks at where the assistant failed. Did they forget the order of events? Did they mix up two different people?
The Edit-Debug Loop: This is the magic part. The coach doesn't just say, "Be more careful." It actually edits the code the assistant uses.
- Analogy: If the assistant was using a magnifying glass to read tiny text and failing, a prompt-only fix would say, "Try harder." MemPro's coach says, "Let's swap the magnifying glass for a microscope and rewrite the instructions on how to hold it."
- It then "debugs" this new code on a few test cases to make sure it works before making it official.

3. The Result: A System That Grows

The paper tested this on four different "mysteries" (datasets like LongMemEval, LoCoMo, HotpotQA, and NarrativeQA).

Fast Improvement: Within just a few rounds of this "coach" editing the system, MemPro became better than the best existing assistants, even those that were very expensive or complex.
Continuous Growth: Unlike other systems that hit a ceiling and stop getting better, MemPro kept improving. The more it evolved, the smarter it got, because it was constantly rewriting its own "brain" and "notebook habits" to fit the specific type of puzzle it was solving.

Why This Matters (According to the Paper)

The authors argue that for AI to handle long, complex tasks, we can't just tweak the "prompt" (the instructions). We have to treat the entire system—how it builds its memory and how it uses it—as a piece of software that can evolve.

In short: MemPro is a system that builds its own better self. It doesn't just learn from mistakes; it rewrites its own rulebook and tools to ensure it never makes the same mistake twice, creating a "living" memory system that gets smarter the more it is used.

Technical Summary: MemPro – Agentic Memory Systems as Evolvable Programs

1. Problem Statement

Long-horizon autonomous agents require memory systems to retain historical information and track evolving states beyond the finite context windows of Large Language Models (LLMs). While existing agentic memory systems typically follow a Memory Construction–Retrieval (MCR) pipeline, they suffer from two critical limitations due to their fixed-pipeline design:

Task Heterogeneity: Different long-term memory tasks exhibit distinct failure modes (e.g., temporal reasoning vs. multi-session evidence linking) requiring different strategies. A fixed pipeline forces a single strategy onto all tasks, leading to suboptimal performance.
Memory–Pipeline Misalignment: As the memory bank evolves in scale and structure over time, a static pipeline may no longer align with how memories are organized or retrieved, resulting in incomplete retrieval or noisy evidence.

Current optimization methods, such as prompt-level evolution, can refine textual instructions but cannot modify the executable pipeline logic (e.g., code for constructing memory banks or retrieval strategies). This paper argues that memory self-evolution must operate at the system level, treating the entire MCR pipeline as an evolvable program rather than just updating stored memories or prompt text.

2. Methodology: MemPro Framework

MemPro is a system-level evolution framework that treats the MCR pipeline as an evolvable program. It maintains a version tree of runnable memory-system implementations, where each node contains both prompts and executable code. The system is driven by an Evolving Agent that iteratively selects, expands, and evaluates pipeline versions through a failure-mode-guided edit–debug refinement process.

Core Components

MCR Version Tree ( $T$ ): A tree structure where each node $v$ represents a runnable pipeline implementation $F_v$ and its evaluation log $L_v$ . The root $v_0$ is the initial pipeline.
Evaluation Log ( $L_v$ ): Records the overall score ( $S_v$ ), category-level scores ( $C_v$ ), parent node ($pa(v)$), and an overall assessment ( $A_v$ ) summarizing failure modes and improvement directions.
Evolving Agent ( $A_{evo}$ ): The core engine that manages the evolution process through three iterative steps:
1. Selection: The agent analyzes logs from the entire version tree to select the most promising parent node for expansion based on high scores, generalizable improvements, and frequent failure modes. It also generates a diagnostic analysis ( $R_\ell$ ).
2. Expansion: Starting from the selected node, the agent performs an inner iterative loop to create a child version. At each step, it chooses an action:
  - EDIT: Revises the pipeline code or prompts based on the accumulated diagnostic analysis.
  - DEBUG: Selects a specific diagnostic example, executes the current pipeline on it to generate a full trace, and updates the diagnostic analysis without re-evaluating the full dataset.
  - TERMINATE: Stops the expansion, finalizing the new version.
3. Evaluation: The new pipeline version is executed on the full training set to collect execution traces. The agent summarizes these traces into a new evaluation log, adding the new node to the version tree.

This tree structure allows MemPro to branch from strong historical versions and explore alternative directions, rather than following a single linear trajectory.

3. Key Contributions

Identification of Limitations: The paper identifies task heterogeneity and memory–pipeline misalignment as fundamental flaws in fixed-pipeline agentic memory systems, arguing for system-level evolution over isolated memory or prompt updates.
MemPro Framework: The proposal of a system-level evolution framework that treats the MCR pipeline as an evolvable program. It uniquely optimizes both prompts and executable code via a version tree and failure-mode-guided edit–debug refinement.
Empirical Validation: Extensive experiments across four benchmarks (LongMemEval, LoCoMo, HotpotQA, NarrativeQA) demonstrate that MemPro consistently outperforms strong static and prompt-level evolving baselines within a few iterations, continues to improve as the version tree expands, and achieves a favorable performance–cost trade-off.

4. Experimental Results

Experiments were conducted on two long-term memory benchmarks (LongMemEval, LoCoMo) and two long-context QA benchmarks (HotpotQA, NarrativeQA) using GPT-4o-mini and Qwen3-30B-A3B backbones.

Performance Gains: MemPro consistently outperformed strong static baselines (e.g., LangMem, Mem0, GAM) and prompt-level evolution baselines (GEPA, MetaMem).
- On LoCoMo, MemPro-5 (after 5 iterations) achieved 81.94% accuracy, surpassing the best baseline (GAM at 80.45%).
- On LongMemEval, MemPro-15 reached 79.00%, outperforming the best baseline (GEPA at 75.60%).
- On HotpotQA and NarrativeQA, MemPro achieved state-of-the-art F1 scores, surpassing all non-MemPro baselines by the 5th iteration.
Continuous Improvement: Unlike static systems, MemPro showed steady performance gains as evolution progressed from 5 to 15 iterations, indicating a high ceiling for system-level optimization.
Ablation Studies: Removing key components (code editing, version tree, iterative expansion, or multi-round evolution) led to significant performance drops. Specifically, the "w/o Code" variant (reducing to prompt-level evolution) underperformed the full system, validating the necessity of editing executable logic.
Efficiency: MemPro achieved the highest overall accuracy with a reasonable token cost, substantially outperforming "Full Text" methods while using fewer tokens and surpassing strong memory baselines with comparable budgets.

5. Significance and Claims

The paper claims that agentic memory should be optimized as a runnable, self-evolving system. By treating the MCR pipeline as an evolvable program, MemPro addresses the limitations of fixed-pipeline designs that struggle with task diversity and evolving memory structures.

The authors emphasize that:

Evolving the executable pipeline logic yields benefits beyond adapting memory banks or prompts alone.
A version tree structure is superior to linear evolution, allowing the system to branch from strong historical versions.
Failure-mode-guided refinement (combining editing and targeted debugging) is effective for iterative system improvement.

The work suggests that future agentic memory systems should move beyond static architectures toward dynamic, self-improving programs that can adapt their own construction and retrieval strategies to specific task requirements and evolving data scales.

6. Limitations and Ethical Considerations

Cost: MemPro introduces an offline evolution stage. While costs can be amortized over many queries, the efficiency of the evolution process itself is a target for future improvement.
Agent Capability: The current implementation relies on a capable Evolving Agent (Codex harness with GPT-5.4-medium) to edit and debug code.
Topology: The current framework uses a tree structure where new versions derive from a single parent. The authors note that more general topologies (e.g., graph-structured evolution allowing merges) remain unexplored.
Safety: Since MemPro edits executable components, evolved versions must be sandboxed, logged, and reviewed before deployment in safety-critical settings. The authors ensure that evaluation data and gold answers are not exposed to the Evolving Agent during experiments.