PaperlayerView exact revision on arXiv

Source-linked AI summary

Memory for Autonomous LLM Agents:Mechanisms, Evaluation, and Emerging Frontiers

Pengfei Du

arXiv:2603.07670v1cs.AI

TL;DR

LLM agents need memory to retain experience, learned information, and constraints beyond a single context window, but current systems still struggle with reliable cross-session use. This survey formalizes memory as a write–manage–read loop, organizes mechanisms and evaluations across three dimensions, and finds that memory type and architecture are strongly application-dependent. It concludes that trustworthy consolidation, retrieval, reflection, and forgetting remain central open problems.

  • Problem

    LLM agents operate beyond a single context window, creating a need to persist, organize, and selectively recall information across interactions.

  • Method

    The survey formalizes agent memory as a write–manage–read loop and synthesizes taxonomies, mechanisms, benchmarks, applications, engineering practices, and open research directions.

  • Results

    Different domains stress different memory types: assistants rely on semantic memory, software agents on procedural memory, games on episodic-procedural integration, and scientific agents on semantic memory with uncertainty tracking.

  • Takeaways & Limitations

    Memory design is a differentiating factor for agents whose tasks span sessions, experience, adaptation, and coordination rather than one-shot interactions.

  • Takeaways & Limitations

    Cross-session coherence remains largely unsolved, and reflective systems can reinforce false beliefs or over-generalize without stronger validation and forgetting controls.

Abstract

from arXiv · show

Large language model (LLM) agents increasingly operate in settings where a single context window is far too small to capture what has happened, what was learned, and what should not be repeated. Memory -- the ability to persist, organize, and selectively recall information across interactions -- is what turns a stateless text generator into a genuinely adaptive agent. This survey offers a structured account of how memory is designed, implemented, and evaluated in modern LLM-based agents, covering work from 2022 through early 2026. We formalize agent memory as a \emph{write--manage--read} loop tightly coupled with perception and action, then introduce a three-dimensional taxonomy spanning temporal scope, representational substrate, and control policy. Five mechanism families are examined in depth: context-resident compression, retrieval-augmented stores, reflective self-improvement, hierarchical virtual context, and policy-learned management. On the evaluation side, we trace the shift from static recall benchmarks to multi-session agentic tests that interleave memory with decision-making, analyzing four recent benchmarks that expose stubborn gaps in current systems. We also survey applications where memory is the differentiating factor -- personal assistants, coding agents, open-world games, scientific reasoning, and multi-agent teamwork -- and address the engineering realities of write-path filtering, contradiction handling, latency budgets, and privacy governance. The paper closes with open challenges: continual consolidation, causally grounded retrieval, trustworthy reflection, learned forgetting, and multimodal embodied memory.

1 Introduction

LLM agents are expected to learn from extended interaction, making memory central to retaining experience, avoiding repeated mistakes, and adapting across sessions. This survey organizes recent memory research around its mechanisms, evaluations, applications, and open challenges.

  • Motivation: Memory distinguishes autonomous agents from stateless chatbots by supporting learning from experience over extended time horizons.Examples include remembering flaky APIs, mastered crafting recipes, and user preferences.
  • Motivation: Without memory, agents repeatedly rediscover project knowledge and retry previously failed approaches across sessions.A debugging assistant may repeatedly reread documentation and reproduce fixes that previously crashed the build.
  • Motivation: Memory can accumulate factual knowledge, develop experience-grounded behavior, avoid costly mistakes, and improve continuously through interaction.The paper characterizes this as a qualitative transformation from a stateless LLM into a self-evolving agent.
  • Prior work: Earlier memory research introduced external differentiable storage, while retrieval systems established dynamic access to knowledge without retraining.The survey connects Memory Networks, Neural Turing Machines, Differentiable Neural Computers, RAG, and RETRO to later agent memory.
  • Prior work: Recent agent systems combine reasoning with actions, verbal self-critiques, observation-reflection-planning loops, hierarchical memory, skill libraries, symbolic stores, and learned memory management.The design space expanded rapidly from 2022 through 2026.
  • Survey scope: The survey formalizes memory in a POMDP-style agent cycle, proposes a three-dimensional taxonomy, reviews mechanisms and benchmarks, maps applications, and discusses engineering realities and open directions.Its research questions concern memory decomposition, mechanism trade-offs, and evaluation by downstream agent performance.

