💬 NLP

SelfMem: Self-Optimizing Memory for AI Agents

The paper introduces SelfMem, a self-optimizing memory framework that enables AI agents to autonomously explore and refine their own memory strategies through environmental feedback, significantly outperforming existing fixed-memory baselines across diverse long-context tasks.

Original authors: Shu Yang, Junchao Wu, Derek F. Wong, Di Wang

Published 2026-07-07

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Shu Yang, Junchao Wu, Derek F. Wong, Di Wang

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 trying to have a conversation with a very smart friend who has read a library's worth of books. The problem is, your friend has a "short-term memory" that can only hold a few pages at a time. If you talk for hours, they start forgetting what you said at the beginning, or they get confused because they can't fit all the details into their head.

Current AI assistants are like this friend. They are getting better at reading long texts, but they still struggle to remember important details from the start of a very long conversation without getting overwhelmed or making mistakes.

The Old Way: The Rigid Filing Cabinet

Most AI memory systems today work like a strict librarian who follows a fixed rulebook.

How it works: No matter what you are talking about, the librarian automatically shoves every conversation into a specific type of folder, summarizes it in a specific way, and pulls out the "most important" pages based on a pre-set formula.
The Problem: This is like trying to organize a chaotic kitchen using only one type of drawer. Sometimes you need a spice rack, sometimes a deep freezer, and sometimes just a sticky note. A rigid system forces everything into the same box, which often leads to losing important details or keeping useless junk.

The New Way: SelfMem (Teaching the Agent to Fish)

The paper introduces SelfMem, which changes the game. Instead of giving the AI a fixed rulebook, the researchers give the AI a toolbox and a mirror.

Think of SelfMem as teaching an agent "how to fish" rather than just giving it a fish.

The Raw Truth: The AI keeps the entire, unedited conversation history (the "transcript") safe in a database, like a recording of the whole chat. It never deletes the original source.
The Toolbox: The AI is given a set of tools. It can:
- Read: Scan the recording to find specific facts.
- Write: Create a summary or a "cheat sheet" of what matters.
- Review: Check its own cheat sheet to see if it's accurate or if it's missing something.
- Fix: If the cheat sheet is wrong or outdated, the AI can edit it.
The Feedback Loop: The AI gets signals like "This summary is too long," "You missed a date," or "This fact is still useful." Based on these signals, the AI decides for itself what to keep, what to throw away, and how to organize its memory.

How It Works in Practice

Imagine you are talking to this AI about buying sneakers over several days.

The Old Way: The system might automatically summarize every chat as "User likes shoes." It might forget that you specifically wanted size 11 or that you mentioned a budget of $100.
SelfMem:
- The AI reads the transcript and sees you mentioned "size 11" and "budget."
- It decides to write a specific note: "User: Size 11, Budget $100."
- Later, you mention a new shoe. The AI checks its note, sees the budget, and realizes the new shoe is too expensive.
- If you change your mind and say, "Actually, I have $150 now," the AI updates its note immediately.
- If a detail is just a one-time thing (like "I saw a red car today"), the AI decides not to write it down, saving space for more important things.

The Results: Better, Cheaper, and Smarter

