The memory layer for AI agents, catalogued and sourced.

A persistent-memory compression system for Claude Code and other agent CLIs. Lifecycle hooks capture what the agent does during a session, an AI worker compresses those observations, and a search skill injects relevant context back into future sessions.

Best for: Developers wanting drop-in persistent session memory for Claude Code and similar coding-agent CLIs

Fastest setup + largest integration ecosystem; dual session/user scope.

Best for: Fastest drop-in memory with the biggest integration ecosystem · Token-cost-sensitive production agents (single-pass extraction, sub-7k tokens/call) · AWS Agent SDK users and SOC 2 / HIPAA workloads

Local-first AI memory distributed as a Python CLI/library plus an MCP server. Stores conversation and project history as verbatim text — it explicitly does not summarize, extract, or paraphrase — and retrieves it with semantic search over a structured index where people/projects are 'wings', topics are 'rooms', and original content lives in 'drawers' so searches can be scoped rather than run flat. Bundles a temporal entity-relationship knowledge graph with validity windows.

Best for: Local-first agent memory where verbatim, source-traceable recall and scoped semantic search matter more than fact extraction

Bi-temporal knowledge graph — every fact carries validity windows; stale facts are auto-superseded.

Best for: Facts that change over time

Production polish: sub-300ms, SOC2/HIPAA, connectors, context fencing.

Best for: Polished managed memory API with SOC 2 / HIPAA compliance · Coding-agent memory via MCP (Claude Code / OpenCode plugins) · One API over mixed data (files, email, PDFs, chat)

Tiered context (L0→L2) for token savings; unifies memory + resources + skills as a filesystem.

Best for: Token-lean, inspectable filesystem-based context (no vector DB) · OpenClaw / agent setups unifying memory + resources + skills

ECL ingestion of 38+ formats into an ontology-grounded graph; 14 retrieval modes.

Best for: Local-first GraphRAG over a large, mixed-format corpus · Edge / on-device memory (Rust engine) · Enterprise knowledge-graph workflows (e.g. research / evidence graphs)

A persistent-memory server for AI coding agents, built on the `iii` engine and extending Karpathy's LLM-wiki pattern with confidence scoring, lifecycle, knowledge graphs, and hybrid search. Exposes 53 MCP tools and 12 auto-hooks; zero external databases required.

Best for: Coding agents needing a self-contained, no-external-DB persistent memory with hybrid search and team/namespacing

The agent itself manages its memory (RAM/cache/disk) inside its reasoning loop.

Best for: Long-running autonomous agents that manage their own memory · Memory-first coding agents (Letta Code, the current flagship)

'reflect' synthesizes conclusions across all memories; retains full turns including tool calls.

Best for: Apps where recall accuracy is the priority (strong LongMemEval scores) · Persistent memory for coding agents (Claude Code / Cursor / OpenCode)

A single-file memory layer for AI agents that packages data, embeddings, search structure, and metadata into one portable '.mv2' file — no server, database, or sidecar files. Organized as an append-only sequence of immutable 'Smart Frames' (content + timestamps + checksums), giving time-travel queries over past memory states. Core is a Rust crate (memvid-core) with Node.js, Python, and CLI SDKs on top.

Best for: Agents or apps needing portable, serverless, single-file memory they can copy/version/share, with offline hybrid + multimodal retrieval

Memory in plain SQL — no vector DB, fully inspectable, portable.

Best for: Skip the vector DB — inspectable SQL

A 'workspace runtime' that compiles heterogeneous sources (chat logs, documents, code, images, audio, tool traces) into three durable Markdown layers — Index (INDEX.md), Skill (SKILL.md), and Memory (MEMORY.md) — via a memorize() pipeline (ingest → preprocess → extract → organize → persist) and serves scoped, ranked layers back via retrieve().

Best for: Agents needing a multimodal, file-system-shaped memory workspace with source-traceable Markdown layers

A self-hostable 'memory operating system' that packages long-term memory into MemCube units and manages their lifecycle (store / retrieve / update / schedule) outside the model.

Best for: Teams wanting a self-hosted memory layer with hybrid retrieval and skill reuse

A local-first, Markdown-native memory runtime and Python library that gives agents one portable memory layer across coding assistants, apps, devices, and workflows. Stores conversations, files, and agent trajectories as canonical .md files (readable, editable, diffable, Git-versioned) and syncs local SQLite + LanceDB indexes for fast retrieval and self-evolving reuse.

Best for: Makers wanting a portable, local-first, Git-versioned Markdown memory layer shared across multiple agents and apps

Fully-local long-term memory for AI agents built on two pillars: layered long-term memory (a semantic pyramid L0 Conversation → L1 Atom → L2 Scenario → L3 Persona) and symbolic short-term memory that offloads verbose tool logs to files while keeping a compact Mermaid 'canvas' in context. Distributed as a TypeScript/npm package; integrates with OpenClaw and the Hermes gateway.

Best for: Long-horizon agent tasks needing token-efficient, fully-local memory with traceable layered recall

Background deriver models a person's beliefs/preferences/contradictions; a 'peer' can be a human, an agent, or an idea.

