---

Why memory? An LLM's context window is its short-term memory — fast, fully attended, and gone the moment the window clears or overflows. Everything an agent should remember across time — facts about a user, past conversations, learned skills, evolving state — has to live outside the window and be selectively retrieved back in. That problem — what to store, when to retrieve it, how to update it, and how to forget — is agentic memory. This list maps the entire space.

Contents

• TL;DR — Start Here
• Taxonomy of Agentic Memory
  • The CoALA frame
  • Short-term vs long-term
  • Long-term subtypes
  • Memory operations (the lifecycle)
  • Memory architectures
• Open-Source Memory Frameworks
  • Dedicated memory frameworks
  • Knowledge-graph & temporal memory
  • Framework-native memory
  • Coding-agent & portable memory
• Feature Comparison
• Managed / Commercial Memory Services
• Research Papers
  • Surveys & foundational frameworks
  • Architectures
  • Episodic & semantic memory
  • Memory management & lifelong learning
• Benchmarks & Evaluation
  • Memory-specific benchmarks
  • Long-context benchmarks (related)
  • Comparative evaluations & leaderboards
• Articles & Deep Dives
• Talks & Courses
• Tutorials & Hands-On
• Other Awesome Lists
• Contributing

---

TL;DR — Start Here

New to the space? This is the shortest path to competence:

1. Read Lilian Weng — LLM Powered Autonomous Agents (the memory section) and the CoALA paper for vocabulary.
2. Understand the two camps: hierarchical paging (MemGPT → Letta) vs temporal knowledge graphs (Zep/Graphiti) vs extraction pipelines (Mem0).
3. Run something: Mem0 (easiest drop-in) or Letta (full stateful-agent platform).
4. Benchmark it against the field's standard trio: LoCoMo + LongMemEval + BEAM.

⚠️ A note on benchmark scores throughout this list: memory benchmark numbers are heavily contested — they swing wildly with config, judge model, and harness. See the Zep ↔ Mem0 dispute before trusting any single SOTA claim. Treat vendor-reported scores as vendor-reported.

---

Taxonomy of Agentic Memory

The CoALA frame