The researchers tested this on a massive benchmark called BEAM, which simulates conversations ranging from 100,000 to 1,000,000 words (that's like reading several thick novels in one chat).

Performance: SelfMem scored significantly higher than all other methods. It was better at answering questions about facts, timelines, and preferences, even after a million words of conversation.
Efficiency: It didn't just work better; it worked cheaper. Other methods tried to solve the problem by using more computer power and expensive tools (like scanning every word with complex algorithms). SelfMem was smarter about what to scan, saving money and time.
Flexibility: It didn't just get better at one type of question. It improved across the board, whether the question was about "What did I say yesterday?" or "What is my favorite color?"

The Bottom Line

SelfMem doesn't force the AI to remember everything or nothing. Instead, it gives the AI the freedom to learn how to manage its own memory. By letting the AI inspect the past, write its own notes, and correct its own mistakes, it creates a system that is more adaptable, accurate, and efficient than any rigid, pre-programmed memory system we've had before.

In short: Don't tell the AI what to remember; give it the tools to figure out how to remember best.

Technical Summary: SelfMem: Self-Optimizing Memory for AI Agents

1. Problem Statement

As AI agents gain capabilities in processing long contexts, multi-step planning, and tool use, they face increasing demands to retain user preferences, project backgrounds, and factual details over extended interactions. Existing memory frameworks (e.g., LoCoMo, MemGPT, MemoryBank, A-Mem) typically rely on fixed storage, retrieval, and summarization mechanisms. These systems often employ manually specified strategies to construct, update, and retrieve historical knowledge.

The core limitation identified is that these predefined structures are rigid across different tasks. While methods like A-Mem allow agents to write and index memories, the fundamental challenge remains: different tasks and conversation histories require different memory behaviors, yet it is unclear how agents should adapt their strategies to specific task demands and environmental feedback without manual tuning. Current approaches often force the model to follow a pre-defined memory format rather than allowing it to learn the optimal strategy for the specific context.

2. Methodology: SelfMem

The authors propose SelfMem, a self-optimizing memory framework inspired by the principle of "teaching an agent to fish rather than giving it a fish." Instead of prescribing a fixed memory strategy, SelfMem creates an environment where the agent learns to manage memory adaptively through exploration, evaluation, and refinement.

Core Architecture

SelfMem separates framework constraints from memory strategy. The framework provides the tools and feedback, while the agent determines the concrete memory actions.

Immutable Transcript Store (Source of Truth): The raw conversation history is stored as a read-only SQLite database (turns table). The agent cannot modify this directly but can inspect it using read-only tools (e.g., conversation_manifest, conversation_sql_query) to retrieve specific turns, entities, or statistics.
Memory Workspace: A model-managed workspace ( $M_i$ ) where the agent constructs a compact representation of the conversation. This can include user profiles, preference lists, timelines, or policy notes.
Action Space ( $A$ ): The agent selects from a set of tools to interact with the transcript and workspace:
- Transcript-read tools: Inspect the immutable history.
- Memory-read tools: Inspect the current workspace to avoid duplicates or detect staleness.
- Memory-write tools: Add, replace, merge, refine, or archive memory content.
- Memory-review tools: Diagnose memory quality (e.g., checking for source support, contradictions, or retrievability risks) without mutating it.
- Self-test tools: Generate internal probes to test if the memory organization supports plausible future questions.
Feedback Signals ( $F$ ): The agent receives feedback not as a single scalar reward or gold labels, but as observable signals:
- Transcript and memory read observations.
- Diagnostic feedback from review and write operations.
- Operational signals (token usage, latency, cache reuse, cost).
- This design allows the agent to reason about trade-offs (e.g., storing more info vs. increasing context cost) in natural language.

Optimization Loop

Memory construction is a model-controlled loop:

Inspect: The agent reads the transcript and current memory.
Decide: The agent selects an action (write, revise, review) based on the current state and feedback.
Refine: The agent can review a draft memory, receive diagnostic feedback (e.g., "stale facts detected"), and revise the workspace.
Answer: For a query $q$ , the system retrieves relevant transcript snippets ( $E_q$ ) based on the optimized memory workspace ( $M^*$ ) and feeds both to the LLM for the final answer.

3. Key Contributions

Self-Optimizing Framework: A novel approach that shifts memory management from a fixed pipeline to an agent-controlled optimization process, allowing the agent to discover task-specific memory strategies.
Tool-Based Action Space: The introduction of a granular set of tools (read, write, review, self-test) that enables agents to iteratively construct, audit, and refine their own memory representations.
Feedback-Driven Adaptation: A mechanism where agents use multi-dimensional feedback signals (cost, accuracy, staleness) to balance memory quality and efficiency without requiring external supervision or model parameter updates.
Comprehensive Evaluation: A rigorous evaluation on the BEAM benchmark across three scales (100K, 500K, and 1M tokens), demonstrating robustness across diverse question types.

4. Experimental Results

The authors evaluated SelfMem on the BEAM benchmark (Tavakoli et al., 2025), comparing it against baselines including RAG, full context, compression, LoCoMo, MemoryBank, MemGPT, A-Mem, and Mem0.

Performance Gains: SelfMem consistently outperformed all baselines across all token scales.
- 100K tokens: Improved official score by 48.7% over the strongest baseline (RAG).
- 500K tokens: Improved official score by 40.8%.
- 1M tokens: Improved official score by 41.9%.
- In absolute terms, SelfMem improved the Score by 0.165, 0.141, and 0.134 at 100K, 500K, and 1M respectively, compared to the best non-SelfMem baseline.
Robustness: SelfMem achieved the best scores on 9/10 question types at 100K, 8/10 at 500K, and 7/10 at 1M, showing broad adaptability to information extraction, temporal reasoning, and multi-session reasoning.
Efficiency: Despite higher accuracy, SelfMem maintained a favorable quality-cost trade-off. At 1M tokens, it achieved a score of 0.454 with a cost of $2.004 and zero embedding requests, whereas competitors like Mem0 cost $18.830 with 25,779 embedding requests for a lower score (0.292).
Strategy Refinement: An optimization study showed that allowing the agent to iteratively refine its memory strategy notes based on aggregate feedback further improved performance, raising the score from 0.472 (Iteration 0) to 0.510 (best observed).

5. Significance and Claims

The paper claims that SelfMem demonstrates that memory behavior can be optimized in language. By exposing memory-management decisions to the agent itself, rather than relying on rigid, predefined strategies, agents can learn principles and trade-offs that are better adapted to specific task demands.

The authors emphasize that:

Adaptability is key: Fixed memory structures limit performance in long-horizon tasks where relevant information is sparse and distributed.
Cost-Efficiency: High accuracy does not require expensive, heavy memory pipelines; selective construction and revision by the agent yield better results with lower computational costs.
Optimization Surface: SelfMem exposes a useful optimization surface for long-horizon memory management, suggesting that model-guided strategy refinement can significantly enhance agent performance without updating the underlying model weights.

The work positions itself as a step toward agents that can "teach themselves" to manage memory effectively, moving beyond the limitations of manually engineered memory architectures.