Best for: Personalization that models a user's beliefs/preferences over time (theory-of-mind) · Multi-party modeling — what one peer (human or agent) knows about another

Pre-compression capture + human-editable markdown tree; sub-100ms, no LLM in read path.

Best for: Coding agents wanting Git-like, versioned, team-synced memory · Cursor / Claude Code / Windsurf users needing one portable memory layer across 22+ tools

Agent-agnostic persistent memory for AI coding agents: a single, dependency-free Go binary backed by SQLite + FTS5 full-text search, exposed via an MCP (stdio) server, an HTTP API, a CLI, and an interactive TUI. Works with any MCP client (Claude Code, Codex, Gemini CLI, Cursor, Windsurf, VS Code Copilot, OpenCode, and more).

Best for: Coding agents needing a lightweight, local, agent-agnostic persistent memory that survives session and compaction boundaries

Next-generation AI memory system inspired by hippocampal memory encoding and neocortical knowledge consolidation. Spans the full knowledge lifecycle: perception → extraction → association → forgetting. LLM-driven extraction converts conversations into structured entity-relationship triples stored in a Neo4j knowledge graph, while a parallel vector store enables hybrid semantic+keyword retrieval. A biologically-motivated forgetting engine (dormancy → decay → clearance) prunes low-value knowledge automatically.

Best for: AI assistants and agents that need rich relational knowledge management — especially where entity relationships, temporal tracing, and automated forgetting matter more than pure vector recall speed

A lifelong memory stack for LLM agents built on 'semantically lossless compression' — store dense, high-information memory so an agent recalls more while spending far fewer tokens. Ships as one `simplemem` Python package that auto-routes across three pillars: SimpleMem (text efficiency core), Omni-SimpleMem (multimodal: text/image/audio/video), and EvolveMem (self-evolving retrieval). Also offered as a cloud-hosted and self-hostable MCP server. Backed by arXiv papers (2601.02553, 2604.01007, 2605.13941).

Best for: Token-budget-constrained agents needing dense lifelong memory with intent-aware retrieval, optionally across modalities

A modular multi-agent memory system that augments any LLM. Specialized agents manage six memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) under a coordinator that orchestrates updates and retrieval. Ships a desktop app that builds a personal memory base from on-screen activity.

Best for: Personal assistants needing multimodal, screen-aware long-term memory

Local-first knowledge-graph memory layer for AI agents and humans, exposed entirely via MCP. Conversations and notes are stored as plain Markdown files; observations and wikilinks compound into a semantic graph over time. Designed to work with any AI client or IDE that speaks MCP — Claude, Copilot, Cursor, and others. A team cloud tier (basicmemory.com) provides shared workspaces.

Best for: Individual developers and small teams wanting persistent cross-session memory for AI coding assistants with zero infrastructure · Projects where human-readable memory files and direct editing are a design requirement

File-based long-term memory toolkit for AI agents — evolved from the MemoryScope project. Turns conversations and documents into readable, editable, searchable Markdown files linked by wikilinks. Three automated background processes (Auto Memory, Auto Resource, Auto Dream) progressively distil interactions into durable memory nodes and build wikilink relationship graphs over time.

Best for: Personal assistants and knowledge-worker agents that need long-term memory stored in a human-readable, inspectable format · Workflows where both humans and agents read and write the same memory files (e.g., collaborative knowledge bases)

Cross-platform semantic memory layer for AI coding agents. Markdown files are the source of truth — memories are plain `.md` files that are human-readable, directly editable, and version-controllable. Milvus is used as a 'shadow index': a derived, rebuildable cache over the Markdown corpus. Ships a procedural 'Skills from Memory' layer that distils repeated workflows into installable reusable skills. Plugins cover Claude Code, OpenClaw, OpenCode, and Codex CLI; a single memory store is shared across all agents.

Best for: AI coding-agent setups (Claude Code, Cursor, OpenCode, Codex CLI) where cross-agent shared memory and Markdown inspectability are priorities · Teams that want persistent memory without a dedicated database server — the Milvus index is local and the Markdown files are the durable record

Procedural memory — learns how to do tasks and rewrites the agent's own behavior/prompts.

Best for: Teams already on LangChain/LangGraph

An OS-inspired memory layer for personalized AI agents that organizes user memory into short-, mid-, and long-term tiers and migrates entries between them. Published as an EMNLP 2025 Oral.

Best for: Personalized conversational agents needing tiered long-term user memory

Persistent, self-evolving AI memory plugin for coding agents and applications. Combines LLM-driven memory extraction with a two-layer Experience + Skill distillation system: raw interactions are first compressed into Experience memories, then recurring patterns are further abstracted into reusable Skill entries. Ebbinghaus-style time-decay keeps memory collections pruned and relevant over time. Exposes a unified backend via Python SDK, HTTP REST server, MCP server, and CLI.

Best for: AI coding agents and multi-agent systems that need both factual recall and reusable procedural workflows distilled from past sessions · Teams wanting a production-ready memory backend that spans multiple agent clients (Claude Code, Codex, OpenCode, Cline) via a shared server

