10 Open-Source AI Agent Memory Projects and 3 Architectural Stacks to Solve Context Amnesia

Developer @wanerfu (摆烂程序媛, @wanerfu) on X has shared a curated breakdown of 10 open-source GitHub projects designed to solve "context amnesia"—the recurring challenge where autonomous AI agents lose conversational context and project state across session boundaries—alongside three production-tested architectural stacks.

When large language model (LLM) agents transition from brief single-turn prompts to long-running, multi-day software projects or personalized assistants, their primary operational limitation is the lack of cross-session persistence. Expanding context window tokens alone cannot fix the fundamental issue of stateless restarts: every new session starts as a clean slate, discarding accumulated user preferences, architectural rules, and debugging lessons. Bridging this gap requires dedicated external memory layers.

1. The 6-Stage Lifecycle Loop of Agent Memory

Rather than treating memory as a passive transcript log, the author highlights a continuous 6-stage lifecycle required for autonomous agents to build and maintain operational knowledge:

Experience → Remember → Connect → Retrieve → Act → Update

1. Experience: Capturing runtime interaction events, including conversation turns, CLI command outputs, file modifications, and environment observations.
2. Remember: Extracting salient facts, episodic timestamps, and user traits rather than hoarding raw text tokens, persisting them into durable storage.
3. Connect: Building structured relationships, entity links, and temporal progressions across disparate facts into an evolving knowledge graph.
4. Retrieve: Dynamically querying only relevant context using hybrid scoring that combines dense vector similarity, BM25 keyword matching, and entity graph hops.
5. Act: Feeding retrieved memories into the active context window so the agent can execute tools and craft informed responses.
6. Update: Re-evaluating existing beliefs based on new evidence, refining observations, and invalidating deprecated or outdated assumptions.

2. 10 Open-Source Memory Projects Across the Stack

The 10 open-source repositories each tackle distinct responsibilities across the agent memory stack:

1) Persistent Memory Infrastructure

• 1. Mem0 (mem0ai/mem0): A widely adopted memory infrastructure layer with over 66,000 GitHub stars. It manages user, session, and agent state tiers with single-pass ADD-only extraction, entity linking, and temporal reasoning across vector and graph (Mem0g) databases.
• 2. Hindsight (vectorize-io/hindsight): A biomimetic agent memory architecture built around "Retain → Recall → Reflect". It condenses raw facts into deduplicated observations with citation proofs and synthesizes persistent "Mental Models" to answer deep standing questions.
• 3. memU: Long-term memory infrastructure built specifically for AI agents handling extended interaction workflows.

2) Knowledge Graph Transformation & Evolution

• 4. Cognee (cognee): Turns unstructured documents, codebases, and conversations into structured knowledge graphs via its add → cognify → search pipeline and remember → recall → improve → forget v2 lifecycle API.
• 5. Graphiti (getzep/graphiti): A temporal knowledge graph engine designed to track how facts, relationships, and entities evolve dynamically over time.
• 6. OpenViking: Dedicated context and memory management middleware bridging autonomous agents and underlying data stores.

3) Stateful Agents & Developer Workflows

• 7. Letta (letta-ai/letta): Formerly MemGPT, Letta structures agent memory like an operating system memory hierarchy (working context as RAM, persistent archival storage as disk) to preserve persistent agent identity and state.
• 8. Letta Code: A specialized memory system designed for coding agents, preserving repository decisions, architectural patterns, and engineering conventions across sessions.

4) Full-Stack Infrastructure & Evaluation

• 9. OpenMemory: An open, cross-stack memory infrastructure designed for integrating state across diverse AI applications.
• 10. Agent Memory Benchmark: A standardized evaluation suite measuring how accurately and consistently agents retain and recall information across long conversational horizons.

3. 3 Production-Tested Architectural Stacks

Rather than combining disparate tools arbitrarily, the guide outlines three purpose-built pipelines tailored to specific operational domains:

1) Coding Specialist Stack: Hindsight → Cognee → Letta Code

• Role Distribution:
  • Hindsight: Reflects on previous build errors, debugging sessions, and refactoring guidelines, compiling them into standing engineering mental models.
  • Cognee: Maps repository source code ASTs, dependency graphs, and documentation into relational knowledge.
  • Letta Code: Supplies persistent state directly to terminal shells and IDE environments, enabling coding agents to resume development without losing context.

2) Personalized Companion Stack: Mem0 → Graphiti → Letta

• Role Distribution:
  • Mem0: Persists user profiles, preferences, and multi-session conversational history across user, session, and agent levels.
  • Graphiti: Tracks temporal changes in user life events, projects, and evolving interests over time.
  • Letta: Preserves persistent persona identity and seamless dialogue continuity across multiple frontend client interfaces.

3) Corporate Brain Stack: Cognee → Graphiti → Hindsight

• Role Distribution:
  • Cognee: Ingests internal wikis, documentation, meeting minutes, and architectural standards into an interconnected enterprise knowledge graph.
  • Graphiti: Records shifting project roadmaps, reorganized teams, and modified technical specs over time.
  • Hindsight: Executes deep reflective synthesis across company-wide archives to answer complex strategic inquiries.

4. Multi-Layer Memory Architecture Pitfalls and Temporal Consistency

Engineering discussions around these memory stacks highlight key considerations for production deployment:

• Respect Architectural Layering: Tools operate on different tiers: Mem0 and Letta manage conversational state ("what happened in chat"), Cognee and Graphiti structure facts into dynamic graphs, and OpenViking orchestrates context injection. Stacking overlapping tools without clear boundaries causes duplicate writes, token bloat, and conflicting state.
• Temporal Invalidation is Critical: The true test of memory infrastructure is not merely retrieving past logs, but updating state when facts change. If a project updates from Python 3.11 to Python 3.12, the system must retain historical traceability while strictly returning the updated version as current truth.
• Benchmark Before Deployment: Teams should validate candidate memory pipelines using tools like Agent Memory Benchmark before shipping to production to ensure retrieval latency and recall precision match target SLAs.

Original source

• 摆烂程序媛 (@wanerfu) on X: 10 Open-Source AI Agent Memory Projects and 3 Architecture Stacks
• Mem0 Official GitHub Repository: mem0ai/mem0
• Hindsight Official GitHub Repository: vectorize-io/hindsight