The accepted scaffolding comes from CoALA — Cognitive Architectures for Language Agents (Sumers, Yao, Narasimhan & Griffiths, 2023). It models any language agent as three parts: memory, an action space (internal reasoning + external tools), and a decision procedure. Its memory typology is lifted straight from human cognitive science (Tulving's episodic/semantic split) — which is why Letta, Mem0, LangMem, and Zep all map their features back to the same words.

mindmap
  root((Agent Memory))
    Short-term
      Context window
      Working scratchpad
      Tool outputs
    Long-term
      Episodic
        Past events
        Task traces
      Semantic
        Facts about user
        Domain knowledge
      Procedural
        System prompt rules
        Reusable skills
    Operations
      Encode / Write
      Retrieve
      Update / Resolve conflict
      Forget / Decay
      Consolidate / Reflect
    Architectures
      Vector RAG
      Knowledge graph
      Hierarchical paging
      Summarization buffer

Short-term vs long-term

The central engineering problem is context management: deciding which slice of a huge long-term store gets loaded into the small working set, and when. Letta and Anthropic both call this context engineering.

Long-term subtypes (the cognitive-science mapping)

A widely cited refinement (LangMem) is the distillation hierarchy: raw episodic experiences distill into semantic facts; repeated semantic patterns crystallize into procedural rules. Memory consolidates upward, specific → general, over time.

Memory operations (the lifecycle)

flowchart LR
    I[Interaction] -->|encode / extract| W[Write to store]
    W --> S[(Long-term store)]
    S -->|retrieve: vector / graph / recency| C[Context window]
    C --> R[Reflect / summarize]
    R --> S
    S -->|consolidate + dedup| S
    S -->|forget / decay / supersede| S
    C --> I

• Encoding / writing — extract what's worth keeping (fact/entity extraction, salience scoring). Runs hot-path (synchronous, during the turn) or background (async — LangMem, ChatGPT's "dreaming").
• Retrieval — vector similarity, BM25/keyword, hybrid, graph traversal, recency. Generative Agents scores by recency × relevance × importance.
• Forgetting / decay — TTL/expiry, recency decay, relevance pruning. Keeps the store from growing unbounded.
• Consolidation — merge, dedup, abstract raw memories into higher-level ones (episodic → semantic).
• Reflection / summarization — synthesize higher-order insights ("reflections"); compaction = summarize-and-reinitialize a near-full window.
• Updating / conflict resolution — revise memories when facts change. Good systems mark old facts superseded rather than silently overwriting — this is where temporal reasoning matters (Zep's bi-temporal graph is the reference example).

Memory architectures

Production systems usually combine these — e.g. Redis for session state, a vector DB for semantic recall, Postgres for episodic/procedural, a graph for relations.

---

Open-Source Memory Frameworks

⭐ Star counts are rough order-of-magnitude as of June 2026 — they move fast.

Dedicated memory frameworks

Knowledge-graph & temporal memory

Framework-native memory

Memory modules built into the major agent frameworks — use these if you're already on the framework.

Coding-agent & portable memory

Persistent memory for coding assistants (Claude Code, Copilot, Cursor) and agent-agnostic memory runtimes.

---

Feature Comparison

The dimensions that actually differentiate memory systems. Use these as your evaluation columns.

Key dimensions not shown but worth checking per project: multi-user namespacing, forgetting/decay policy, retrieval method (vector vs hybrid vs graph), tokens-per-query cost, and which benchmarks each reports.

---

Managed / Commercial Memory Services

---

Research Papers

Grouped by category, newest-first within each group. arXiv IDs verified.

Surveys & foundational frameworks

• CoALA: Cognitive Architectures for Language Agents — Sumers et al., 2023 — the canonical taxonomy (working / episodic / semantic / procedural); the standard vocabulary for the whole field.
• Graph-based Agent Memory: Taxonomy, Techniques, and Applications — Yang et al., 2026 — survey of graph-structured memory: extraction, storage, retrieval, evolution.
• From Human Memory to AI Memory: A Survey on Memory Mechanisms in the Era of LLMs — Wu et al., 2025 — maps human memory onto AI via an object/form/time taxonomy.
• A Survey on the Memory Mechanism of LLM-based Agents — Zhang et al., 2024 (TOIS 2025) — the canonical agent-memory survey (repo).
• The Rise and Potential of LLM Based Agents: A Survey — Xi et al., 2023 — broad agent survey; influential brain/perception/action memory framing.

Architectures

• MemOS: Memory OS of AI Agent — Kang et al., 2025 (EMNLP Oral) — OS-inspired hierarchical memory with FIFO + segmented-page updates.
• MemEngine: A Unified Modular Library for LLM-Agent Memory — Zhang et al., 2025 (TheWebConf Oral) — modular library implementing many published memory models.
• Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory — Chhikara et al., 2025 — extract/consolidate/retrieve pipeline (+ graph variant); big latency/token savings.
• Zep: A Temporal Knowledge Graph Architecture for Agent Memory — Rasmussen et al., 2025 — temporal KG on Graphiti; beats MemGPT on DMR, improves LongMemEval.
• MemoRAG: Next-Gen RAG via Memory-Inspired Knowledge Discovery — Qian et al., 2024 — dual-system RAG: long-range memory LLM generates retrieval clues.
• Memory³: Language Modeling with Explicit Memory — Yang et al., 2024 — "explicit memory" as a third form beyond params and KV context.
• HMT: Hierarchical Memory Transformer — He et al., 2024 — plug-in hierarchical memory imitating human memorization.
• Larimar: LLMs with Episodic Memory Control — Das et al., 2024 — brain-inspired episodic memory; one-shot edits + selective forgetting.
• MemoryLLM: Towards Self-Updatable LLMs — Wang et al., 2024 (ICML) — fixed-size latent memory pool, self-updates over ~1M updates.
• MemGPT: Towards LLMs as Operating Systems — Packer et al., 2023 — the foundational "LLM as OS" paper; tiered memory + interrupts (now Letta).
• RecurrentGPT: Interactive Generation of (Arbitrarily) Long Text — Zhou et al., 2023 — language-based recurrence with NL long/short-term memory.
• RET-LLM: A General Read-Write Memory for LLMs — Modarressi et al., 2023 — knowledge as triplets; scalable, updatable, interpretable.
• SCM: Self-Controlled Memory Framework — Liang et al., 2023 — agent + memory stream + controller; infinite-length input, no fine-tuning.
• Memorizing Transformers — Wu et al., 2022 (ICLR) — non-differentiable kNN memory over past (k,v) pairs up to 262K tokens.
• Retrieval-Augmented Generation (RAG) — Lewis et al., 2020 (NeurIPS) — parametric + non-parametric memory; foundation of retrieval-based memory.

Episodic & semantic memory

• MemInsight: Autonomous Memory Augmentation for LLM Agents — Salama et al. (Amazon), 2025 — autonomous annotation/retrieval; +34% recall over RAG on LoCoMo.
• A-MEM: Agentic Memory for LLM Agents — Xu et al., 2025 — Zettelkasten-inspired atomic notes, dynamic linking, memory evolution.
• From RAG to Memory: Non-Parametric Continual Learning (HippoRAG 2) — Gutiérrez et al., 2025 (ICML) — deeper passage integration; factual + associative memory gains.
• MemTree: Dynamic Tree Memory Representation — Rezazadeh et al., 2024 — tree-structured memory at varying abstraction, like cognitive schemas.
• HippoRAG: Neurobiologically Inspired Long-Term Memory — Gutiérrez et al., 2024 (NeurIPS) — hippocampal-index retrieval via KG + Personalized PageRank.
• MemoryBank: Enhancing LLMs with Long-Term Memory — Zhong et al., 2023 (AAAI) — Ebbinghaus-forgetting-curve updates; SiliconFriend companion.
• Generative Agents: Interactive Simulacra of Human Behavior — Park et al., 2023 (UIST) — memory stream + recency/importance/relevance retrieval + reflection.

Memory management & lifelong learning

• Agent Workflow Memory (AWM) — Wang et al., 2024 (ICML 2025) — induces reusable workflows from past trajectories.
• Memory Sharing for LLM-based Agents — Gao & Zhang, 2024 — shared memory pool across similar agents; collective intelligence.
• Think-in-Memory (TiM) — Liu et al., 2023 — store evolving "thoughts" with insert/forget/merge + LSH retrieval.
• ExpeL: LLM Agents Are Experiential Learners — Zhao et al., 2023 (AAAI) — extract NL insights across tasks, recalled at inference.
• MemoChat: Memos for Consistent Long-Range Conversation — Lu et al., 2023 — memorize–retrieve–respond cycles with structured memos.
• RecallM: Adaptable Memory with Temporal Understanding — Kynoch et al., 2023 — graph-backed memory; 4× better at knowledge updates than vector-only.
• LongMem: Augmenting LMs with Long-Term Memory — Wang et al., 2023 (NeurIPS) — decoupled memory encoder + residual side-network reader.
• Voyager: An Open-Ended Embodied Agent — Wang et al., 2023 — lifelong Minecraft agent with a growing, retrievable skill library (code-as-memory).
• Reflexion: Language Agents with Verbal Reinforcement Learning — Shinn et al., 2023 (NeurIPS) — verbal self-reflections in an episodic buffer; no weight updates.

---

Benchmarks & Evaluation

⚠️ Memory scores are config/judge/harness-dependent and frequently contested. Always note who reported a number.

Memory-specific benchmarks

Long-context benchmarks (related)

These test long context-window retrieval, not persistent cross-session memory — a distinction worth keeping straight.

Comparative evaluations & leaderboards

• Zep: State of the Art in Agent Memory — Zep/Graphiti vs MemGPT on DMR; LongMemEval gains + latency reduction.
• Lies, Damn Lies & Statistics: Is Mem0 Really SOTA? — Zep disputes Mem0's LoCoMo claim (issue thread). Read this for benchmark skepticism.
• Letta: Is a Filesystem All You Need? — filesystem-memory benchmarking + critique of Mem0's LoCoMo methodology.
• Mem0: State of AI Agent Memory 2026 — survey of benchmarks, architectures, production gaps, vendor score table.
• Mem0: OpenAI Memory vs LangMem vs MemGPT vs Mem0 — head-to-head accuracy.
• OMEGA LongMemEval Leaderboard — public leaderboard (OMEGA, Mastra, Emergence AI, Zep/Graphiti…).
• Agent Memory at Scale 2026 — vendor landscape (Letta, Zep, Mem0, LangMem).

---

Articles & Deep Dives

• Lilian Weng — LLM Powered Autonomous Agents — the most-cited short explainer of short- vs long-term memory.
• Anthropic — Effective Context Engineering for AI Agents — compaction, context editing, memory tools; the best working-memory treatment.
• Letta — Agent Memory: How to Build Agents That Learn and Remember — message buffer / core / recall / archival, framed as context engineering.
• LangChain — Context Engineering for Agents — the write/select/compress/isolate framework.
• LangChain — LangMem SDK launch — clearest semantic/episodic/procedural + hot-path/background framing.
• Redis — Long-Term Memory Architectures for AI Agents — ingestion → embedding → retrieval → consolidation pipeline.
• Neo4j — Graphiti: Knowledge Graph Memory for an Agentic World — deep dive on the temporal-KG library under Zep.
• AWS — Persistent Memory with Mem0 + Valkey + Neptune — production reference architecture (vector + graph).
• Cognee — CoALA Explained — plain-language CoALA walkthrough.
• Mem0 — AI Memory Benchmarks 2026 — explains LoCoMo / LongMemEval / BEAM.

Talks & Courses

• DeepLearning.AI — LLMs as Operating Systems: Agent Memory (Packer & Wooders, Letta) — build MemGPT-style self-editing memory.
• DeepLearning.AI — Long-Term Agentic Memory with LangGraph (Chase & Ng) — semantic/episodic/procedural via hot-path + background.
• DeepLearning.AI — Agent Memory: Building Memory-Aware Agents (Oracle) — "memory engineering": managers, extraction, consolidation, multi-backend retrieval.
• Latent Space — Context Engineering for Agents (Lance Martin) — managing the working-memory budget.
• Latent Space — "RAG is Dead, Context Engineering is King" (Jeff Huber, Chroma) — retrieval vs context engineering.

Tutorials & Hands-On

• NirDiamant — Agent Memory Techniques — 30+ runnable notebooks covering memory techniques (incl. Letta/MemGPT).
• Claude Cookbook — Context Engineering — hands-on compaction, context editing, tool clearing.
• MemoryBank / SiliconFriend — reference implementation of forgetting-curve memory.

---

Other Awesome Lists

• topoteretes/awesome-ai-memory
• TsinghuaC3I/Awesome-Memory-for-Agents
• TeleAI-UAGI/Awesome-Agent-Memory
• DEEP-PolyU/Awesome-GraphMemory
• Shichun-Liu/Agent-Memory-Paper-List
• ysymyth/awesome-language-agents (CoALA companion)

---

Contributing

Contributions welcome! See CONTRIBUTING.md. Found a missing project, paper, or benchmark? Open a PR or issue. The bar: it must be a real, locatable resource specifically about agentic / LLM-agent memory, with a working link.

License

To the extent possible under law, the contributors have waived all copyright and related rights to this work (CC0-1.0).