@seclink: Awesome list on large model memory.
Summary
A curated list dedicated to the long-term memory of large language models, covering the latest papers, methods, and evaluation benchmarks.
View Cached Full Text
Cached at: 09/20/26, 05:07 AM
Here is the translated markdown content:
Sharing an awesome list on LLM memory.
https://t.co/VRxMOviLa0
XiaomingX/awesome-ai-memory
Source: https://github.com/XiaomingX/awesome-ai-memory
Awesome AI Memory - Curated List of Long-Term Memory Projects for Large Language Models
A curated list focused on long-term memory (LTM) implementations for Large Language Models (LLMs), covering the complete ecosystem from underlying retrieval/storage paradigms, memory layer systems, and agent memory tools, to multimodal consistency, training, and alignment.
Core Updates (2026 Q2–Q3)
- RL-ified Memory Management: Projects like AgeMem transform the CRUD (Create, Read, Update, Delete) operations of long-term/short-term memory into trainable tool actions for agents, using three-stage RL (step-wise GRPO) for end-to-end optimization, replacing heuristic controllers.
- From “Atomic Facts” to Multi-Granularity: TriMem simultaneously maintains three granularities: raw dialogue segments, extracted facts, and synthesized portraits. It uses TextGrad to iteratively optimize prompts, enabling parameter-free lifelong evolution.
- Conflict-Aware and Fact Revision: MOSAIC, Infini Memory address the “facts change over time” problem by designing maintainable memory (topic documents / conflict detection), directly tackling the quality control challenge in the write path.
- Evaluation Shifts from “Recall” to “Action”: Benchmarks like MemoryAgentBench (ICLR’26), MemoryArena / Memoria-Bench / AMA-Bench (ICML’26), HaluMem, and LongMemEval-V2 push evaluation towards operational-level hallucinations, multi-session agentic tasks, and selective forgetting.
- Test-Time Memory Layering: Titans-as-a-Layer packages the neural long-term memory into a plug-and-play adapter (MAL), enabling the injection of long-term memory into multimodal models without altering the backbone.
- Local-First, Cross-Tool MCP Memory: Projects like Memorix, OKF-standard mcp-memory, implemented with SQLite / Knowledge Graph + Markdown, emphasize privatization and cross-host (Claude Code / Cursor / Codex) sharing.
Recent Major Advances (June–September 2026)
New Papers and Methods
| Name | Source | Core Contribution |
|---|---|---|
| AgeMem (Agentic Memory) | arXiv 2601.01885 (https://arxiv.org/abs/2601.01885) · ACL 2026 SAC Highlight | Unifies LTM/STM storage, retrieval, update, summarization, and discard into agent tool actions, using three-stage progressive RL + step-wise GRPO training to eliminate heuristic controllers. |
| TriMem | arXiv 2605.19952 (https://arxiv.org/abs/2605.19952) | Breaks the “extract atomic facts” paradigm by simultaneously maintaining raw dialogues, atomic facts, and synthesized portraits; uses TextGrad for iterative prompt optimization, achieving parameter-free lifelong evolution. |
| Infini Memory | arXiv 2606.10677 (https://arxiv.org/abs/2606.10677) | Organizes memory into maintainable “topic documents”; new observations first enter a buffer then periodically merge. Uses iterative tool calls during inference to read memory, achieving 64.7% on MemoryAgentBench. |
| MOSAIC | arXiv 2607.16211 (https://arxiv.org/abs/2607.16211) | Conflict-aware structured long-term memory, explicitly detects factual conflicts (66% hit rate vs. baseline 14%), achieves 89.35% accuracy on LoCoMo. |
| H-MEM | EACL 2026 (https://aclanthology.org/2026.eacl-long.15.pdf) | Four-level hierarchical memory (domain → sub-domain → keywords → events/portraits), where the first three levels serve as interpretable indexes to improve long-range reasoning efficiency. |
| Titans-as-a-Layer (MAL) | arXiv 2606.08573 (https://arxiv.org/abs/2606.08573) | Packages Titans-style test-time neural memory into a plug-and-play Memory-as-a-Layer adapter, injecting dialogue history into audio large models without modifying the backbone. |
| MemDelta | arXiv 2606.29914 (https://arxiv.org/abs/2606.29914) | Identifies hidden confounding variables in agent memory evaluation and provides controlled baselines, questioning the comparability of previous evaluation conclusions. |
| Diagnosing Retrieval vs. Utilization | arXiv 2603.02473 (https://arxiv.org/abs/2603.02473) | Empirically finds that retrieval quality impacts final performance far more than write/compression strategies; raw chunking can match complex fact extraction. |
| How Memory Management Impacts LLM Agents | ACL 2026 (https://aclanthology.org/2026.acl-long.27.pdf) | Systematically studies “experience following” behavior, reveals error propagation and misaligned experience replay, and proposes history-based memory deletion strategies. |
New Datasets and Benchmarks
Complete list see docs/memory-evaluation-benchmarks.md.
| Benchmark | Source | Evaluation Focus |
|---|---|---|
| MemoryAgentBench | ICLR 2026 · GitHub (https://github.com/HUST-AI-HYZ/MemoryAgentBench) | Four-dimensional capabilities: precise retrieval, test-time learning, long-range understanding, selective forgetting; adds EventQA and FactConsolidation. |
| MemoryArena | ICML 2026 · GitHub (https://github.com/ZexueHe/MemoryArena) | Multi-session Memory-Agent-Environment closed loop, interdependent subtasks (web navigation / preference planning / progressive search / formal reasoning). |
| Memoria-Bench | ICML 2026 · Paper (https://palm.seu.edu.cn/zhangml/files/ICML%2726a.pdf) | Episodic/semantic/procedural memory for long-range autonomous agents, covering deep research, code, tabular tasks; reveals memory bottlenecks even in million-token contexts. |
| AMA-Bench | ICML 2026 · GitHub (https://github.com/AMA-Bench/AMA-Bench) | Long-range context retention and long-horizon memory performance on agent trajectories (state/action/observation/tool output). |
| HaluMem | arXiv 2511.03506 (https://arxiv.org/abs/2511.03506) | The first operational-level memory hallucination benchmark, decomposing extraction / update / Q&A stages. |
| LongMemEval-V2 | arXiv 2605.12493 (https://arxiv.org/abs/2605.12493) | For web agent environmental experience (static/dynamic states, workflows, pitfalls, precondition awareness), with historical trajectories up to 115M tokens. |
| Mem-Gallery | ACL 2026 (https://aclanthology.org/2026.acl-long.1892/) | Multimodal long-range dialogue memory, evaluating MLLM agent extraction/test-time adaptation, reasoning, and knowledge management. |
| Mem2ActBench | ACL 2026 (https://aclanthology.org/2026.acl-long.370/) | Evaluates whether agents can proactively use long-term memory to drive tool selection and parameter grounding (not passive Q&A). |
| EverMemBench | arXiv 2602.01313 (https://arxiv.org/abs/2602.01313) | Multi-party workplace dialogue, fine-grained recall / memory awareness / user profile understanding. |
| Memora | ACL 2026 (https://github.com/geniesinc/Memora) · arXiv 2604.20006 (https://arxiv.org/abs/2604.20006) | For personalized agents, scores both “what to remember” and “what to forget (deleted/updated)”, proposing the FAMA metric. |
| MemoryBench | arXiv 2510.17281 (https://arxiv.org/abs/2510.17281) | Memory + continual learning, on-policy / off-policy interaction simulation. |
| BEAM | ICLR 2026 | Recall and augmentation for million-token-scale long-term memory. |
New Trends
- RL-ified Memory Management: Memory operations are no longer fixed pipelines but part of the policy, driven by reward signals to decide “what to remember and when to forget.”
- Multi-granularity + Conflict-Aware Write Path: Shifting from “extracting atomic facts” to simultaneously preserving original text, facts, and portraits, while explicitly handling factual conflicts and revisions.
- Operational-level / Agentic Evaluation: Evaluation moves from end-to-end QA scores to detailed stages like extraction, update, and forgetting, and shifts towards multi-session, actionable tasks.
- Test-Time Memory Layering: Neural long-term memory evolves from “modifying architecture” to “pluggable layers,” lowering the barrier for injecting long-term memory into multimodal models.
- Local-First and Standardization: MCP memory services emphasize local running and cross-host sharing, with emerging memory file format standards like OKF.
- From “Remembering” to “Acting”: Benchmarks like Mem2ActBench and MemoryArena directly test the benefit of memory for tool calls and decision-making.
Technical Evolution of LLM Memory
To understand the positioning of the projects below, first clarify the development trajectory of memory technologies. Key verified milestones are listed chronologically (years/institutions per original papers).
Paradigm Foundations
- RAG (Retrieval-Augmented Generation, Meta/FAIR, 2020, arXiv 2005.11401): The retrieval + generation paradigm, considered foundational for LLM memory beyond parameters. Placing “knowledge” in external corpora and retrieving it as needed for injection into context.
- Generative Agents (Stanford, Park et al., 2023, arXiv 2304.03442): A town of 25 AI agents, proposing the “memory stream + retrieval + reflection” trifecta, a classic prototype for agent memory design.
Memory Mechanism Exploration (2023)
- MemoryBank (Zhong et al., 2023, arXiv 2305.10250, AAAI 2024): Inspired by the Ebbinghaus forgetting curve, applies decay and reinforcement to memory, accompanied by the LoCoMo long-range dialogue memory benchmark.
- LongMem (Wang et al., 2023, arXiv 2306.07174, NeurIPS 2023): Freezes the backbone LLM as a memory encoder, coupled with a Residual SideNet and cache memory bank, enabling long-term memory.
- MemGPT / Letta (UC Berkeley, Packer et al., 2023, arXiv 2310.08560): Applies OS virtual memory concepts to LLMs, stratifying context into primary context/external storage, using tool calls for “virtual context management.” The team later founded Letta to continue the open-source project.
Memory Compression and Episodic Memory (2024)
- ReadAgent (Google DeepMind, 2024): Simulates human reading, paginating long text and using gist memory to compress key points, an episodic memory framework.
- GraphRAG (Microsoft, 2024, arXiv 2404.16130): Extracts entity relationships from unstructured text to build knowledge graphs, with community summarization, enhancing retrieval-augmented generation for complex/global QA.
- HippoRAG (OSU-NLP-Group & Stanford et al., 2024, arXiv 2405.14831, NeurIPS 2024): Inspired by the hippocampal indexing theory, synergizes LLMs, knowledge graphs, and personalized PageRank for multi-hop retrieval akin to long-term memory.
- Memory3 / Explicit Memory (BAAI et al., 2024, arXiv 2407.01178): Externalizes knowledge as a sparse attention KV memory module, paralleling parametric and working memory as the “third type of memory.”
Production-Grade Memory Layers (2025)
- Mem0 (Mem0 Team, 2025, arXiv 2504.19413): A scalable long-term memory layer for production-grade AI agents, including vector Mem0 and graph Mem0g, claiming superior performance over OpenAI’s memory solutions in LLM-as-Judge evaluations while saving tokens.
- A-MEM (Xu et al., 2025, arXiv 2502.12110): Inspired by Luhmann’s Zettelkasten note-card method, uses dynamic indexing/linking for agent self-evolving structured memory, similar to but independent of the Zep/Graphiti path.
Architectural Long-Term Memory (2024-2025)
- Titans (Google, 2024-12, arXiv 2412.01427, NeurIPS 2025): Proposes a “neural long-term memory” module, driven by “surprise,” supporting test-time training/learning, combining RNN-style memory with attention for ultra-long contexts.
Learnable Memory Management and Evaluation Systems (2026)
- AgeMem / Agentic Memory (2026, arXiv 2601.01885, ACL 2026): Treats LTM/STM operations as tool actions for agent autonomous decision-making, trained with progressive RL, marking memory management’s shift from heuristic rules to learnable strategies.
- TriMem (2026, arXiv 2605.19952): Coexists three granularities: “raw dialogue + atomic facts + synthesized portraits” instead of single fact extraction, using TextGrad prompt optimization for parameter-free lifelong evolution.
- Infini Memory (2026, arXiv 2606.10677): Restructures memory into maintainable “topic documents,” coupled with iterative agentic retrieval, emphasizing evidence aggregation and fact revision.
- Titans-as-a-Layer (2026, arXiv 2606.08573): Packages test-time neural memory as a pluggable layer (MAL), shifting from “modifying architecture” to “adding modules,” first systematically extending to audio multimodality.
- Evaluation Systems (2026): MemoryAgentBench (ICLR), MemoryArena / Memoria-Bench / AMA-Bench (ICML), HaluMem, LongMemEval-V2, etc., refine evaluation to operational stages like extraction/update/forgetting and multi-session agentic tasks.
Evolution Main Line: External retrieval (RAG) → Agent memory streams and reflection (Generative Agents / MemGPT) → Memory compression and graphification (ReadAgent / GraphRAG / HippoRAG / Memory3) → Production-grade memory layers (Mem0 / A-MEM / Zep) → Architectural neural long-term memory (Titans) → Learnable memory management + operational evaluation (AgeMem / TriMem / MemoryAgentBench). Memory is evolving from “stuffing materials into prompts” to “the model itself learning to remember and managing what to remember.”
1. Integrated Memory Layers
These projects offer complex logical memory management, supporting multi-user, multi-session, automatic summarization, and knowledge extraction.
| Name | GitHub URL | Type | Storage Type | Features |
|---|---|---|---|---|
| Mem0 | mem0ai/mem0 (https://github.com/mem0ai/mem0) | Hosted/Open Source | Graph + Vector | Intelligent memory layer, includes vector Mem0 and graph Mem0g, supports cross-user/session memory. |
| Memobase | memodb-io/memobase (https://github.com/memodb-io/memobase) | Open Source | Profile-based | Focuses on long-term memory management for event evolution and user portraits. |
| Graphiti | getzep/graphiti (https://github.com/getzep/graphiti) | Open Source | Temporal Knowledge Graph | Open-source version of Zep Core, focusing on dynamically evolving associative knowledge storage over time. |
| LangMem | langchain-ai/langmem (https://github.com/langchain-ai/langmem) | Open Source | Vector + Attributes | Official LangChain long-term memory, automatically extracts, integrates, and updates knowledge. |
| Zep AI | getzep/zep (https://github.com/getzep/zep) | Hosted/Open Source | Graph + Vector | Chat memory platform, providing sentiment analysis and deep summarization features. |
| Letta | letta-ai/letta (https://github.com/letta-ai/letta) | Hosted/Open Source | Hierarchical Storage | Formerly MemGPT, treats memory as an OS’s multi-level cache (RAM/Disk). |
| SimpleMem | aiming-lab/SimpleMem (https://github.com/aiming-lab/SimpleMem) | Open Source | Multimodal | Lifelong memory layer, supports cross-dialogue project history memory, includes multimodal capabilities. |
| MemoryOS | BAI-LAB/MemoryOS (https://github.com/BAI-LAB/MemoryOS) | Open Source | Hierarchical Storage | Hierarchical memory management inspired by OS memory paging (arXiv 2506.06326), often used as a memory evaluation baseline. |
2. Agentic & Local Tools
Suitable for individual developers, single-machine agents, or integration into specific office workflows.
| Name | GitHub URL | Type | Features |
|---|---|---|---|
| NovelGenerator | KazKozDev/NovelGenerator (https://github.com/KazKozDev/NovelGenerator) | Multi-Agent | Tracks character perspectives, plotlines, and emotional arcs, suitable for generating complete novels. |
| AgentCortex | sage-hq/agentcortex-mcp (https://github.com/sage-hq/agentcortex-mcp) | MCP | Native MCP memory system, supports Cursor and Claude Desktop. |
| Basic Memory | basicmachines-co/basic-memory (https://github.com/basicmachines-co/basic-memory) | MCP/SQLite | Based on SQLite and Markdown, extremely privacy-friendly, suitable for local knowledge bases. |
| Nano-GraphRAG | gusye1234/nano-graphrag (https://github.com/gusye1234/nano-graphrag) | Local Optimized | Extremely lightweight GraphRAG implementation, suitable for resource-constrained environments. |
| SimpleMem | aiming-lab/SimpleMem (https://github.com/aiming-lab/SimpleMem) | Open Source | Lifelong memory layer, supports cross-dialogue project history memory. |
| Supermemory | supermemoryai/supermemory (https://github.com/supermemoryai/supermemory) | Cloud-Native | Built on the Cloudflare ecosystem, constructing a distributed personal AI memory brain. |
| Khoj | khoj-ai/khoj (https://github.com/khoj-ai/khoj) | Multi-Platform | Personal AI co-pilot, deeply integrates Markdown documents and notes. |
3. AI Frameworks with Memory Support
General AI development frameworks deeply integrated with long-term memory management capabilities.
| Name | GitHub URL | Core Capabilities |
|---|---|---|
| LlamaIndex | run-llama/llama_index (https://github.com/run-llama/llama_index) | Provides Property Graph Index and various narrative-enhanced indexing patterns. |
| LangChain | langchain-ai/langchain (https://github.com/langchain-ai/langchain) | Built-in multiple Memory components, supports seamless integration with various vector stores. |
4. Infrastructure & Storage
Foundational databases providing physical support for the above memory layers.
| Category | Recommended Projects | Core Capabilities |
|---|---|---|
| Vector Databases | Chroma (https://github.com/chroma-core/chroma), Milvus (https://github.com/milvus-io/milvus), Qdrant (https://github.com/qdrant/qdrant), Weaviate (https://github.com/weaviate/weaviate) | Efficient semantic similarity search and hybrid retrieval. |
| Graph Databases | Neo4j (https://github.com/neo4j) | Complex entity relationship reasoning and deep associative analysis. |
5. Practical Integration
- Start Small: Beginners are advised to start with vector databases. Avoid introducing complex graph structures prematurely unless business needs demand it (e.g., complex plotline reasoning).
- Long-Form Storytelling:
- Prioritize using Mem0 or NovelGenerator to track character arcs.
- Strategy: Generate and store chapter summaries first; retrieve summaries before generating new chapters to ensure coherence.
- Ecosystem Compatibility:
- For users of personal assistants like OpenClaw (formerly Clawdbot), consider using Mem0 or Letta, which offer mature SDKs.
- Privacy-Sensitive: Local agents should prioritize Basic Memory or AgentCortex.
6. Research & Architecture
Advanced research focused on enhancing LLM memory capabilities at the training stage or architectural level.
| Name | GitHub URL | Focus |
|---|---|---|
| Titans | google-research/titans (https://github.com/google-research/titans) | Architecture proposed by Google to enhance long-text processing via a neural memory module. |
| HOMER | alinlab/HOMER (https://github.com/alinlab/HOMER) | Hierarchical context merging (ICLR 2024), efficiently extending context length. |
| Memory3 | BAAI-Agents/Memory3 (https://github.com/BAAI-Agents/Memory3) | Explicit memory large model proposed by BAAI, externalizing knowledge as sparse memory modules. |
| AgeMem | arXiv 2601.01885 (https://arxiv.org/abs/2601.01885) | Unifies learning of LTM/STM storage, retrieval, update, and forgetting strategies with reinforcement learning (ACL 2026). |
| Titans-as-a-Layer | arXiv 2606.08573 (https://arxiv.org/abs/2606.08573) | Plug-and-play test-time memory adapter layer (MAL), extensible to audio multimodality. |
| Awesome LLM Pre-training | RUCAIBox/awesome-llm-pretraining (https://github.com/RUCAIBox/awesome-llm-pretraining) | Curated list for pre-training strategies, architectural improvements (e.g., Ultra-Sparse Memory) research. |
7. MCP & Assistant Skills
Using the Model Context Protocol (MCP) or specific tool calls (Skills) to inject persistent memory capabilities into models.
| Name | GitHub URL | Type | Features |
|---|---|---|---|
| memento-mcp | gannonh/memento-mcp (https://github.com/gannonh/memento-mcp) | MCP | Knowledge graph-driven memory system, supports semantic retrieval and time awareness. |
| OpenClaw Skills | VoltAgent/awesome-openclaw-skills (https://github.com/VoltAgent/awesome-openclaw-skills) | Skills | Includes OpenClaw-specific skills like Git-notes memory and LanceDB triple memory. |
| mcp-memory | samwang0723/mcp-memory (https://github.com/samwang0723/mcp-memory) | MCP/Redis | Knowledge graph MCP server using Redis Graph as backend. |
| Memorix | avids2/memorix (https://github.com/avids2/memorix) | MCP | Local-first, cross-tool shared memory layer, supports Claude Code / Codex / Cursor / OpenCode, etc. |
| mcp-memory (OKF) | fellowgeek/mcp-memory (https://github.com/fellowgeek/mcp-memory) | MCP/SQLite | Persistent memory service based on Open Knowledge Format v0.2 + SQLite FTS5, Markdown-readable and auditable. |
8. Multimodal Consistency & Memory
Specialized tools and algorithms for maintaining character appearance, art style, and voice timbre consistency when generating images and videos.
| Category | Recommended Projects | GitHub URL | Core Features |
|---|---|---|---|
| Visual Consistency | StoryMaker, IP-Adapter | FireRedTeam/StoryMaker (https://github.com/FireRedTeam/StoryMaker) | Maintains consistency of character faces, hairstyles, and clothing across frames/prompts. |
| Video Coherence | ConsistI2V | TIGER-AI-Lab/ConsistI2V (https://github.com/TIGER-AI-Lab/ConsistI2V) | Image-to-Video consistency, maintains layout and motion coherence. |
| Voice Timbre Cloning | Amphion, Bark | open-mmlab/Amphion (https://github.com/open-mmlab/Amphion) | High-fidelity zero-shot voice mimicry, ensures unified timbre for novel dubbing. |
9. Distributed Training
Ensuring absolute synchronization of parameters and gradients across multiple GPUs/nodes during large-scale model training.
| Tool/Algorithm | Type | Key Features |
|---|---|---|
| Megatron-LM | Framework | NVIDIA product, offers extreme model parallelism (TP/PP) efficiency. |
| DeepSpeed | Optimizer/Framework | Microsoft ZeRO technology, standard for memory sharding and large-scale training. |
| FSDP | Native Parallelism | PyTorch built-in, Fully Sharded Data Parallelism, a high-performance alternative to ZeRO-3. |
10. Multi-Agent Coordination
Ensuring consistency of shared state, task progress, and contextual memory during agent team collaboration.
| Project Name | Coordination Mechanism | Features |
|---|---|---|
| DeMAC | Decentralized | Eliminates the Zeno effect, suitable for multi-agent systems requiring 1:1 dynamic response. |
| Nexus Agents | Redis Communication | Redis-based Agent-to-Agent (A2A) communication, tracks multi-agent research progress in real-time. |
11. Online Training
Preventing catastrophic quality degradation and value drift during real-time user interaction or online fine-tuning (RLHF).
| Name | GitHub URL | Core Features |
|---|---|---|
| OpenRLHF | OpenRLHF/OpenRLHF (https://github.com/OpenRLHF/OpenRLHF) | Distributed PPO/GRPO, includes rigorous KL divergence constraints to prevent alignment collapse. |
| Online-RLHF | RLHFlow/Online-RLHF (https://github.com/RLHFlow/Online-RLHF) | Focuses on online iterative feedback, reproduces high stability for LLaMA3-level models. |
12. Continual Learning
Ensuring LLMs do not suffer catastrophic forgetting when adapting to new scenarios/domains, maintaining long-term memory continuity.
| Name | GitHub URL | Algorithm Background |
|---|---|---|
| ContinualLM | UIC-Liu-Lab/ContinualLM (https://github.com/UIC-Liu-Lab/ContinualLM) | Domain-adaptive continual pre-training framework, supports large-scale incremental learning. |
| CURLoRA | MNoorFawi/curlora (https://github.com/MNoorFawi/curlora) | Combines CUR decomposition with LoRA for continual fine-tuning, balancing low overhead and high stability. |
| Awesome Lifelong | zzz47zzz/awesome-lifelong-learning (https://github.com/zzz47zzz/awesome-lifelong-learning-methods-for-llm) | Summarizes all mainstream forgetting prevention methods, including EWC, experience replay buffers. |
13. Fishbone Diagram of Memory Technology Evolution
Below is a fishbone diagram (cause-effect skeleton) outlining several main lines of “where LLM long-term memory capabilities come from,” to facilitate quick global comprehension. The fish head is “LLM Long-Term Memory Capability,” each “large bone” on the skeleton is a technical dimension, and branches are representative works.
┌─ RAG (2020, Meta) ................ Foundation of parametric-external memory ├─ GraphRAG (2024, MS) ........... Graph + community summarization Retrieval/External Memory ──────┼─ HippoRAG (2024) ............... Hippocampal indexing + PPR └─ Memory3 (2024, BAAI) .......... Explicit/sparse memory module │ ├─ Generative Agents (2023) . Memory stream + reflection ├─ MemGPT / Letta (2023) .... Virtual context stratification Mechanism/Architectural Memory ─────────────┼─ LongMem (2023) ............ Frozen encoder + cache bank ├─ ReadAgent (2024) ......... Pagination + gist compression ├─ Titans (2024-25, Google) . Neural LTM + test-time learning └─ Titans-as-a-Layer (2026) . Memory layering, plug-and-play │ ├─ MemoryBank (2023) ........ Forgetting curve decay Production-Grade Memory Layers ──────────────┼─ Mem0 / Mem0g (2025) ...... Vector + graph memory layer ├─ Zep / Graphiti ........... Temporal knowledge graph └─ A-MEM (2025) ............. Zettelkasten self-evolution │ ├─ AgeMem (2026) ............ RL-learned memory management strategy Learnable Memory Management (2026) ─────┼─ TriMem (2026) ............. Multi-granularity + parameter-free evolution ├─ Infini Memory (2026) ..... Topic documents + fact revision └─ MOSAIC (2026) ............ Conflict-aware structured memory │ ├─ MemoryAgentBench (ICLR'26) Four-dimensional capability decoupling Evaluation Systems (2026) ───────────┼─ MemoryArena / Memoria-Bench Multi-session agentic ├─ HaluMem ................... Operational-level hallucination └─ LongMemEval-V2 ........... Web agent environmental experience
Similar Articles
@wsl8297: Sharing an easy-to-read open-source book 'Foundations of Large Models'. From an introduction to large language models to architectural evolution, then to key technologies such as Prompt engineering, parameter-efficient fine-tuning, model editing, retrieval-augmented generation (RAG), all in one book. GitHub: https://github.com/ZJU-LLMs/…
The Zhejiang University team open-sourced an easy-to-understand textbook on large models 'Foundations of Large Models', covering from architectural evolution to key technologies like RAG, accompanied by the Agent-Kernel multi-agent framework.
@seclink: If Chen Tianqiang doesn't step up, ByteDance will steal the show in the LLM memory race... We were early and tried hard, but the execution fell short... The open-source CLI tool OpenViking has undergone many iterative optimizations... Sooner or later, you'll remember that when using AI to refactor complex projects, you'll definitely need LLM memory...
OpenViking is an open-source CLI tool designed to enhance the AI coding experience for complex projects and save tokens through LLM memory features. The article comments on its performance in execution and discusses the dynamics in the LLM memory space with competitors like ByteDance.
@GitHub_Daily: To dive deep into model research, you can't just stay at the application layer—you need to understand how the underlying system is trained and optimized. I stumbled upon LLMSys-PaperList, a carefully curated collection of papers related to large model systems. It is continuously updated from 2022 to the latest top conference papers in 2026, and organized by categories such as training, inference, multimodality...
A carefully curated collection of papers related to large model systems, covering training, inference, multimodality, and more. It is continuously updated and includes technical reports, frameworks, and courses, making it a valuable reference for researchers and developers.
@ba_niu80557: https://x.com/ba_niu80557/status/2073362883728302125
Stanford University proposes the AutoMem method, which allows models to learn memory management (selective forgetting) instead of expanding parameters. This doubles the performance of a 32-billion-parameter small model and matches top-tier large models, revealing that memory management is more important than model scale.
@vintcessun: A 'knowledge hard drive' that can be plugged across models — the difficulty lies not in moving the memory table, but in configuring the read head for the target model. https://arxiv.org/abs/2608.17050 The paper first trains Engram hash memory with the source model, then freezes the memory and target backbone, only training the reader to complete addressing...
This paper proposes a method for cross-model memory transfer through target-side reader adaptation, using Engram hash memory and a lightweight reader, achieving 38.8 on QA tasks, and applicable to Agent memory updates and audits. The limitation is that it was only tested up to 9B models, with scaling laws unknown.