Source-linked AI summary
AtomMem : Learnable Dynamic Agentic Memory with Atomic Memory Operation
Yupeng Huo, Yaxi Lu, Zhong Zhang, Haotian Chen, Yankai Lin
TL;DR
LLM-agent memory mechanisms commonly depend on static, expert-crafted workflows that may not adapt to diverse long-horizon tasks. AtomMem reframes memory management as a dynamic decision process over atomic CRUD operations and trains a task-aligned policy. Across evaluated memory-intensive tasks, it outperforms static-workflow methods, while its learned operation patterns vary with task conditions.
Problem
Most LLM-agent memory mechanisms rely on static, expert-crafted pipelines that constrain operations to predefined workflows and may fail to preserve critical information in complex environments.
Method
AtomMem decomposes high-level memory workflows into atomic Create, Read, Update, and Delete operations and optimizes the resulting decision process with reinforcement learning.
Results
Across five memory-intensive tasks, AtomMem consistently outperforms prior static-workflow methods by approximately 3-8 percentage points under the same Qwen3-8B backbone.
Takeaways & Limitations
Learned memory management discovers task-aligned operation patterns, with operation frequencies changing when task conditions change.
Takeaways & Limitations
RL optimization requires approximately 2 to 3 days on an 8-GPU cluster, which may bottleneck scaling to longer-horizon or noisier tasks.
Abstract
from arXiv · showhide
Equipping agents with memory is essential for solving real-world long-horizon problems. However, most existing agent memory mechanisms rely on static and hand-crafted workflows. This limits the performance and generalization ability of these memory designs, which highlights the need for a more flexible, learning-based memory framework. In this paper, we propose AtomMem, which reframes memory management as a dynamic decision-making problem. We deconstruct high-level memory processes into fundamental atomic CRUD (Create, Read, Update, Delete) operations, transforming the memory workflow into a learnable decision process. By combining supervised fine-tuning with reinforcement learning, AtomMem learns an autonomous, task-aligned policy to orchestrate memory behaviors tailored to specific task demands. Experimental results across 3 long-context benchmarks demonstrate that the trained AtomMem-8B consistently outperforms prior static-workflow memory methods. Further analysis of training dynamics shows that our learning-based formulation enables the agent to discover structured, task-aligned memory management strategies, highlighting a key advantage over predefined routines.
1 Introduction
AtomMem addresses the rigidity of expert-crafted memory workflows by reframing memory management as a learnable, task-aware decision process over atomic operations. Across memory-intensive tasks, it consistently outperforms static workflows, while learned operation patterns vary with task conditions.
- Most LLM-agent memory mechanisms use predefined pipelines, leaving memory operations non-autonomous.
- Static one-size-fits-all rules can fail in complex environments by prematurely discarding critical early information.
- AtomMem decomposes memory workflows into Create, Read, Update, and Delete operations, turning management into a learnable decision process.
- Reinforcement learning trains a task-aware policy that acquires experience over atomic operations and retains information important for task completion.
- Approximately 3-8 percentage points: AtomMem outperforms static-workflow methods across five memory-intensive tasks under the same Qwen3-8B backbone.
- Create, Update, and Delete usage increases while Read usage decreases and stabilizes, with different trends when task conditions change.
2 Related Works
Prior agent-memory research largely relies on hard-coded workflows, including imitation-based, prior-based, summarization-based, and heuristic-tool-based approaches. AtomMem instead uses atomic operations and reinforcement learning to learn a dynamic policy that adapts across tasks.
- Static Memory Workflow: Static memory workflows are hard-coded by experts, limiting adaptation across tasks and environments.
- Reinforcement Learning in Agent Memory: RL-based summarization methods overwrite memory step by step, enforcing updates even when new information is sparse.
- AtomMem: AtomMem decomposes high-level memory workflows into atomic CRUD operations and learns a task-aligned policy through reinforcement learning.
3 Method
AtomMem formulates agent memory management as a partially observable sequential decision problem with a complete atomic CRUD action space. It combines hybrid retrieval with reinforcement-learning optimization so memory actions and task performance are jointly learned.
- POMDP Formulation: Memory management is modeled as a POMDP in which memory is part of the environment and access is an explicit decision variable.The agent observes external information and memory observations shaped by prior memory actions.
- Atomic Memory Actions: CRUD operations provide a complete atomic action space for transforming memory states, while higher-level tools can be composed from these primitives.The framework emphasizes a general operator set rather than isolated memory tools.
- Memory Mechanism: At each step, the policy can generate a sequence of memory operations whose non-read actions compose a single transition.Create, Update, and Delete operations are executed sequentially within the environment step.
- Memory Mechanism: Hybrid retrieval combines mandatory scratchpad retrieval with selective query-based retrieval from stored memory entries.The scratchpad preserves global task state, while semantic similarity retrieves potentially relevant entries.
- Optimization Strategy: Reinforcement learning uses terminal task success as the reward and distributes the resulting task-level advantage across all output tokens, including memory operations.This jointly optimizes memory usage and task performance without external modules.
4 Experiments
AtomMem is evaluated across long-context QA and multi-turn web-search tasks, with robustness, training dynamics, ablations, and hyperparameter effects examined. It consistently benefits from learned memory policies, component synergy, selective updating, and task-matched retrieval.
- Evaluation Setup: Training uses 200-document, approximately 28K-token inputs, while testing scales to 800 documents, approximately 112K tokens, and up to 10 simultaneous questions.The evaluation also permits up to 40 web-tool calls per multi-turn search task.
- Main Results: In the 800-document setting, AtomMem maintains a significant performance lead despite a 4× extension of the training context.The authors characterize this as evidence of a content-aware policy that mitigates information overload as environmental noise increases.
- Main Results: Nearly 9 percentage points: RL training improves AtomMem on average across different task settings.The reported gains indicate that task-level feedback optimizes when and how memory operations are applied.
- Training Dynamics: RL shifts memory use toward increased Create, Update, and Delete operations and lower, stabilized Read usage, with different trends under changed task conditions.The learned policy moves from redundant retrieval toward compact, task-relevant memory maintenance.
- Memory Operation Ablations: Removing Update operations causes a substantial performance drop across all benchmarks, whereas disabling Delete has only a marginal impact.Selective revision helps maintain accurate, compact representations as new evidence arrives.
- Memory Component Ablations: Removing either scratchpad or external storage causes a 5–10-point drop across benchmarks, while removing both causes degradation exceeding 40 points.The results indicate that the two components preserve fundamentally different information and are not fully substitutable.
5 Case Study
The case study shows AtomMem adapting its memory workflow to the information available at each step. The agent selectively ignores, retrieves, stores, or consolidates memories based on context.
- AtomMem adapts its memory workflow according to the timing and order of key documents in HotpotQA.The cases demonstrate different decisions under different observation conditions.
- With unrelated documents, the agent records the absence of relevant information and stores only potentially related background entries.
- With partial information, the agent stores newly found evidence and requests memory retrieval for the missing piece.
- When all required information is present, the agent synthesizes the facts and updates memory by overwriting useless entries with the conclusion.
- These cases illustrate a context-sensitive workflow that dynamically decides when to ignore, retrieve, update, or consolidate memories.
6 Conclusion
AtomMem reframes agentic memory management as a dynamic decision-making problem by decomposing workflows into atomic CRUD operations. The resulting learnable process is intended to move beyond static pipelines and produce task-aligned memory policies.
- AtomMem deconstructs complex agentic memory workflows into atomic Create, Read, Update, and Delete operations.
- The framework treats memory management as a learnable decision process rather than a fixed workflow.
- Experimental results and training dynamics demonstrate a task-aligned memory policy.
Limitation
The paper identifies computational cost and coarse reinforcement-learning credit assignment as limitations. These constraints affect training efficiency and the precision with which memory entries’ contributions can be evaluated.
- RL optimization requires approximately 2 to 3 days on an 8-GPU cluster to train an agent model to convergence.
- This computational overhead may become a bottleneck when scaling to longer-horizon or noisier tasks.
- The current reinforcement-learning setup distributes task-level advantages evenly across actions rather than precisely measuring each memory entry’s contribution.
- The paper leaves more precise memory-entry credit assignment for future work because its evaluation methodology remains unresolved.
Ethical Statement
The paper reports that its data come from open-source datasets without personal or private information. It also specifies limited LLM use and records core implementation settings for training and inference.
- All data used in the work come from open-source datasets and contain no personal or private information.
- The LLM is used solely for writing and sentence refinement.
- Training is conducted on NVIDIA A800 GPUs, with shared training hyperparameters listed for all agents.
- Long-term memory uses four atomic CRUD operations: Create inserts entries, Read retrieves top-k similar entries, Update modifies entries, and Delete removes them.
- Inference uses temperature 0.7, top-p 1, and disabled top-k sampling.
A.3 Baseline Implementations
The baseline implementations compare retrieval-based, full-context, and agent-memory workflows under specified storage, retrieval, and context-extension settings. The section also introduces the atomic CRUD operation framework and associated experimental tables.
- RAG stores each document individually without chunking and retrieves six documents per question before concatenating them for answering.
- Full Context applies YaRN scaling to extend Qwen3-8B to 128K tokens for 800 documents, answering questions sequentially.
- mem0, Amem, and Generative Agents use AtomMem’s chunking strategy and retrieve separately for each question before concatenating results.
B Efficiency Analysis
The efficiency analysis reports that AtomMem achieves strong performance at comparatively high efficiency. AtomMem and MemAgent are more efficient than workflows that repeatedly invoke the LLM for each input, although AtomMem has slightly higher latency than MemAgent.
- AtomMem achieves optimal performance at comparatively high efficiency, according to the section’s efficiency analysis.The comparison is reported in Table 6.
- AtomMem and MemAgent achieve higher processing efficiency than other agent memory workflows because those workflows invoke the LLM multiple times per input.Serialized processing in the other workflows significantly reduces memory-mechanism efficiency and makes them nearly unscalable.
- AtomMem’s inference latency is slightly higher than MemAgent’s because of longer prompts from multiple tools and additional retrieval latency.
C Memory Capacity Limitation Experiment
The capacity-limitation experiment restricts memory to 20 entries and retrains the agent on HotpotQA to examine how operation rates adapt. Training increases Update and Delete use while reducing Create and Read use, with Read nearly disappearing after early information loss.
- The experiment limits the memory store to 20 entries, discarding entries beyond capacity, and retrains the agent on HotpotQA.The fine-tuned prompt informs the model of the database limitation and encourages greater use of Delete.
- Update and Delete frequencies increase significantly during training because these operations do not add entries to memory.The authors describe this trend as consistent with expectations.
- Create and Read frequencies decrease significantly under the capacity limit.The model learns to create entries within capacity, while Read drops almost to zero after early discarded entries reduce retrievable useful information.
- The agent’s prompts define short-term memory as a step-wise summary and long-term memory as a vector database managed through atomic operations.The system and memory prompts are shown in Figures 7 and 8.