2 Problem Formulation and Design Objectives

The paper models agent memory as a managed internal state between observations and actions, emphasizing that memory operations form a feedback loop under utility, efficiency, adaptivity, faithfulness, and governance constraints. Ablations across systems show that memory architecture can materially affect multi-session task performance.

  • 2.1 The agent loop, seen through memory: At each step, the agent receives input, consults accumulated memory, produces an action, and updates memory using feedback and reward-like signals.The formulation places memory between perception and action within the agent cycle.
  • 2.1 The agent loop, seen through memory: Memory management includes summarization, deduplication, priority scoring, contradiction resolution, and deletion rather than simple appending.Because decisions determine writes and writes shape later decisions, one bad write can pollute downstream behavior.
  • 2.2 Connection to POMDPs: In the POMDP analogy, memory acts as a belief state: an internal summary of history that substitutes for the world state that cannot be directly observed.LLM agents approximate belief updates through natural-language compression, vector indexing, or structured storage.
  • 2.3 Five design objectives and their tensions: Memory mechanisms are evaluated across utility, efficiency, adaptivity, faithfulness, and governance.These objectives cover task outcomes, resource costs, incremental updating, recall quality, privacy, deletion, and policy compliance.
  • 2.3 Five design objectives and their tensions: These objectives conflict: storing more can improve utility while increasing storage and governance burdens, whereas compression improves efficiency but can discard rare critical facts.The appropriate balance depends on the application’s faithfulness and efficiency requirements.
  • 2.4 Memory as a differentiator: an empirical perspective: MemoryArena task completion fell from over 80% to roughly 45% when an active memory agent was replaced by a long-context-only baseline on interdependent multi-session tasks.The broader ablation comparison also reports degradation without reflection and a 15.3× loss in Voyager tech-tree milestone speed without its skill library.
  • 2.4 Memory as a differentiator: an empirical perspective: Across reported systems, the performance gap between having memory and having none can exceed the gap between different LLM backbones.This comparison motivates treating memory architecture as a major design investment rather than a peripheral module.

3 A Unified Taxonomy of Agent Memory

The taxonomy organizes agent memory by temporal scope, representational substrate, and control policy. It distinguishes memory layers, storage forms, and decision mechanisms while highlighting unresolved transitions, capacity limits, and management trade-offs.

  • 3.1 Temporal scope: The taxonomy adapts distinctions among working, episodic, semantic, and procedural memory to LLM agents.These layers cover current context, concrete experiences, abstract knowledge, and reusable skills or plans.
  • 3.1 Temporal scope: Working memory is the current context window and therefore shares the LLM’s limited-capacity bottleneck.Episodic memory stores timestamped experiences, semantic memory abstracts recurring facts, and procedural memory stores executable skills.
  • 3.1 Temporal scope: The unresolved transition policy determines when episodes become semantic knowledge and when semantic facts return to working memory for a task.Most systems blend at least two memory types, but transitions remain difficult to manage.
  • 3.1 Temporal scope: A customer-support example combines episodic case records, semantic eligibility rules, working-memory details, and procedural return-processing scripts.The example illustrates how all four memory types can participate in one reasoning process.
  • 3.1 Temporal scope: Current systems implement only some memory layers well, while consolidation from episodes to semantic knowledge commonly relies on fragile rules or periodic LLM summarization.This makes transitions difficult to validate.
  • 3.2 Representational substrate: Context-resident text is transparent and infrastructure-free but capacity-limited, whereas vector stores scale to millions of records while weakening causal and relational queries.Vector retrieval answers similarity questions efficiently but not necessarily questions about what caused what.
  • 3.2 Representational substrate: Structured stores preserve relationships for complex queries, executable repositories directly invoke stored skills, and hybrid systems layer stores with different access and eviction rules.These substrates trade schema or infrastructure costs for structured retrieval and direct execution.
  • 3.3 Control policy: Control policies range from fixed heuristics to prompted LLM decisions and learned actions for storing, retrieving, updating, summarizing, and discarding.Learned control can discover preemptive summarization strategies but requires substantial training.

