SimpleMem: Efficient Lifelong Memory for LLM Agents 1 Introduction 2 The SimpleMem Architecture 2.1 Semantic Structured Compression 2.2 Online Semantic Synthesis 2.3 Intent-Aware Retrieval Planning 3 Experiments 3.1 Experimental Setup 3.2 Results and Analysis 3.3 Efficiency Analysis 3.4 Ablation Study 3.5 Case Study: Long-Term Temporal Grounding 4 Related Work 5 Conclusion A Detailed System Prompts A.1 Stage 1: Semantic Structured Compression Prompt A.2 Stage 2: Adaptive Retrieval Planning Prompt A.3 Stage 3: Reconstructive Synthesis Prompt A.4 LongMemEval Evaluation Prompt B Extended Implementation Details and Experiments B.1 Dataset Description B.2 Hyperparameter Configuration B.3 Hyperparameter Sensitivity Analysis SimpleMem: Efficient Lifelong Memory for LLM Agents Jiaqi Liu Yaofeng Su Peng Xia Siwei Han Zeyu Zheng Cihang Xie Mingyu Ding Huaxiu Yao Abstract To support long-term interaction in complex environments, LLM agents require memory systems that manage historical experiences. Existing approaches either retain full interaction histories via passive context extension, leading to substantial redundancy, or rely on iterative reasoning to filter noise, incurring high token costs. To address this challenge, we introduce SimpleMem, an efficient memory framework based on semantic lossless compression. We propose a three-stage pipeline designed to maximize information density and token utilization: (1) Semantic Structured Compression, which distills unstructured interactions into compact, multi-view indexed memory units; (2) Online Semantic Synthesis, an intra-session process that instantly integrates related context into unified abstract representations to eliminate redundancy; and (3) Intent-Aware Retrieval Planning, which infers search intent to dynamically determine retrieval scope and construct precise context efficiently. Experiments on benchmark datasets show that our method consistently outperforms baseline approaches in accuracy, retrieval efficiency, and inference cost, achieving an average F1 improvement of 26.4% in LoCoMo while reducing inference-time token consumption by up to 30×, demonstrating a superior balance between performance and efficiency. Code is available at https://github.com/aiming-lab/SimpleMem . Machine Learning, ICML 1 Introduction Large Language Model (LLM) agents have recently demonstrated remarkable capabilities across a wide range of tasks  (Xia et al. , 2025 ; Team et al. , 2025 ; Qiu et al. , 2025 ) . However, constrained by fixed context windows, existing agents exhibit significant limitations when engaging in long-context and multi-turn interaction scenarios  (Liu et al. , 2023 ; Wang et al. , 2024a ; Liu et al. , 2025 ; Hu et al. , 2025 ; Tu et al. , 2025 ) . To facilitate reliable long-term interaction, LLM agents require robust memory systems to efficiently manage and utilize historical experience  (Dev and Taranjeet, 2024 ; Fang et al. , 2025 ; Wang and Chen, 2025 ; Tang et al. , 2025 ; Yang et al. , 2025 ; Ouyang et al. , 2025 ) . While recent research has extensively explored the design of memory modules for LLM agents, current systems still suffer from suboptimal retrieval efficiency and low token utilization  (Fang et al. , 2025 ; Hu et al. , 2025 ) . On one hand, many existing systems maintain complete interaction histories through full-context extension  (Li et al. , 2025 ; Zhong et al. , 2024 ) . However, this approach introduce substantial redundant information  (Hu et al. , 2025 ) . Specifically, during long-horizon interactions, user inputs and model responses accumulate substantial low-entropy noise (e.g., repetitive logs, non-task-oriented dialogue), which degrades the effective information density of the memory buffer. This redundancy adversely affects memory retrieval and downstream reasoning, often leading to middle-context degradation phenomena  (Liu et al. , 2023 ) , while also incurring significant computational overhead during retrieval and secondary inference. On the other hand, some agentic frameworks mitigate noise through online filtering based on iterative reasoning procedures  (Yan et al. , 2025 ; Packer et al. , 2023 ) . Although such approaches improve retrieval relevance, they rely on repeated inference cycles, resulting in substantial computational cost, including increased latency and token usage. As a result, neither paradigm achieves efficient allocation of memory and computation resources. Figure 1 : Performance vs. Efficiency Trade-off. Comparison of F1 against Token Cost on the LoCoMo benchmark. SimpleMem achieves high accuracy with minimal token consumption. To address these limitations, we introduce SimpleMem , an efficient memory framework inspired by the Complementary Learning Systems (CLS) theory  (Kumaran et al. , 2016 ) and built around structured semantic compression. The objective of SimpleMem is to improve information efficiency under fixed context and token budgets. We develop a three-stage pipeline that supports dynamic memory compression, organization, and adaptive retrieval: (1) Semantic Structured Compression : we apply a semantic density gating mechanism via LLM-based qualitative assessment. The system uses the foundation model as a semantic judge to estimate information gain relative to history, preserving only content with high downstream utility. Retained information is reformulated into compact memory units and indexed jointly using dense semantic embeddings, sparse lexical features, and symbolic metadata. (2) Online Semantic Synthesis : inspired by biological consolidation and optimized for real-time interaction, we introduce an intra-session process that reorganizes memory on-the-fly. Related memory units are synthesized into higher-level abstract representations during the write phase, allowing repetitive or structurally similar experiences to be denoised and compressed immediately. (3) Intent-Aware Retrieval Planning : we employ a planning-based retrieval strategy that infers latent search intent to determine retrieval scope dynamically. The system constructs a precise context by querying multiple indexes (symbolic, semantic, lexical) and unifying results through ID-based deduplication, balancing structural constraints and semantic relevance without complex linear weighting. Our primary contribution is SimpleMem, an efficient memory framework grounded in structured semantic compression, which improves information efficiency through principled memory organization, online synthesis, and intent-aware planning. As shown in Figure  1 , our empirical experiments demonstrate that SimpleMem establishes a new state-of-the-art with an F1 score, outperforming strong baselines like Mem0 by 26.4%, while reducing inference token consumption by 30 × \times compared to full-context models. 2 The SimpleMem Architecture In this section, we present SimpleMem , which operates through a three-stage pipeline (see Figure  2 for the detailed architecture). Specifically, we first describe the Semantic Structured Compression , which utilizes implicit semantic gating to filter redundant interaction content and reformulate raw dialogue streams into compact memory units. Next, we describe Online Semantic Synthesis , an on-the-fly mechanism that instantly synthesizes related memory units into higher-level abstract representations, ensuring a compact and noise-free memory topology. Finally, we present Intent-Aware Retrieval Planning , which infers latent search intent to dynamically adjust retrieval scope, constructing precise and token-efficient contexts for downstream reasoning. Figure 2 : The SimpleMem Architecture. SimpleMem follows a three-stage pipeline: (1) Semantic Structured Compression filters low-utility dialogue and converts informative windows into compact, context-independent memory units. (2) Online Semantic Synthesis consolidates related fragments during writing, maintaining a compact and coherent memory topology. (3) Intent-Aware Retrieval Planning infers search intent to adapt retrieval scope and query forms, enabling parallel multi-view retrieval and token-efficient context construction. 2.1 Semantic Structured Compression A primary bottleneck in long-term interaction is context inflation , the accumulation of raw, low-entropy dialogue. For example, a large portion of interaction segments in the real-world consists of phatic chit-chat or redundant confirmations, which contribute little to downstream reasoning but consume substantial context capacity. To address this, we introduce a mechanism to actively filter and restructure information at the source. Specifically, first, incoming dialogue is segmented into overlapping sliding windows W W of fixed length, where each window represents a short contiguous span of recent interaction. These windows serve as the basic units for processing. Unlike traditional approaches that rely on rigid heuristic filters or separate classification models, we employ an implicit semantic density gating mechanism integrated directly into the generation process. We model the information assessment as an instruction-following task performed by the foundation model itself. The system leverages the attention mechanism of the LLM f f to identify high-entropy spans within the window W W relative to the immediate history H H . Formally, we define the gating function Φ gate \Phi_{\text{gate}} not as a binary classifier, but as a generative filter resulting from the model’s extraction capability: Φ gate ​ ( W ) → { m k } s.t. | { m k } | ≥ 0 \Phi_{\text{gate}}(W)\to\{m_{k}\}\quad\text{s.t.}\quad|\{m_{k}\}|\geq 0 (1) Here, the generation of an empty set ( ∅ \emptyset ) inherently signifies a low-density window (e.g., pure phatic chitchat), effectively discarding it without explicit threshold tuning. This instruction-driven gating allows the system to capture subtle semantic nuances while naturally filtering redundancy through the model’s semantic compression objectives. For windows containing valid semantic content, the system performs a unified De-linearization Transformation ℱ θ \mathcal{F}_{\theta} . Instead of sequential independent modules, we optimize the extraction, coreference resolution, and temporal anchoring as a joint generation task. The transformation projects the raw dialogue window W W directly into a set of context-independent memory units { m k } \{m_{k}\} : { m k } = ℱ θ ​ ( W ; H ) ≈ ( g time ∘ g coref ∘ g ext ) ​ ( W ) . \{m_{k}\}=\mathcal{F}_{\theta}(W;H)\approx(g_{\text{time}}\circ g_{\text{coref}}\circ g_{\text{ext}})(W). (2) In this unified pass, the model follows strict instructional constraints to: (1) resolve ambiguous pronouns to specific entity names ( g coref g_{\text{coref}} ), (2) convert relative temporal expressions into absolute ISO-8601 timestamps ( g time g_{\text{time}} ), and (3) atomize complex dialogue flows into self-contained factual statements. By aggregating all resulting units m k m_{k} across sliding windows, we obtain the complete memory set ℳ \mathcal{M} . Following compression, the system organizes the memory units to support storage and retrieval. This stage consists of two synergistic processes: (i) structured multi-view indexing for precise access, and (ii) online semantic synthesis for minimizing redundancy at the point of creation. To support flexible and high-fidelity retrieval, each memory unit is indexed through three complementary representations. First, at the Semantic Layer , we map the entry to a dense vector space s k s_{k} using embedding models, capturing abstract meaning to enable fuzzy matching (e.g., retrieving "latte" when querying "hot drink"). Second, the Lexical Layer utilizes an inverted index-based sparse representation. This acts as a high-dimensional sparse vector l k l_{k} focusing on exact keyword matches and rare proper nouns, ensuring that specific entities are not diluted in dense vector space. Third, the Symbolic Layer extracts structured metadata, such as timestamps and entity types, to enable deterministic filtering logic. Formally, for a given memory unit m k m_{k} , these projections form the comprehensive indexing ℐ \mathcal{I} : ℐ ​ ( m t , k ) = { s k = E dense ​ ( m k ) (Semantic Layer) l k = E sparse ​ ( m k ) (Lexical Layer) r k = E sym ​ ( m k ) (Symbolic Layer) \mathcal{I}(m_{t,k})=\begin{cases}s_{k}=E_{\text{dense}}(m_{k})&\text{(Semantic Layer)}\\ l_{k}=E_{\text{sparse}}(m_{k})&\text{(Lexical Layer)}\\ r_{k}=E_{\text{sym}}(m_{k})&\text{(Symbolic Layer)}\end{cases} (3) This architecture allows the system to flexibly query information based on conceptual similarity, exact keyword matches, or structured metadata constraints. 2.2 Online Semantic Synthesis While this multi-view indexing strategy facilitates access, naively accumulating raw extractions leads to fragmentation, causing the memory structure to grow in a purely additive and unregulated manner that fails to adapt in real time to the evolving semantic context of an ongoing interaction. To address this, we introduce Online Semantic Synthesis , an intra-session consolidation mechanism. Unlike traditional systems that rely on asynchronous background maintenance, SimpleMem performs synthesis on-the-fly during the write phase. The model analyzes the stream of extracted facts within the current session scope and synthesizes related fragments into unified, high-density entries before they are committed to the database. Formally, we define this synthesis as a transformation function ℱ syn \mathcal{F}_{\text{syn}} that maps a set of new observations O session O_{\text{session}} to a consolidated memory entry ℱ syn ​ ( O session , 𝒞 context ; f ) \mathcal{F}_{\text{syn}}(O_{\text{session}},\mathcal{C}_{\text{context}};f) , where 𝒞 context \mathcal{C}_{\text{context}} represents the current conversational context. This operation denoises the input by merging scattered details into a coherent whole. For instance, rather than storing three separate fragments like "User wants coffee" , "User prefers oat milk" , and "User likes it hot" , the synthesis layer consolidates them into a single, comprehensive entry: "User prefers hot coffee with oat milk" . This proactive synthesis ensures that the memory topology remains compact and free of redundant fragmentation, significantly reducing the burden on the retrieval system during future interactions. 2.3 Intent-Aware Retrieval Planning After memory entries are organized, the final challenge is to retrieve relevant information under constrained context budgets. Standard retrieval approaches typically fetch a fixed number of entries, which often results in recall failure for complex queries or token wastage for simple ones. To address this, we introduce Intent-Aware Retrieval Planning , a mechanism that dynamically determines the retrieval scope and depth by inferring the user’s latent search intent. Unlike systems that rely on scalar complexity classifiers, SimpleMem leverages the reasoning capabilities of the LLM to generate a comprehensive retrieval plan. Given a query q q and history H H , the planning module 𝒫 \mathcal{P} acts as a reasoner to decompose the information needs and estimate the necessary search depth d d : { q sem , q lex , q sym , d } ∼ 𝒫 ​ ( q , H ) \{q_{\text{sem}},q_{\text{lex}},q_{\text{sym}},d\}\sim\mathcal{P}(q,H) (4) where q sem q_{\text{sem}} , q lex q_{\text{lex}} , and q sym q_{\text{sym}} are optimized queries for semantic, lexical, and symbolic retrieval respectively. The parameter d d represents the adaptive retrieval depth , which reflects the estimated complexity of the query. Based on d d , the system utilizes a candidate limit n n (where n ∝ d n\propto d ) to balance recall coverage against context window constraints. Guided by this plan, the system executes a parallel multi-view retrieval. We simultaneously query all three index layers defined in Section 2.1 , imposing the quantity limit n n on each path: ℛ sem \displaystyle\mathcal{R}_{\text{sem}} = Top − ⁡ n ​ ( cos ⁡ ( E ​ ( q sem ) , E ​ ( m i ) ) ∣ m i ∈ ℳ ) \displaystyle=\operatorname{Top-}n(\cos(E(q_{\text{sem}}),E(m_{i}))\mid m_{i}\in\mathcal{M}) (5) ℛ lex \displaystyle\mathcal{R}_{\text{lex}} = Top − ⁡ n ​ ( BM25 ⁡ ( q lex , m i ) ∣ m i ∈ ℳ ) \displaystyle=\operatorname{Top-}n(\operatorname{BM25}(q_{\text{lex}},m_{i})\mid m_{i}\in\mathcal{M}) ℛ sym \displaystyle\mathcal{R}_{\text{sym}} = Top − ⁡ n ​ ( { m i ∈ ℳ ∣ Meta ​ ( m i ) ⊧ q sym } ) \displaystyle=\operatorname{Top-}n(\{m_{i}\in\mathcal{M}\mid\text{Meta}(m_{i})\models q_{\text{sym}}\}) Here, each view captures distinct relevance signals: ℛ sem \mathcal{R}_{\text{sem}} retrieves based on dense embedding similarity; ℛ lex \mathcal{R}_{\text{lex}} matches exact keywords or proper nouns; and ℛ sym \mathcal{R}_{\text{sym}} filters entries based on structured metadata constraints. Finally, we construct the context 𝒞 q \mathcal{C}_{q} by merging the results from these three views using a set union operation. This step naturally deduplicates overlapping entries, ensuring a comprehensive yet compact context: 𝒞 q = ℛ sem ∪ ℛ lex ∪ ℛ sym \mathcal{C}_{q}=\mathcal{R}_{\text{sem}}\cup\mathcal{R}_{\text{lex}}\cup\mathcal{R}_{\text{sym}} (6) This hybrid approach ensures that strong signals from any view are preserved, allowing the system to adaptively scale its retrieval volume n n based on the inferred depth d d . 3 Experiments In this section, we evaluate SimpleMem on the benchmark to answer the following research questions: (1) Does SimpleMem outperform other memory systems in complex long-term reasoning understanding tasks? (2) Can SimpleMem achieve a superior trade-off between retrieval accuracy and token consumption? (3) How effective are the proposed components? (4) What factors account for the observed performance and efficiency gains? Table 1 : Performance on the LoCoMo benchmark with High-Capability Models (GPT-4.1 series and Qwen3-Plus). SimpleMem achieves superior efficiency-performance balance. Model Method MultiHop Temporal OpenDomain SingleHop Average Token F1 BLEU F1 BLEU F1 BLEU F1 BLEU F1 BLEU Cost GPT-4.1-mini LoCoMo 25.02 21.62 12.04 10.63 19.05 17.07 18.68 15.87 18.70 16.30 16,910 ReadAgent 6.48 5.6 5.31 4.23 7.66 6.62 9.18 7.91 7.16 6.09 643 MemoryBank 5.00 4.68 5.94 4.78 5.16 4.52 5.72 4.86 5.46 4.71 432 MemGPT 17.72 16.02 19.44 16.54 11.29 10.18 25.59 24.25 18.51 16.75 16,977 A-Mem 25.06 17.32 51.01 44.75 13.22 14.75 41.02 36.99 32.58 28.45 2,520 LightMem 24.96 21.66 20.55 18.39 19.21 17.68 33.79 29.66 24.63 21.85 612 Mem0 30.14 27.62 48.91 44.82 16.43 14.94 41.3 36.17 34.20 30.89 973 SimpleMem 43.46 38.82 58.62 50.10 19.76 18.04 51.12 43.53 43.24 37.62 531 GPT-4o LoCoMo 28.00 18.47 9.09 5.78 16.47 14.80 61.56 54.19 28.78 23.31 16,910 ReadAgent 14.61 9.95 4.16 3.19 8.84 8.37 12.46 10.29 10.02 7.95 805 MemoryBank 6.49 4.69 2.47 2.43 6.43 5.30 8.28 7.10 5.92 4.88 569 MemGPT 30.36 22.83 17.29 13.18 12.24 11.87 40.16 36.35 25.01 21.06 16,987 A-Mem 32.86 23.76 39.41 31.23 17.10 15.84 44.43 38.97 33.45 27.45 1,216 LightMem 28.15 21.83 36.53 29.12 13.38 11.54 33.76 28.02 27.96 22.63 645 Mem0 35.13 27.56 52.38 44.15 17.73 15.92 39.12 35.43 36.09 30.77 985 SimpleMem 35.89 32.83 56.71 20.57 18.23 16.34 45.41 39.25 39.06 27.25 550 Qwen3-Plus LoCoMo 24.15 18.94 16.57 13.28 11.81 10.58 38.58 28.16 22.78 17.74 16,910 ReadAgent 9.52 6.8 ... [OUTPUT TRUNCATED - 12972 chars omitted out of 62972 total] ... which is approximately 33% faster than LightMem and Mem0. This gain arises from the adaptive retrieval mechanism, which dynamically limits retrieval scope and prioritizes high-level abstract representations before accessing fine-grained details. By restricting retrieval to only the most relevant memory entries, the system avoids the expensive neighbor traversal and expansion operations that commonly dominate the latency of graph-based memory systems. When considering the total time-to-insight, SimpleMem achieves a 4 × \times speedup over Mem0 and a 12 × \times speedup over A-Mem. Crucially, this efficiency does not come at the expense of performance. On the contrary, SimpleMem achieves the highest Average F1 among all compared methods. These results support our central claim that structured semantic compression and adaptive retrieval produce a more compact and effective reasoning substrate than raw context retention or graph-centric memory designs, enabling a superior balance between accuracy and computational efficiency. Table 4 : Comparison of construction time, retrieval time, total experiment time, and average F1 score across different memory systems (tested on LoCoMo-10 with GPT-4.1-mini; time values are reported as per-sample averages on LoCoMo-10). Model Construction Time Retrieval Time Total Time Average F1 A-mem 5140.5s 796.7s 5937.2s 32.58 Lightmem 97.8s 577.1s 675.9s 24.63 Mem0 1350.9s 583.4s 1934.3s 34.20 SimpleMem 92.6s 388.3s 480.9s 43.24 3.4 Ablation Study In addition, we conduct an ablation study using the GPT-4.1-mini backend. We investigate the contribution of three key components. The results are summarized in Table 5 . Table 5 : Full ablation analysis with GPT-4.1-mini backend. The "Diff" columns indicate the percentage drop relative to the full SimpleMem model. The results confirm that each stage contributes significantly to specific reasoning capabilities. Configuration Multi-hop Temporal Open Domain Single Hop Average F1 Diff F1 Diff F1 Diff F1 Diff F1 Diff Full SimpleMem 43.46 - 58.62 - 19.76 - 51.12 - 43.24 -    w/o Semantic Compression 34.20 ( ↓ \downarrow 21.3%) 25.40 ( ↓ \downarrow 56.7%) 17.50 ( ↓ \downarrow 11.4%) 48.05 ( ↓ \downarrow 6.0%) 31.29 ( ↓ \downarrow 27.6%)    w/o Online Synthesis 29.85 ( ↓ \downarrow 31.3%) 55.10 ( ↓ \downarrow 6.0%) 18.20 ( ↓ \downarrow 7.9%) 49.80 ( ↓ \downarrow 2.6%) 38.24 ( ↓ \downarrow 11.6%)    w/o Intent-Aware Retrieval 38.60 ( ↓ \downarrow 11.2%) 56.80 ( ↓ \downarrow 3.1%) 14.50 ( ↓ \downarrow 26.6%) 41.20 ( ↓ \downarrow 19.4%) 37.78 ( ↓ \downarrow 12.6%) Figure 3 : A Case of SimpleMem for Long-Term Multi-Session Dialogues. SimpleMem processes multi-session dialogues by filtering redundant content, normalizing temporal references, and organizing memories into compact representations. During retrieval, it adaptively combines semantic, lexical, and symbolic signals to select relevant entries. Impact of Semantic Structured Compression. Replacing the proposed compression pipeline with standard chunk-based storage leads to a substantial degradation in temporal reasoning performance. Specifically, removing semantic structured compression reduces the Temporal F1 by 56.7%, from 58.62 to 25.40. This drop indicates that without context normalization steps such as resolving coreferences and converting relative temporal expressions into absolute timestamps, the retriever struggles to disambiguate events along the timeline. As a result, performance regresses to levels comparable to conventional retrieval-augmented generation systems that rely on raw or weakly structured context. Impact of Online Semantic Synthesis. Disabling online semantic synthesis results in a 31.3% decrease in multi-hop reasoning performance. Without on-the-fly consolidation during the write phase, semantically related facts accumulate as fragmented entries, forcing the retriever to assemble dispersed evidence at query time. This fragmentation inflates contextual redundancy and rapidly exhausts the available context window in complex queries. The observed degradation demonstrates that proactive, intra-session synthesis is essential for maintaining a compact and semantically coherent memory topology, and for transforming local observations into reusable, high-density abstractions. Intent-Aware Retrieval Planning. Removing intent-aware retrieval planning and reverting to a fixed-depth retrieval strategy primarily degrades performance on open-domain and single-hop tasks, with drops of 26.6% and 19.4%, respectively. In the absence of query-aware adjustment, the system either retrieves insufficient context for entity-specific queries or introduces excessive irrelevant information for simple queries. These results highlight the importance of dynamically modulating retrieval scope to balance relevance and efficiency during inference. 3.5 Case Study: Long-Term Temporal Grounding To illustrate how SimpleMem handles long-horizon conversational history, Figure  3 presents a representative multi-session example spanning two weeks and approximately 24,000 raw tokens. SimpleMem filters low-information dialogue during ingestion and retains only high-utility memory entries, reducing the stored memory to about 800 tokens without losing task-relevant content. Temporal Normalization. Relative temporal expressions such as last week” and yesterday” refer to different absolute times across sessions. SimpleMem resolves it into absolute timestamps at memory construction time, ensuring consistent temporal grounding over long interaction gaps. Precise Retrieval. When queried about Sarah’s past artworks, the intent-aware retrieval planner infers both the semantic focus (art-related activities) and the temporal constraints implied by the query. The system then performs parallel multi-view retrieval, combining semantic similarity with symbolic filtering to exclude unrelated activities and return only temporally valid entries. This example demonstrates how structured compression, temporal normalization, and adaptive retrieval jointly enable reliable long-term reasoning under extended interaction histories. 4 Related Work Memory Systems for LLM Agents. Recent approaches manage memory through virtual context or structured representations. Virtual context methods, including MemGPT (Packer et al. , 2023 ) , MemoryOS (Kang et al. , 2025 ) , and SCM (Wang et al. , 2023 ) , extend interaction length via paging or stream-based controllers  (Wang et al. , 2024b ) but typically store raw conversation logs, leading to redundancy and increasing processing costs. In parallel, structured and graph-based systems, such as MemoryBank (Zhong et al. , 2024 ) , Mem0 (Dev and Taranjeet, 2024 ) , Zep (Rasmussen et al. , 2025 ) , A-Mem (Xu et al. , 2025 ) , and O-Mem (Wang et al. , 2025 ) , impose structural priors to improve coherence but still rely on raw or minimally processed text, preserving referential and temporal ambiguities that degrade long-term retrieval. In contrast, SimpleMem adopts a semantic compression mechanism that converts dialogue into independent, self-contained facts, explicitly resolving referential and temporal ambiguities prior to storage. Context Management and Retrieval Efficiency. Beyond memory storage, efficient access to historical information remains a core challenge. Existing approaches primarily rely on either long-context models or retrieval-augmented generation (RAG). Although recent LLMs support extended context windows (OpenAI, 2025 ; Deepmind, 2025 ; Anthropic, 2025 ) , and prompt compression methods aim to reduce costs (Jiang et al. , 2023a ; Liskavetsky and others, 2025 ) , empirical studies reveal the “Lost-in-the-Middle” effect (Liu et al. , 2023 ; Kuratov and others, 2024 ) , where reasoning performance degrades as context length increases, alongside prohibitive computational overhead for lifelong agents. RAG-based methods (Lewis et al. , 2020 ; Asai et al. , 2023 ; Jiang et al. , 2023b ) , including structurally enhanced variants such as GraphRAG (Edge et al. , 2024 ; Zhao et al. , 2025 ) and LightRAG (Guo et al. , 2024 ) , decouple memory from inference but are largely optimized for static knowledge bases, limiting their effectiveness for dynamic, time-sensitive episodic memory. In contrast, SimpleMem improves retrieval efficiency through Intent-Aware Retrieval Planning , jointly leveraging semantic, lexical, and symbolic signals to construct query-specific retrieval plans and dynamically adapt the retrieval budget, achieving token-efficient reasoning under constrained context budgets. 5 Conclusion We introduce SimpleMem, an efficient agent memory architecture grounded in the principle of semantic lossless compression. By treating memory as an active process rather than passive storage, SimpleMem integrates Semantic Structured Compression to filter noise at the source, Online Semantic Synthesis to consolidate fragmented observations during writing, and Intent-Aware Retrieval Planning to dynamically adapt retrieval scope. Empirical evaluation on the LoCoMo and LongMemEval-S benchmark demonstrates the effectiveness and efficiency of our method. Acknowledgement This work is partially supported by Amazon Research Award, Cisco Faculty Research Award, and Coefficient Giving. This work is also partly supported by the National Center for Transportation Cybersecurity and Resiliency (TraCR) (a U.S. Department of Transportation National University Transportation Center) headquartered at Clemson University, Clemson, South Carolina, USA (USDOT Grant #69A3552344812). Any opinions, findings, conclusions, and recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of TraCR, and the U.S. Government assumes no liability for the contents or use thereof. References Anthropic (2025) Claude 3.7 sonnet and claude code . Note: https://www.anthropic.com/news/claude-3-7-sonnet Cited by: §4 . A. Asai, Z. Wu, Y. Wang, A. Sil, and H. Hajishirzi (2023) Self-rag: learning to retrieve, generate, and critique through self-reflection . arXiv preprint arXiv:2310.11511 . Cited by: §4 . G. Deepmind (2025) Gemini 2.5: Our most intelligent AI model — blog.google . Note: https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/#gemini-2-5-thinking Accessed: 2025-03-25 Cited by: §4 . K. Dev and S. Taranjeet (2024) Mem0: the memory layer for ai agents. . Note: https://github.com/mem0ai/mem0 Cited by: §1 , §3.1 , §4 . D. Edge, H. Trinh, N. Cheng, J. Bradley, A. Chao, A. Mody, S. Truitt, and J. Larson (2024) From local to global: a graph rag approach to query-focused summarization . arXiv preprint arXiv:2404.16130 . Cited by: §4 . J. Fang, X. Deng, H. Xu, Z. Jiang, Y. Tang, Z. Xu, S. Deng, Y. Yao, M. Wang, S. Qiao, et al. (2025) LightMem: lightweight and efficient memory-augmented generation . arXiv preprint arXiv:2510.18866 . Cited by: §1 , §1 , §3.1 . Z. Guo, L. Xia, Y. Yu, T. Ao, and C. Huang (2024) Lightrag: simple and fast retrieval-augmented generation . arXiv preprint arXiv:2410.05779 . Cited by: §4 . Y. Hu, S. Liu, Y. Yue, G. Zhang, B. Liu, F. Zhu, J. Lin, H. Guo, S. Dou, Z. Xi, et al. (2025) Memory in the age of ai agents . arXiv preprint arXiv:2512.13564 . Cited by: §1 , §1 . H. Jiang, Q. Wu, C. Lin, Y. Yang, and L. Qiu (2023a) LLMLingua: compressing prompts for accelerated inference of large language models . arXiv preprint arXiv:2310.05736 . Cited by: §4 . Z. Jiang, F. F. Xu, L. Gao, Z. Sun, Q. Liu, J. Dwivedi-Yu, Y. Yang, J. Callan, and G. Neubig (2023b) Active retrieval augmented generation . arXiv preprint arXiv:2305.06983 . Cited by: §4 . J. Kang, M. Ji, Z. Zhao, and T. Bai (2025) Memory os of ai agent . arXiv preprint arXiv:2506.06326 . Cited by: §4 . D. Kumaran, D. Hassabis, and J. L. McClelland (2016) What learning systems do intelligent agents need? complementary learning systems theory updated . Trends in cognitive sciences 20 ( 7 ), pp. 512–534 . Cited by: §1 . Y. Kuratov et al. (2024) In case of context: investigating the effects of long context on language model performance . arXiv preprint . Cited by: §4 . K. Lee, X. Chen, H. Furuta, J. Canny, and I. Fischer (2024) A human-inspired reading agent with gist memory of very long contexts . arXiv preprint arXiv:2402.09727 . Cited by: §3.1 . P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W. Yih, T. Rocktäschel, et al. (2020) Retrieval-augmented generation for knowledge-intensive nlp tasks . Advances in Neural Information Processing Systems 33 , pp. 9459–9474 . Cited by: §4 . Z. Li, S. Song, H. Wang, S. Niu, D. Chen, J. Yang, C. Xi, H. Lai, J. Zhao, Y. Wang, J. Ren, Z. Lin, J. Huo, T. Chen, K. Chen, K. Li, Z. Yin, Q. Yu, B. Tang, H. Yang, Z. Xu, and F. Xiong (2025) MemOS: an operating system for memory-augmented generation (mag) in large language models . ArXiv abs/2505.22101 . External Links: Link Cited by: §1 . A. Liskavetsky et al. (2025) COMPRESSOR: context-aware prompt compression for enhanced llm inference . arXiv preprint . Cited by: §4 . J. Liu, K. Xiong, P. Xia, Y. Zhou, H. Ji, L. Feng, S. Han, M. Ding, and H. Yao (2025) Agent0-vl: exploring self-evolving agent for tool-integrated vision-language reasoning . arXiv preprint arXiv:2511.19900 . Cited by: §1 . N. F. Liu, K. Lin, J. Hewitt, A. Paranjape, M. Bevilacqua, F. Petroni, and P. Liang (2023) Lost in the middle: how language models use long contexts . arXiv preprint arXiv:2307.03172 . Cited by: §1 , §1 , §4 . A. Maharana, D. Lee, S. Tulyakov, M. Bansal, F. Barbieri, and Y. Fang (2024) Evaluating very long-term conversational memory of llm agents . External Links: 2402.17753 , Link Cited by: §B.1 , §3.1 , §3.1 , §3.1 . OpenAI (2025) Introducing gpt-5 . Note: https://openai.com/index/introducing-gpt-5/ Cited by: §4 . S. Ouyang, J. Yan, I. Hsu, Y. Chen, K. Jiang, Z. Wang, R. Han, L. T. Le, S. Daruki, X. Tang, et al. (2025) Reasoningbank: scaling agent self-evolving with reasoning memory . arXiv preprint arXiv:2509.25140 . Cited by: §1 . C. Packer, V. Fang, S. G. Patil, K. Lin, S. Wooders, and J. Gonzalez (2023) MemGPT: towards llms as operating systems . ArXiv abs/2310.08560 . External Links: Link Cited by: §1 , §3.1 , §4 . J. Qiu, X. Qi, T. Zhang, X. Juan, J. Guo, Y. Lu, Y. Wang, Z. Yao, Q. Ren, X. Jiang, et al. (2025) Alita: generalist agent enabling scalable agentic reasoning with minimal predefinition and maximal self-evolution . arXiv preprint arXiv:2505.20286 . Cited by: §1 . P. Rasmussen, P. Paliychuk, T. Beauvais, J. Ryan, and D. Chalef (2025) Zep: a temporal knowledge graph architecture for agent memory . arXiv preprint arXiv:2501.13956 . Cited by: §4 . X. Tang, T. Qin, T. Peng, Z. Zhou, D. Shao, T. Du, X. Wei, P. Xia, F. Wu, H. Zhu, et al. (2025) Agent kb: leveraging cross-domain experience for agentic problem solving . arXiv preprint arXiv:2507.06229 . Cited by: §1 . T. D. Team, B. Li, B. Zhang, D. Zhang, F. Huang, G. Li, G. Chen, H. Yin, J. Wu, J. Zhou, et al. (2025) Tongyi deepresearch technical report . arXiv preprint arXiv:2510.24701 . Cited by: §1 . A. Tu, W. Xuan, H. Qi, X. Huang, Q. Zeng, S. Talaei, Y. Xiao, P. Xia, X. Tang, Y. Zhuang, et al. (2025) Position: the hidden costs and measurement gaps of reinforcement learning with verifiable rewards . arXiv preprint arXiv:2509.21882 . Cited by: §1 . B. Wang, X. Liang, J. Yang, H. Huang, S. Wu, P. Wu, L. Lu, Z. Ma, and Z. Li (2023) Enhancing large language model with self-controlled memory framework . arXiv preprint arXiv:2304.13343 . Cited by: §4 . P. Wang, M. Tian, J. Li, Y. Liang, Y. Wang, Q. Chen, T. Wang, Z. Lu, J. Ma, Y. E. Jiang, et al. (2025) O-mem: omni memory system for personalized, long horizon, self-evolving agents . arXiv e-prints , pp. arXiv–2511 . Cited by: §4 . T. Wang, M. Tao, R. Fang, H. Wang, S. Wang, Y. E. Jiang, and W. Zhou (2024a) Ai persona: towards life-long personalization of llms . arXiv preprint arXiv:2412.13103 . Cited by: §1 . Y. Wang and X. Chen (2025) Mirix: multi-agent memory system for llm-based agents . arXiv preprint arXiv:2507.07957 . Cited by: §1 . Z. Z. Wang, J. Mao, D. Fried, and G. Neubig (2024b) Agent workflow memory . arXiv preprint arXiv:2409.07429 . Cited by: §4 . D. Wu, H. Wang, W. Yu, Y. Zhang, K. Chang, and D. Yu (2024) Longmemeval: benchmarking chat assistants on long-term interactive memory . arXiv preprint arXiv:2410.10813 . Cited by: §3.1 , §3.1 . P. Xia, K. Zeng, J. Liu, C. Qin, F. Wu, Y. Zhou, C. Xiong, and H. Yao (2025) Agent0: unleashing self-evolving agents from zero data via tool-integrated reasoning . arXiv preprint arXiv:2511.16043 . Cited by: §1 . W. Xu, Z. Liang, K. Mei, H. Gao, J. Tan, and Y. Zhang (2025) A-mem: agentic memory for llm agents . ArXiv abs/2502.12110 . External Links: Link Cited by: §3.1 , §4 . B. Yan, C. Li, H. Qian, S. Lu, and Z. Liu (2025) General agentic memory via deep research . arXiv preprint arXiv:2511.18423 . Cited by: §1 . B. Yang, L. Xu, L. Zeng, K. Liu, S. Jiang, W. Lu, H. Chen, X. Jiang, G. Xing, and Z. Yan (2025) ContextAgent: context-aware proactive llm agents with open-world sensory perceptions . arXiv preprint arXiv:2505.14668 . Cited by: §1 . Y. Zhao, J. Zhu, Y. Guo, K. He, and X. Li (2025) Eˆ 2graphrag: streamlining graph-based rag for high efficiency and effectiveness . arXiv preprint arXiv:2505.24226 . Cited by: §4 . W. Zhong, L. Guo, Q. Gao, H. Ye, and Y. Wang (2024) Memorybank: enhancing large language models with long-term memory . In Proceedings of the AAAI Conference on Artificial Intelligence , Vol. 38 , pp. 19724–19731 . Cited by: §1 , §3.1 , §4 . Appendix A Detailed System Prompts To ensure full reproducibility of the SimpleMem pipeline, we provide the exact system prompts used in the key processing stages. All prompts are designed to be model-agnostic but were optimized for GPT-4o-mini in our experiments to ensure cognitive economy. A.1 Stage 1: Semantic Structured Compression Prompt This prompt performs entropy-aware filtering and context normalization. Its goal is to transform raw dialogue windows into compact, context-independent memory units while excluding low-information interaction content. Listing 1: Prompt for Semantic Structured Compression and Normalization. ⬇ You are a memory encoder in a long - term memory system . Your task is to transform raw conversational input into compact , self - contained memory units . INPUT METADATA : Window Start Time : { window_start_time } ( ISO 8601) Participants : { speakers_list } INSTRUCTIONS : 1. Information Filtering : - Discard social filler , acknowledgements , and conversational routines that introduce no new factual or semantic information . - Discard redundant confirmations unless they modify or finalize a decision . - If no informative content is present , output an empty list . 2. Context Normalization : - Resolve all pronouns and implicit references into explicit entity names . - Ensure each memory unit is interpretable without access to prior dialogue . 3. Temporal Normalization : - Convert relative temporal expressions ( e . g ., " tomorrow ", " last week ") into absolute ISO 8601 timestamps using the window start time . 4. Memory Unit Extraction : - Decompose complex utterances into minimal , indivisible factual statements . INPUT DIALOGUE : { dialogue_window } OUTPUT FORMAT ( JSON ): { " memory_units ": [ { " content ": " Alice agreed to meet Bob at the Starbucks on 5 th Avenue on 2025-11-20 T14 :00:00.", " entities ": [" Alice ", " Bob ", " Starbucks ", "5 th Avenue "], " topic ": " Meeting Planning ", " timestamp ": "2025-11-20 T14 :00:00", " salience ": " high " } ] } A.2 Stage 2: Adaptive Retrieval Planning Prompt This prompt analyzes the user query prior to retrieval. Its purpose is to estimate query complexity and generate a structured retrieval plan that adapts retrieval scope accordingly. Listing 2: Prompt for Query Analysis and Adaptive Retrieval Planning. ⬇ Analyze the following user query and generate a retrieval plan . Your objective is to retrieve sufficient information while minimizing unnecessary context usage . USER QUERY : { user_query } INSTRUCTIONS : 1. Query Complexity Estimation : - Assign " LOW " if the query can be answered via direct fact lookup or a single memory unit . - Assign " HIGH " if the query requires aggregation across multiple events , temporal comparison , or synthesis of patterns . 2. Retrieval Signals : - Lexical layer : extract exact keywords or entity names . - Temporal layer : infer absolute time ranges if relevant . - Semantic layer : rewrite the query into a declarative form suitable for semantic matching . OUTPUT FORMAT ( JSON ): { " complexity ": " HIGH ", " retrieval_rationale ": " The query requires reasoning over multiple temporally separated events .", " lexical_keywords ": [" Starbucks ", " Bob "], " temporal_constraints ": { " start ": "2025-11-01 T00 :00:00", " end ": "2025-11-30 T23 :59:59" }, " semantic_query ": " The user is asking about the scheduled meeting with Bob , including location and time ." } A.3 Stage 3: Reconstructive Synthesis Prompt This prompt guides the final answer generation using retrieved memory. It combines high-level abstract representations with fine-grained factual details to produce a grounded response. Listing 3: Prompt for Reconstructive Synthesis (Answer Generation). ⬇ You are an assistant with access to a structured long - term memory . USER QUERY : { user_query } RETRIEVED MEMORY ( Ordered by Relevance ): [ ABSTRACT REPRESENTATIONS ]: { retrieved_abstracts } [ DETAILED MEMORY UNITS ]: { retrieved_units } INSTRUCTIONS : 1. Hierarchical Reasoning : - Use abstract representations to capture recurring patterns or general user preferences . - Use detailed memory units to ground the response with specific facts . 2. Conflict Handling : - If inconsistencies arise , prioritize the most recent memory unit . - Optionally reference abstract patterns when relevant . 3. Temporal Consistency : - Ensure all statements respect the timestamps provided in memory . 4. Faithfulness : - Base the answer strictly on the retrieved memory . - If required information is missing , respond with : " I do not have enough information in my memory ." FINAL ANSWER : A.4 LongMemEval Evaluation Prompt For the LongMemEval benchmark, we employed gpt-4.1-mini as the judge to evaluate the correctness of the agent’s responses. The prompt strictly instructs the judge to focus on semantic and temporal consistency rather than exact string matching. The specific prompt template used is provided below: Listing 4: LLM-as-a-Judge Evaluation Prompt. ⬇ Your task is to label an answer to a question as ’ CORRECT ’ or ’ WRONG ’. You will be given the following data : (1) a question ( posed by one user to another user ), (2) a ’ gold ’ ( ground truth ) answer , (3) a generated answer which you will score as CORRECT / WRONG . The point of the question is to ask about something one user should know about the other user based on their prior conversations . The gold answer will usually be a concise and short answer that includes the referenced topic , for example : Question : Do you remember what I got the last time I went to Hawaii ? Gold answer : A shell necklace The generated answer might be much longer , but you should be generous with your grading - as long as it touches on the same topic as the gold answer , it should be counted as CORRECT . For time related questions , the gold answer will be a specific date , month , year , etc . The generated answer might be much longer or use relative time references ( like " last Tuesday " or " next month "), but you should be generous with your grading - as long as it refers to the same date or time period as the gold answer , it should be counted as CORRECT . Even if the format differs ( e . g ., " May 7 th " vs "7 May "), consider it CORRECT if it ’ s the same date . Now it ’ s time for the real question : Question : { question } Gold answer : { gold_answer } Generated answer : { generated_answer } First , provide a short ( one sentence ) explanation of your reasoning , then finish with CORRECT or WRONG . Do NOT include both CORRECT and WRONG in your response , or it will break the evaluation script . Just return the label CORRECT or WRONG in a json format with the key as " label ". Appendix B Extended Implementation Details and Experiments B.1 Dataset Description LoCoMo   (Maharana et al. , 2024 ) is specifically designed to test the limits of LLMs in processing long-term conversational dependencies. The dataset comprises conversation samples ranging from 200 to 400 turns, containing complex temporal shifts and interleaved topics. The evaluation set consists of 1,986 questions categorized into four distinct reasoning types: (1) Multi-Hop Reasoning: Questions requiring the synthesis of information from multiple disjoint turns (e.g., ‘‘Based on what X said last week and Y said today...’’ ); (2) Temporal Reasoning: Questions testing the model’s ability to understand event sequencing and absolute timelines (e.g., ‘‘Did X happen before Y?’’ ); (3) Open Domain: General knowledge questions grounded in the conversation context; (4) Single Hop: Direct retrieval tasks requiring exact matching of specific facts. LongMemEval-S benchmark. The defining characteristic of this dataset is its extreme context length , which poses a unique and severe challenge for memory systems. Unlike standard benchmarks, LongMemEval-S requires the system to precisely locate specific answers across various sub-categories (e.g., temporal events, user preferences) within an exceptionally long interaction history. This massive search space significantly escalates the difficulty of retrieval and localization, serving as a rigorous stress test for the system’s precision. We utilized an LLM-as-a-judge protocol (using gpt-4.1-mini ) to score the correctness of generated answers against ground-truth references, categorizing responses as either Correct or Wrong based on semantic and temporal alignment. The full evaluation prompt is provided in Appendix  A.4 . B.2 Hyperparameter Configuration Table  7 summarizes the hyperparameters used to obtain the results reported in Section  3 . These values were selected to balance memory compactness and retrieval recall, with particular attention to the thresholds governing semantic structured compression and recursive consolidation. B.3 Hyperparameter Sensitivity Analysis To assess the effectiveness of semantic structured compression and to motivate the design of adaptive retrieval, we analyze system sensitivity to the number of retrieved memory entries ( k k ). We vary k k from 1 to 20 and report the average F1 score on the LoCoMo benchmark using the GPT-4.1-mini backend. Table 6 : Performance sensitivity to retrieval count ( k k ). SimpleMem demonstrates "Rapid Saturation," reaching near-optimal performance at k = 3 k=3 (42.85) compared to its peak at k = 10 k=10 (43.45). This validates the high information density of Atomic Entries, proving that huge context windows are often unnecessary for accuracy. Method Top- k k Retrieved Entries k k =1 k k =3 k k =5 k k =10 k k =20 ReadAgent 6.12 8.45 9.18 8.92 8.50 MemGPT 18.40 22.15 25.59 24.80 23.10 SimpleMem 35.20 42.85 43.24 43.45 43.40 Table  6 provides two key observations. First, rapid performance saturation is observed at low retrieval depth. SimpleMem achieves strong performance with a single retrieved entry (35.20 F1) and reaches approximately 99% of its peak performance at k = 3 k=3 . This behavior indicates that semantic structured compression produces memory units with high information content, often sufficient to answer a query without aggregating many fragments. Second, robustness to increased retrieval depth distinguishes SimpleMem from baseline methods. While approaches such as MemGPT experience performance degradation at larger k k , SimpleMem maintains stable accuracy even when retrieving up to 20 entries. This robustness enables adaptive retrieval to safely expand context for complex reasoning tasks without introducing excessive irrelevant information. Table 7 : Detailed hyperparameter configuration for SimpleMem. The system employs adaptive thresholds to balance memory compactness and retrieval effectiveness. Module Parameter Value / Description Stage 1: Semantic Structured Compression Window Size ( W W ) 20 turns Sliding Stride 5 turns (25% overlap) Model Backend gpt-4.1-mini (temperature = 0.0) Output Constraint Strict JSON schema enforced Stage 2: Online Semantic Synthesis Embedding Model Qwen3-embedding-0.6b (1024 dimensions) Vector Database LanceDB (v0.4.5) with IVF-PQ indexing Stored Metadata timestamp , entities , topic , salience Stage 3: Intent-Aware Retrieval Planning Query Complexity Estimator gpt-4.1-mini Retrieval Range [3, 20] Minimum Depth 1 Maximum Depth 20 Re-ranking Disabled (multi-view score fusion applied directly) Generated on Thu Jan 29 15:46:20 2026 by L a T e XML