LLM Agent Memory Systems: A Unified Framework Comparing 10 Architectures

Introduction: The Evolution and Significance of Memory Systems

As large language models (LLMs) continue to advance, the capability boundaries of intelligent agents are constantly expanding. From simple Q&A systems to complex multi-turn dialogues, from single-task execution to long-term goal tracking, agents are gradually evolving into intelligent entities capable of continual learning and experience accumulation. The core infrastructure supporting this evolution is the memory system.

Memory is to an agent what RAM is to a computer. Without memory, an agent is merely a one-shot calculator; with memory, it can evolve into a genuine working partner. However, LLMs are constrained by fixed context windows and cannot directly process dialogue histories spanning hundreds of turns. This fundamental constraint has spawned dedicated research on agent memory systems: how to efficiently store, manage, and retrieve knowledge across extensive interaction histories within limited context windows.

The development trajectory shows a clear evolutionary path. Early RAG (Retrieval-Augmented Generation) systems injected external knowledge into context through vector retrieval, solving the knowledge extension problem but lacking deep understanding of dialogue history. Subsequently, MemGPT introduced the hierarchical memory management concept from operating systems into the LLM domain, pioneering virtual context management. MemoryBank drew on the Ebbinghaus forgetting curve from cognitive science, endowing AI with "human-like" memory update mechanisms. In recent years, systems such as A-MEM, Mem0, and Zep have further explored dynamic knowledge networks, graph-structured memories, and other innovative directions, pushing memory systems toward greater intelligence and adaptability.

In April 2026, a survey paper titled "Memory in the LLM Era: Modular Architectures and Strategies in a Unified Framework" (arXiv:2604.01707) emerged, conducting the first systematic comparative analysis of existing agent memory methods. The paper not only proposes a unified analytical framework but also comprehensively evaluates ten representative memory methods through the LOCOMO and LONGMEMEVAL benchmarks. Based on this survey and the original literature, this article provides an in-depth comparative analysis of the ten memory solutions.

---

Part 1: Unified Analytical Framework

To systematically compare different memory solutions, a unified analytical framework is needed. The framework abstracts the memory system into four core components: Information Extraction, Memory Management, Memory Storage, and Information Retrieval. These four components collaborate to form a complete memory processing pipeline.

1.1 Information Extraction: From Raw Data to Structured Memory

Information extraction is the entry point of the memory system, responsible for transforming raw dialogue content or observational data into memory representations suitable for storage and retrieval. According to extraction strategies, existing methods can be divided into three categories:

Direct Archival: Stores dialogue content in raw or near-raw form. Representative systems include MemoryBank and MemGPT, which preserve complete dialogue context without complex semantic extraction.

Summarization-based Extraction: Uses LLMs to summarize dialogue content, extracting key information in structured form. A-MEM generates comprehensive notes containing contextual descriptions, keywords, and tags; Mem0 extracts key facts represented as semantic vectors.

Graph-based Extraction: Extracts entities and relationships from dialogues to construct knowledge graphs. Mem0's graph variant (Mem0g) and Zep adopt Subject-Predicate-Object (SPO) triples for extracting structured knowledge, supporting complex relational reasoning.

1.2 Memory Management: Maintenance and Evolution

Memory management is the "brain" of the memory system, responsible for determining which memories are worth retaining, how to organize memories, and when to update them. This component encompasses five core operations:

• Associating related experiences: Identifying and establishing semantic or temporal connections between memories. A-MEM creates interconnected knowledge networks through dynamic indexing and linking; MemoryOS clusters related memories through semantic association.
• Integrating fragmented memories: Aggregating dispersed, fine-grained memories into more macroscopic units. MemoryBank integrates through summarization; MemoChat uses structured memos.
• Cross-memory hierarchy transitions: Information flow between memory hierarchies. MemoryOS designs short/medium/long-term three-tier storage with FIFO + heat-score mechanisms for dynamic migration.
• Updating existing memories: Updating existing memory content based on new information. Update mechanisms can be rule-driven (e.g., time decay), LLM-driven (e.g., semantic merging), or agent-driven (e.g., A-MEM's dynamic link updates).
• Filtering invalid information: Identifying and removing outdated or low-value memories. Common strategies include access frequency + time decay (MemoryBank's forgetting curve), semantic deduplication, etc.

1.3 Memory Storage: Physical Organization

Memory storage concerns the physical organization of memories, including storage structure and storage representation dimensions.

Organization methods:

• Flat: All memories at the same level, e.g., MemoryBank uses FIFO queues or JSON
• Hierarchical: Memories layered by importance or timeliness, e.g., MemoryOS's three-tier architecture
• Tree-based: Memories organized hierarchically, e.g., MemTree's dynamic tree representation

Representation methods:

• Vector storage: Semantic vectors for memory content, supporting similarity retrieval via FAISS or Qdrant
• Graph storage: Nodes and edges for entities and relationships, supporting graph traversal reasoning. MemTree uses tree structure; Zep uses temporal knowledge graphs
• Hybrid storage: Combining multiple representations, e.g., Mem0 supports both vector retrieval and graph traversal

1.4 Information Retrieval: Fast Memory Localization

Information retrieval is the exit of the memory system, responsible for quickly locating relevant memories based on current queries. Retrieval strategies fall into four main categories:

• Lexical retrieval: Based on keyword matching, such as BM25, Jaccard similarity
• Vector retrieval: Based on semantic similarity, using cosine similarity with ANN (Approximate Nearest Neighbor) algorithms
• Structural retrieval: Leveraging structured features of memories, such as graph traversal and multi-hop reasoning. Mem0g and Zep utilize graph structures for complex relational queries
• LLM-assisted retrieval: Using LLMs to reformulate or expand queries to improve retrieval. MemoChat adopts an iterative "memorize-retrieve-respond" loop

---

Part 2: Detailed Analysis of Ten Memory Solutions

2.1 A-MEM: Dynamic Knowledge Network Builder

Core Idea: A-MEM (Agentic Memory) draws on German sociologist Niklas Luhmann's Zettelkasten methodology, treating memory as a dynamically growing knowledge network. Its core innovation is endowing the memory system with "agency"—memories are no longer passively stored data but knowledge entities capable of autonomously establishing connections and continuously evolving.

Architectural Features:

• Comprehensive note generation: When new memories enter the system, A-MEM generates structured notes with multi-dimensional attributes
• Dynamic linking mechanism: The system automatically analyzes historical memories, identifies semantic similarities, and establishes meaningful links
• Memory evolution capability: New memories can trigger updates to historical memory contexts

Innovation: A-MEM breaks through the static storage paradigm of traditional memory systems, achieving organic connections between memories. This design is particularly suitable for scenarios requiring deep knowledge associations.

Paper and Resources: arXiv:2502.12110 | https://github.com/WujiangXu/AgenticMemory

2.2 MemoryBank: Human-like Memory that Forgets

Core Idea: MemoryBank's design is inspired by the Ebbinghaus forgetting curve theory from cognitive psychology. It addresses a fundamental question: if humans forget, why must AI remember everything? By introducing "selective forgetting" mechanisms, MemoryBank achieves memory behavior patterns closer to humans.

Architectural Features:

• Forgetting curve inspiration: Memory retention strength naturally decays over time, with important memories decaying slower
• Emotional companionship orientation: Designed for long-term AI companion scenarios, supporting personalized memory and user personality understanding
• Two-layer memory structure: Contains short-term working memory and long-term storage memory, supporting dynamic updates

Innovation: MemoryBank is the first to systematically introduce cognitive science theory into LLM memory design, pioneering the "human-like memory" research branch. Its SiliconFriend chatbot demonstrates application potential in long-term companionship scenarios.

Paper and Resources: arXiv:2305.10250 | https://github.com/zhongwanjun/MemoryBank-SiliconFriend

2.3 MemGPT: Memory Management from an OS Perspective

Core Idea: MemGPT is inspired by traditional operating system virtual memory management mechanisms. Just as operating systems provide the illusion of "infinite memory" by moving data between RAM and disk, MemGPT achieves virtual super-large context through intelligent data exchange between the LLM's limited context window and external storage.

Architectural Features:

• Hierarchical storage system: Simulates OS memory hierarchy, including fast-access context and slow persistent external storage
• Interrupt mechanism: Introduces OS-interrupt-like control flow management
• Paging management: Splits long documents into pages, loading on demand into context

Innovation: MemGPT is the first work to systematically apply OS design concepts to LLM memory management. This project later evolved into the Letta framework.

Paper and Resources: arXiv:2310.08560 | https://github.com/letta-ai/letta

2.4 Mem0 / Mem0g: Scalable Memory Infrastructure

Core Idea: Mem0 aims to provide a scalable, high-performance long-term memory layer for production-grade AI agents. Its core design principle is practicality—significantly reducing latency and cost while ensuring accuracy.

Architectural Features:

• Multi-level memory: Seamlessly manages user-level, session-level, and agent-level state
• Dynamic information integration: Automatically extracts, integrates, and retrieves key information from dialogues
• Graph-enhanced variant (Mem0g): Introduces graph storage using SPO triples to capture complex relationships

Innovation: Mem0 achieves a 26% accuracy improvement over OpenAI's built-in memory on the LOCOMO benchmark, while reducing p95 latency by 91% and token consumption by 90%. This performance-efficiency balance makes it ideal for enterprise applications.

Paper and Resources: arXiv:2504.19413 | https://github.com/mem0ai/mem0

2.5 MemoChat: Structured Memo Loop

Core Idea: MemoChat proposes an iterative "memorize-retrieve-respond" loop mechanism, maintaining dialogue consistency through explicit memo structures. Its core insight is that effective long-term dialogue requires systematic memory management rather than simple history recording.

Architectural Features:

• Three-stage loop: Memorization → Retrieval → Response
• Structured memos: Uses predefined templates to organize memory content
• Instruction tuning: Designs specialized training instructions for each stage

Innovation: MemoChat demonstrates that through carefully designed training processes and structured memory representations, even open-source models can match commercial models in long-range dialogue.

Paper and Resources: arXiv:2308.08239 | https://github.com/LuJunru/MemoChat

2.6 Zep (Graphiti): Temporal-aware Knowledge Graph

Core Idea: Zep's core component Graphiti is a temporal-aware knowledge graph engine capable of dynamically integrating unstructured dialogue data and structured business data while maintaining historical relationship timelines. Its goal is to address dynamic knowledge integration challenges in enterprise applications.

Architectural Features:

• Temporal knowledge graph: Stores entity relationships and records relationship time dimensions
• Multi-source data fusion: Simultaneously processes dialogue data (unstructured) and business data (structured)
• Deep memory retrieval: Achieves 94.8% accuracy on DMR benchmark, surpassing MemGPT's 93.4%

Innovation: Zep's temporal-aware design is particularly suitable for scenarios requiring tracking of information evolution, such as customer relationship management and medical record tracking. On LongMemEval, Zep achieves up to 18.5% accuracy improvement and 90% latency reduction.

Paper and Resources: arXiv:2501.13956 | https://github.com/getzep/graphiti

2.7 MemTree: Dynamic Tree Memory Representation

Core Idea: MemTree formalizes hierarchical memory structures from human cognition into algorithmic implementation. Its core concept is that information should be organized by abstraction levels, with high-level nodes summarizing multiple low-level details, enabling efficient memory compression and retrieval.

Architectural Features:

• Dynamic tree structure: Memories organized in tree hierarchies, each node containing aggregated text content and semantic vectors
• Multi-level abstraction: Tree depth corresponds to different abstraction levels, with top-level being summary and bottom-level being details
• Semantic adaptation: Dynamically adjusts tree structure by computing and comparing semantic embeddings

Innovation: MemTree's tree structure is naturally suited for representing hierarchical knowledge.

Paper and Resources: arXiv:2410.14052

2.8 MemoryOS: Hierarchical Storage Operating System

Core Idea: MemoryOS fully introduces OS memory management principles into the AI agent domain, designing short/medium/long-term three-tier storage architecture for comprehensive memory lifecycle management.

Architectural Features:

• Three-tier storage architecture: Short-term memory (immediate dialogue), medium-term memory (session-level), long-term personal memory (persistent profile)
• Dynamic migration mechanism: Short→Medium based on dialogue chain FIFO principles; Medium→Long using segmented page organization strategies
• Four core modules: Storage, Update, Retrieval, Generation

Innovation: MemoryOS achieves an average F1 score improvement of 49.11% and BLEU-1 improvement of 46.18% over baseline on the LOCOMO benchmark.

Paper and Resources: arXiv:2506.06326 | https://github.com/BAI-LAB/MemoryOS

2.9 MemOS: Memory as System Resource

Core Idea: MemOS proposes a grander vision—treating memory as manageable system resources and establishing a unified memory-centric system framework. Its design goal is to support continual learning and personalized modeling, laying the foundation for AGI infrastructure.

Architectural Features:

• MemCube basic unit: Encapsulates memory content and metadata (source, version, etc.), supporting composition, migration, and fusion
• Multi-level memory unification: Unifies pure text memory, activation value memory, and parameter-level memory
• Controllability and plasticity: Supports flexible conversion of memory types, bridging retrieval-enhanced learning and parameter learning

Innovation: MemOS has the highest abstraction level, attempting to establish a complete memory ecosystem. Its MemCube design concept is similar to the "component" concept in software engineering, with strong extensibility.

Paper and Resources: arXiv:2507.03724 | https://github.com/MemTensor/MemOS

---

Part 3: Systematic Comparative Analysis

3.1 Information Extraction Strategy Comparison

| System | Extraction Strategy | Features | Advantage Scenarios | |--------|--------------------|----|----| | MemoryBank | Direct Archival | Preserves raw dialogue | Scenarios requiring complete context | | MemGPT | Direct Archival | Paginated raw content | Ultra-long document analysis | | A-MEM | Summarization | Comprehensive notes + multi-dimensional attributes | Knowledge management, research assistants | | Mem0 | Summarization | Key facts + semantic vectors | General dialogue, personal assistants | | Mem0g | Graph-based | SPO triples | Relationship-intensive queries | | Zep | Graph-based | Temporal knowledge graph | Time-sensitive applications |

Analysis: Direct archival strategies are simple and lossless but costly; summarization-based extraction significantly compresses information but may lose details; graph-based extraction is best for relational reasoning but depends on extraction quality.

3.2 Memory Management Strategy Comparison

| System | Association Mechanism | Integration Strategy | Update Mechanism | Filtering Strategy | |--------|----|----|----|----| | A-MEM | Dynamic linking | Knowledge network evolution | LLM-driven | Semantic deduplication | | MemoryBank | Temporal association | Summary aggregation | Forgetting curve-driven | Time decay | | MemoryOS | Semantic/temporal association | Hierarchical aggregation | Heat score | FIFO + scoring | | MemoChat | Structured association | Memo integration | Rule-driven | Explicit override |

Analysis: Memory management is the most differentiated component. A-MEM's dynamic linking is most innovative but computationally expensive; MemoryBank's forgetting curve is intuitive but parameter tuning is complex.

3.3 Storage Structure Comparison

| System | Organization | Representation | Scalability | |--------|----|----|----| | MemoryBank | Flat (FIFO/JSON) | Vector | Medium | | Mem0 | Flat + Graph | Vector + Graph | High | | MemTree | Tree | Vector + Hierarchy | Depth-limited | | MemoryOS | Hierarchical (3 tiers) | Hybrid | High | | Zep | Temporal Graph | Graph + Vector | High |

Analysis: Tree/hierarchical structures generally perform better in experiments, but scalability requires attention. MemTree's depth increase leads to nonlinear retrieval cost rise.

3.4 Retrieval Mechanism Comparison

| System | Main Retrieval | Special Mechanism | Multi-hop Support | |--------|----|----|----| | MemoryBank | Vector retrieval | Time weighting | Limited | | MemGPT | Page loading | On-demand retrieval | None | | A-MEM | Vector + link traversal | Knowledge network navigation | Strong | | Mem0g | Vector + graph traversal | Relational reasoning | Strong | | Zep | Graph traversal | Temporal filtering | Strong | | MemoChat | LLM-assisted | Query reformulation | Medium |

Analysis: Multi-hop reasoning capability is the key competitive edge. Graph-based systems (A-MEM, Mem0g, Zep) naturally support multi-hop reasoning.

---

Part 4: Evaluation Benchmarks and Experimental Results

4.1 LOCOMO Benchmark

Dataset Overview:

• 10 long-range dialogues, averaging 27.2 sessions and 588.2 dialogue turns
• Average ~9,000 tokens per dialogue, max ~16,000 tokens
• 1,986 questions total, divided into five categories

Question Type Definitions:

• Single-hop: Answers obtainable from a single session
• Multi-hop: Requires synthesizing information from multiple sessions
• Temporal: Requires understanding event time order or relative time relations
• Open-domain: Requires combining dialogue content with external common knowledge
• Adversarial: Questions without corresponding answers in dialogue (testing refusal ability)

4.2 LONGMEMEVAL Benchmark

Dataset Overview:

• 500 carefully curated questions
• Average 50.2 sessions, ~115,000 tokens
• Based on user-AI interaction scenarios

Evaluation Dimensions:

• Information Extraction (IE): Extracting specific information from single sessions
• Multi-session Reasoning (MR): Synthesizing information from multiple sessions
• Knowledge Updates (KU): Handling dynamically changing information (e.g., address changes)
• Temporal Reasoning (TR): Understanding relative time
• Abstention (ABS): Identifying unanswerable questions

4.3 Key Experimental Findings

Finding 1: Tree/Hierarchical Storage Structures Prevail

Experiments consistently show that systems using tree or hierarchical structures (MemTree, MemoryOS, MemOS) outperform flat-structure systems. This confirms a fundamental cognitive science viewpoint: human memory is also hierarchically organized.

Finding 2: Information Completeness is Critical

Comparison experiments show that memory systems preserving complete raw messages (such as MemoryOS) perform better than graph systems extracting only triples (such as basic Zep). This indicates that over-simplification may cause information loss.

Finding 3: Memory Linking Capability is Core to Multi-hop Reasoning

Multi-hop reasoning accuracy is highly correlated with memory system linking capability. A-MEM's dynamic linking, Mem0g's graph traversal, and Zep's temporal graph queries excel at multi-hop tasks.

Finding 4: Temporal Reasoning Heavily Depends on LLM Capability

Controlled experiments show that temporal reasoning accuracy is approximately 35% with 7B parameter models and approximately 70% with 72B models. This indicates temporal reasoning is an "emergent ability" sensitive to base model scale.

Finding 5: Token Consumption Correlates Positively with Performance, but Coarse Granularity Doesn't Necessarily Degrade Performance

Experimental data shows that investing more tokens usually yields better performance. However, overly fine-grained memory storage is not always optimal—appropriately aggregated memory units sometimes perform better than raw fragments.

Finding 6: Indexing Mechanisms Need Attention to Scalability

MemTree's experiments show that retrieval cost rises nonlinearly when tree depth increases.

4.4 Performance Data Overview

| System | LOCOMO (F1) | LONGMEMEVAL (Acc) | Latency Optimization | Token Savings | |--------|-------------|-------------------|----------------------|---------------| | Mem0 | High | High | -91% | -90% | | Zep | Medium | High (+18.5%) | -90% | - | | MemoryOS | High (+49%) | - | - | - | | A-MEM | High | - | - | - |

*Note: Table data comes from respective paper reports. Due to evaluation protocol differences, cross-paper comparisons are for reference only*

---

Part 5: Key Insights and Design Trade-offs

5.1 Extraction vs. Retention: What Should Be Remembered?

Trade-off Analysis:

• Complete retention: No information loss, supports arbitrary granularity recall; but high storage cost, retrieval noise
• Structured extraction: Efficient storage, precise retrieval; but risk of information loss, depends on extraction quality

Design Recommendations:

• For fact-intensive applications (medical records, legal documents), prioritize retaining raw content
• For casual dialogue, structured extraction suffices
• Hybrid strategies may be best practice: simultaneously store raw content and extracted summaries/facts

5.2 Flat vs. Hierarchical: How to Organize Memory?

Trade-off Analysis:

• Flat storage: Simple implementation, direct retrieval logic; but difficult to handle large-scale memory, lacks abstraction
• Hierarchical storage: Supports progressive summarization, suitable for large-scale memory; but increases system complexity

Design Recommendations:

• Short-term memory (<100 turns) can adopt flat structure
• Long-term memory should adopt hierarchical structure, usually 2-3 tiers are sufficient
• Tree structure suits knowledge-intensive scenarios but depth should be controlled (recommended ≤5 levels)

5.3 Vector vs. Graph: How to Choose Representation?

Trade-off Analysis:

• Vector storage: Strong semantic retrieval, mature implementation; but lacks explicit relational representation
• Graph storage: Strong relational reasoning, good interpretability; but high construction cost, complex queries
• Hybrid storage: Combines both advantages; but high system complexity, difficult consistency maintenance

Design Recommendations:

• If queries are mainly "content about X", vector storage suffices
• If queries involve "relationship between X and Y", graph structure needed
• In practice, vector + lightweight graph may be the best compromise

5.4 Automation vs. Manual: Degree of Memory Management Automation

Trade-off Analysis:

• Fully automatic: Smooth user experience, suitable for consumer applications; but error accumulation risk
• Manual confirmation: High accuracy, suitable for professional scenarios; but interrupts user experience
• Hybrid mode: Key memories manually confirmed, routine memories automatically processed

Design Recommendations:

• Personal assistant scenarios can adopt fully automatic mode
• Enterprise applications should provide manual review mechanisms
• Supporting user-initiated memory editing is a differentiating feature

5.5 Forgetting: A Neglected Design Dimension

Core Insight: Most systems focus on "how to remember" while ignoring "how to forget".

MemoryBank's forgetting curve is an important directional exploration. A key characteristic of human memory is selective forgetting—retaining important information while discarding trivial content. Current most systems lack this capability, leading to unbounded memory growth and declining retrieval efficiency.

Future Directions:

• Introduce importance evaluation mechanisms to automatically identify low-value memories
• Design memory compression algorithms to merge related memories into summaries
• Research joint modeling of time decay and access frequency

Part 6: Future Directions and Development Trends

6.1 Short-term Trends (1-2 years)

Memory System Standardization: As memory systems move from research to production, standardized APIs and protocols will emerge. Open protocols like MCP (Model Context Protocol) may promote memory system interoperability.

Deep Integration with RAG: The boundary between memory systems and RAG will gradually blur, forming a unified "context enhancement" layer. Memory provides personalized history, RAG provides external knowledge, working synergistically.

Multimodal Memory: Current mainstream systems mainly handle text memory; future expansion will support images, audio, video, and other multimodal memories.

6.2 Mid-term Trends (3-5 years)

Personalized Memory Models: Rather than "one memory system serving all users", lightweight personalized memory models will be trained for each user, achieving deeper personalization.

Memory as a Service (MaaS): Memory systems may become independent cloud service layers, similar to today's vector databases. Mem0's cloud-hosted service may be a harbinger of this trend.

Federated Memory: Under privacy protection needs, federated learning technology will be introduced into memory systems, achieving "data stationary, model mobile" distributed memory management.

6.3 Long-term Vision (5+ years)

Unification of Memory and Reasoning: Currently, memory and reasoning are two relatively independent modules. Future deeper integration may emerge—memory itself becomes reasoning infrastructure, and retrieval processes are themselves reasoning processes.

Lifelong Learning Architectures: Agents will possess true lifelong learning capabilities. Memory is not only information storage but also skill accumulation. MemOS's vision may be early exploration in this direction.

Human-Machine Memory Symbiosis: Human and AI memory systems will achieve some form of connection. AI can read human digital memory (with authorization), and humans can query AI memory repositories, forming memory communities.

6.4 Core Challenges to Resolve

Challenge 1: Memory Reliability

Current memory systems cannot guarantee 100% accuracy, with hallucination, forgetting, and confusion issues. For high-stakes applications (medical, legal), this is a fundamental obstacle.

Challenge 2: Privacy and Security

Memory systems store large amounts of sensitive information. Protecting user privacy, preventing data leaks, and supporting secure memory deletion are pressing issues.

Challenge 3: Cross-System Migration

Users' memories are currently locked in specific systems. Standardized memory exchange formats are needed to support users carrying memories across different AI services.

Challenge 4: Ethical Boundaries of Memory

What should AI remember? What should it forget? Who has the right to decide? These questions will become increasingly urgent as memory systems proliferate.

---

Conclusion

Agent memory systems are at a critical stage of rapid development. From MemGPT's virtual context management, to A-MEM's dynamic knowledge network, to MemoryOS's hierarchical storage architecture, researchers are exploring the mysteries of memory from multiple dimensions.

This comparative analysis reveals the core design space of current memory systems: granularity of information extraction, organization of storage structures, choice of retrieval mechanisms, and formulation of update strategies. There is no universally optimal solution, only appropriate choices matching scenario requirements.

Notably, the survey paper "Memory in the LLM Era" discovered several counter-intuitive conclusions through systematic experimental comparison: tree structures outperform flat structures; information completeness beats over-extraction; token consumption positively correlates with performance but coarse granularity doesn't necessarily harm performance. These findings provide valuable empirical guidance for future system design.

Looking ahead, memory systems will no longer be AI "attachments" but part of its core infrastructure. Just as humans cannot do without memory, truly intelligent agents cannot do without efficient, reliable, scalable memory systems. Every advancement in this field lays the foundation for more intelligent, more personalized AI experiences.

Memory is the cornerstone of intelligence. In the LLM era, we are rediscovering the digital expression of this ancient truth.

---

References

1. Wu, Y., et al. (2026). Memory in the LLM Era: Modular Architectures and Strategies in a Unified Framework. arXiv:2604.01707. 2. Xu, W., et al. (2025). A-Mem: Agentic Memory for LLM Agents. arXiv:2502.12110. 3. Zhong, W., et al. (2023). MemoryBank: Enhancing Large Language Models with Long-Term Memory. arXiv:2305.10250. 4. Packer, C., et al. (2023). MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560. 5. Chhikara, P., et al. (2025). Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv:2504.19413. 6. Lu, J., et al. (2023). MemoChat: Tuning LLMs to Use Memos for Consistent Long-Range Open-Domain Conversation. arXiv:2308.08239. 7. Rasmussen, P., et al. (2025). Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv:2501.13956. 8. Rezazadeh, A. (2024). MemTree: A Dynamic Tree-Structured Memory Representation for LLM Agents. arXiv:2410.14052. 9. Kang, J., et al. (2025). MemoryOS: A Hierarchical Memory Operating System for AI Agents. arXiv:2506.06326. 10. Li, Z., et al. (2025). MemOS: A Memory Operating System for Large Language Models. arXiv:2507.03724. 11. Maharana, A., et al. (2024). LoCoMo: Evaluating Very Long-Term Conversational Memory of LLM Agents. arXiv:2402.17753. 12. Wu, D., et al. (2024). LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory. arXiv:2410.10813.

---

*This article is organized and analyzed based on public academic papers and technical documentation, for academic research reference only.*