4 Core Memory Mechanisms

LLM-agent memory spans context compression, retrieval stores, structured read-write systems, and reflective self-improvement, each balancing recall, relevance, cost, and reliability. Across these mechanisms, long-lived agents need selective external storage and safeguards against information loss, attentional dilution, and self-reinforcing errors.

  • Context-resident memory and compression: Context-resident memory keeps recent history directly in the prompt, using sliding windows, rolling or hierarchical summaries, and task-conditioned compression when history exceeds the context window.Self-Controlled Memory lets the agent choose between verbatim retention and aggressive condensation.
  • Context-resident memory and compression: Summarization drift can erase rare but critical instructions, while longer contexts delay rather than eliminate the problem and increase attention costs quadratically.A 350-turn history compressed through three weekly cycles may lose a day-one instruction such as avoiding direct production-database calls.
  • Context-resident memory and compression: Long-running agents should supplement context-resident memory with external stores that preserve raw records at full fidelity.The paper connects this recommendation to reported failures in deployed chatbots and coding assistants.
  • Retrieval-augmented memory stores: Retrieval-augmented stores preserve interaction records such as tool calls, observations, corrections, plans, and reflections, but must balance indexing granularity, query formulation, and relevance at scale.Multi-granularity indexing and query reformulation address fragmented reasoning and poor retrieval queries; large datastores shift the bottleneck from storage to relevance.
  • Retrieval-augmented memory stores: Structured read-write memory combines schema at storage time with natural-language flexibility at read time.RET-LLM writes structured triplets and queries them through natural language.
  • Reflective and self-improving memory: Reflective memory improves later attempts by storing self-critiques and synthesizing higher-order reflections from episodic observations.Reflexion prepends post-mortems to the next prompt, while Generative Agents scores memories using recency, relevance, and importance.
  • Reflective and self-improving memory: Reflective memory risks self-reinforcing errors and over-generalization, especially when incorrect reflections persist across many downstream decisions.Suggested safeguards include confidence scores, contradiction checking, expiration, and grounding reflections in specific episodic evidence.
  • Architecture and deployment constraints: Memory architectures also face silent orchestration failures, policy-transfer limits, costly long-horizon training, unsafe forgetting, and weak interpretability.Wrong paging decisions may produce degraded responses without exceptions or logs, complicating diagnosis.

5 Evaluation: From Recall to Agentic Utility

Agent-memory evaluation must measure whether retrieved information improves decisions, not merely whether retrieval finds relevant documents. Recent benchmarks expose substantial gaps in long-term recall, selective forgetting, cross-session coherence, and operational efficiency.

  • Evaluation criteria: Memory evaluation must jointly assess task decisions, memory quality, efficiency, and governance rather than relying on Precision@k or nDCG alone.Relevant dimensions include contradiction, staleness, forgetting quality, privacy leakage, deletion compliance, and access-scope violations.
  • Benchmarks: LoCoMo tests up to 35 sessions and 300+ turns, finding that RAG-augmented LLMs lag humans especially on temporal and causal dynamics.It evaluates factual QA, event summarization, and dialogue generation.
  • Benchmarks: MemoryAgentBench finds no current system masters accurate retrieval, test-time learning, long-range understanding, and selective forgetting.Most systems fail conspicuously on selective forgetting after long-context datasets are reformatted into incremental interactions.
  • Benchmarks: Models scoring near-perfectly on LoCoMo fall to 40–60% in MemoryArena, revealing a gap between passive recall and active, decision-relevant memory use.MemoryArena embeds evaluation in web navigation, constrained planning, information search, and sequential formal reasoning.
  • Cross-cutting findings: Long-context models underperform purpose-built memory systems on selective retrieval and active management despite context windows reaching 200k tokens.The result indicates that larger passive contexts do not substitute for memory systems designed for selective management.
  • Cross-cutting findings: Cross-session coherence remains largely unsolved, while parametric and non-parametric memory retain complementary failure profiles.Parametric memory integrates knowledge seamlessly but hinders deletion and auditing; external stores support inspection and governance but may be ignored or inconsistently used.
  • Deployment evaluation: Benchmarks should report effectiveness alongside latency, token consumption, storage growth, and other operational costs.A 5% accuracy gain that triples latency and storage cost may not improve deployment outcomes.