Local cognitive memory for MCP-compatible agents, shipped as a single ~20MB Rust binary with a 25-tool MCP server, an Axum HTTP/WebSocket server, and a SvelteKit 3D memory dashboard. Implements neuroscience-grounded mechanisms — FSRS-6 spaced repetition, prediction-error gating, synaptic tagging, spreading activation, dual-strength model, and 'memory dreaming' consolidation — across ~30 stateful cognitive modules. 100% local.

Best for: Developers wanting a fully-local, inspectable cognitive memory for coding agents that decays, consolidates, and forgets like a brain

An agent memory management layer positioned as a high-performance drop-in replacement for Mem0 (`import telemem as mem0`), optimized for multi-turn dialogue, character modeling, long-term storage, and semantic retrieval. Pipeline: character-aware summarization → semantic-clustering deduplication → efficient storage → precise retrieval. Extends to multimodal video memory (frame extraction → captioning → vector DB) with ReAct-style multi-step video QA. Backed by a tech report (arXiv 2601.06037).

Best for: Teams wanting a local, Mem0-compatible memory layer with strong per-character isolation and optional video memory

A two-tier memory API server for AI agents built on Redis. Working memory is session-scoped and fast; long-term memory is persistent and searchable across sessions. Exposes both a REST API and a Model Context Protocol (MCP) server from the same backend, so any MCP-capable agent or HTTP client can connect without code changes. Memory extraction strategy (discrete facts, conversation summary, user preferences, or custom) is configurable per deployment.

Best for: Agents already running in Redis-backed infrastructure that want persistent memory without adding a new database · Teams wanting a single memory server accessible from both HTTP clients and MCP-native agents

Self-organising long-term memory substrate for agentic LLM workflows, grounded in Event Segmentation Theory (EST) and Predictive Processing (PP). Ingests multi-turn conversations, segments them into topically coherent episodes via LLM-powered boundary detection, distils durable semantic knowledge from each episode, and exposes a unified search surface for downstream reasoning. Designed as a minimalist production-ready core: PostgreSQL for structured metadata, Qdrant for vector similarity.

Best for: Agentic LLM workflows needing structured long-term memory with semantically coherent episodes and a unified search surface across episodic and semantic stores

A self-hosted MCP server (plus REST API) that adds persistent, personalized long-term memory to any MCP-compatible assistant (Claude Code, ChatGPT, Cursor, Open WebUI, and more). A single unified LLM call performs fact extraction, metadata classification, deduplication, and contradiction resolution at once. Two-tier design: fast searchable summaries in a vector store, plus a detailed artifact store retrieved on demand.

Best for: Self-hosters wanting a private, MCP-native memory server with automatic fact extraction, dedup, and contradiction handling

Non-parametric self-evolving agent memory that applies runtime reinforcement learning on an episodic memory store. Instead of passive semantic matching (retrieve nearest neighbours and hope), MemRL uses environmental feedback signals to learn which past episode strategies are actually useful and promote them via a Two-Phase Retrieval mechanism — decoupling stable reasoning from the plastic memory. Agents improve from experience without weight updates or fine-tuning.

Best for: Research and agentic systems where agents repeatedly solve similar tasks and can provide environmental feedback (reward signals) to improve memory selection over time

A framework-agnostic, fully-offline AI memory system (Python library `taosmd` + optional MCP server) built around 'provable memory': everything lands first in an append-only verbatim archive that is never edited or deleted, and the searchable memory is derived from that archive, never written over it. Because the source is retained, a verifier checks each extracted fact against the exact text it came from and leaves out what it can't support. Part of the taOS ecosystem; runs on 8GB+ RAM (Raspberry Pi 4B to workstation), zero cloud.

Best for: Offline / air-gapped or low-resource deployments needing auditable, source-preserving memory with no cloud dependency

Hybrid BM25 + vector + rerank → exact-token recall semantic search misses.

Best for: Agents needing lossless recall — full chronology, no semantic-search step · Codes / IDs / error strings and preference-recall-heavy apps

A single Rust binary that gives AI agents durable cross-session memory as an MCP-native server — one binary, one SQLite file, no Docker, Postgres, or cloud. Exposes 40+ MCP tools spanning entity CRUD, hybrid search/RAG, an entity link graph, an immutable journal/audit trail, key-value state with TTL, and a memory lifecycle engine. Ships framework adapters for LangGraph, CrewAI, and AutoGen, plus a web dashboard.

Best for: Local-first or air-gapped agents wanting a single-binary, MCP-native memory store with hybrid search, audit trail, and lifecycle decay

An in-process, local-first Python memory library (`pip install archon-memory-core`) whose thesis is that memory should get better the longer it is used. Built on ChromaDB + Ollama, it pairs ranked top-1 retrieval with supersede-aware nightly consolidation, type-aware salience, an entity graph, active forgetting, and full replay/observability. Positions itself as a memory policy library (not an agent runtime), with LangChain and LlamaIndex adapters.

Best for: Agents that accumulate contradictory facts over long horizons and want a local, consolidating memory library with built-in forgetting