6 Where Memory Makes or Breaks the Agent

Memory matters most when agents must preserve information across long horizons, personalize behavior, reuse skills, or update beliefs. Different application domains therefore stress different memory types and expose distinct limitations.

  • Domain dependence: Memory is critical for long-lived collaborators but minimally necessary for one-shot tools such as translation systems.The survey uses month-long project collaboration versus one-shot translation to illustrate this difference.
  • Personal assistants: Personal assistants require personalization without overstepping, balancing remembered preferences and user models against information users consider private or forgotten.MemoryBank models decay with forgetting curves, while MemGPT supports multi-session chat with evolving user models.
  • Coding agents: Coding agents must retain architecture decisions, bug histories, code-style preferences, and verified solutions across codebases spanning thousands of files.The central challenge is indexing and retrieving relevant codebase portions rather than only conversational history.
  • Open-world games: Voyager’s skill library produced 3.3× more unique items and 15.3× faster milestone progression than prior agents in Minecraft.JARVIS-1 extends game-agent memory across visual observations and textual plans.
  • Open-world games: Game agents face compositional skill reuse: they must chain remembered skills creatively to solve novel problems.This requires more than recalling individual skills.
  • Scientific reasoning: Scientific agents use memory as a hypothesis ledger and evidence accumulator, but current systems handle confidence updates as new data arrives poorly or not at all.Scientific memory must preserve uncertainty alongside factual content.

6.5 Multi-agent collaboration

In multi-agent collaboration, memory coordinates contributions, agreements, and anticipated needs, but shared-memory design must balance knowledge transfer against privacy and concurrent-write consistency. No single architecture currently supports all domain-specific memory profiles well.

  • Coordination: Shared memory lets agents build on contributions, preserve collaborative history, and anticipate teammate needs.AutoGen, CAMEL, and ProAgent illustrate shared-context, role-aware, and proactive coordination patterns.
  • Coordination: Multi-agent systems must resolve shared-versus-private visibility and consistency under concurrent writes.These challenges arise when agents update shared memory simultaneously or need selective access to information.
  • Memory boundaries: All-shared memory risks private-information leakage, whereas isolated per-agent stores prevent cross-agent knowledge transfer.Existing frameworks commonly choose one of these unsatisfactory extremes.
  • Tool-mediated collaboration: Tool-use memory must track capabilities, parameters, verified call sequences, and API versions because schema drift invalidates stored usage patterns.Without version tracking and schema validation, invalid records accumulate and degrade reuse of past experience.
  • Tool-mediated collaboration: A living, versioned catalog of tool capabilities is more appropriate than simply storing which calls previously worked.The paper connects this requirement to dependency management in software engineering.
  • Architectural implications: Different domains stress different memory types, and no existing system supports all profiles simultaneously.The survey associates personal assistants with semantic memory, software agents with procedural memory, games with episodic-procedural integration, and science with uncertainty-aware semantic memory.

7 Engineering Realities

Reliable agent memory depends on selective writing, targeted reading, temporal and provenance-aware updates, privacy controls, observability, and workload-appropriate architecture. Deployment choices must balance retrieval quality, latency, cost, governance, and debuggability.

  • Write path: A robust write path filters low-signal records, canonicalizes facts, deduplicates entries, scores priority, and attaches metadata.Useful metadata includes timestamps, sources, task labels, and confidence.
  • Write path: Filtering thresholds are application-specific: medical agents prioritize avoiding false negatives, while casual assistants can tolerate more omission.Customer-support and financial-advisory agents occupy different points on the recall spectrum.
  • Read path: Read-path optimizations include two-stage retrieval, retrieval-or-not gating, dynamic token budgeting, and caching of frequently used records.These methods avoid running the full retrieval pipeline for every step.
  • Consistency and forgetting: Stale memories can cause harmful actions, so systems need temporal versioning, source attribution, contradiction detection, and periodic consolidation.These mechanisms help distinguish newer records from outdated ones and resolve conflicting entries.
  • Latency and cost: Retrieval pipelines can add 200–500ms, motivating asynchronous writes, progressive retrieval, and dynamic routing for sub-second interactions.Dynamic routing skips retrieval for straightforward requests and engages the full pipeline when ambiguity is high.
  • Latency and cost: Retrieving a handful of highly relevant passages into a moderate-length context can outperform both pure long-context and pure retrieval approaches.This provides a guideline for tuning the latency–quality tradeoff.
  • Privacy and governance: Memory governance requires encryption, access scoping, PII redaction, retention policies, and auditable deletion across indexes and backups.If information has entered fine-tuned weights, external deletion is insufficient and machine unlearning remains far from production-ready.
  • Architecture patterns: Pattern B combines context with an external retrieval store and is presented as the production workhorse, while Pattern C adds learned control across memory tiers.The recommendation is to begin with Pattern B and move to Pattern C only when workload evidence supports the added complexity.

8 Positioning Relative to Prior Surveys

This survey distinguishes its scope from broad agent and retrieval-augmented-generation surveys by centering agent-specific memory. It updates earlier memory reviews with a POMDP-grounded formulation, newer systems, applications, engineering patterns, and governance.

  • Unlike broad agent surveys, this work focuses specifically on memory rather than treating it as one module among many.
  • The survey extends prior memory reviews with 2025–2026 systems, a POMDP-grounded formulation, applications, engineering patterns, and governance.
  • Compared with RAG surveys, its scope covers agent-specific memory needs beyond the retrieval–generation pipeline.
  • Longer context windows enlarge working memory but do not provide persistent cross-session storage, structured organization, selective retrieval, or deletion and access control.

9 Open Challenges

Open challenges span memory quality, retrieval, reflection, forgetting, embodiment, multi-agent coordination, efficiency, general-purpose control, and evaluation. Across these areas, the survey emphasizes unresolved trade-offs between utility, reliability, cost, and governance.

  • Continual consolidation: Offline or dual-buffer consolidation could balance retaining important memories against noise, using probationary quality checks before promotion.Proposed checks include reverification, deduplication, and importance scoring.
  • Causal retrieval: Causally grounded retrieval remains difficult because semantic similarity can miss temporally distant memories that are causally upstream of the current problem.A proposed direction adds causal metadata and traverses causal links alongside vector search.
  • Trustworthy reflection: Reflective memory can entrench false beliefs, motivating external validation, uncertainty decay, adversarial probing, and expiration policies.
  • Learned forgetting: Selective forgetting must optimize long-term utility under safety and compliance constraints rather than relying only on expiration or storage-limit eviction.
  • Embodied and multi-agent memory: Embodied and multi-agent settings require multimodal retrieval, spatial and real-time memory, shared-store access control, concurrent-write consensus, and knowledge transfer.
  • Efficiency: Current efficiency proposals reduce memory cost through sparse retrieval, compressed session vectors, memory-native architectures, or adapters, but none has demonstrated strong agent-level performance.
  • Foundation models for memory management: A task-agnostic foundation model for memory control remains unrealized, with training requiring diverse trajectories and labels for memory-operation quality.
  • Evaluation: The field lacks a community-standard evaluation harness, making cross-paper comparison unreliable across datasets, metrics, and protocols.

10 Conclusion

The survey frames agent memory as a central engineering and research challenge, tracing progress from compression to retrieval stores and learned policies. It concludes that reliable agents depend on solving unresolved problems in consolidation, causal retrieval, reflection, and forgetting, while treating memory as a first-class system component.

  • Agent memory has progressed through prompt-level compression, retrieval-augmented stores, and end-to-end learned policies, while evaluation moved toward multi-session agentic benchmarks.
  • The hardest remaining problems are consolidation without catastrophic loss, causal retrieval, reflection without error entrenchment, and safe forgetting.
  • The survey recommends giving memory the same level of engineering investment as the underlying LLM, including dedicated design, testing, and optimization.

Data Availability Statement

No primary data were generated in this study; all referenced works are publicly available as cited.

  • No primary data were generated in this study, and all referenced works are publicly available as cited.
Loading 2603.07670v1…