AI agent memory frameworks, 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

Single-pass ADD-only extraction: each add() fires one LLM call (default gpt-5-mini) that accumulates facts — no UPDATE or DELETE on ingestion. Entity linking via spaCy (installed as `mem0ai[nlp]`) extracts named entities from every stored memory and writes them to a parallel vector sub-collection (`{collection}_entities`); retrieval folds entity-match scores into the ranking alongside dense and keyword signals. External graph DB support (Neo4j, Memgraph, Kuzu, AGE, Neptune) was removed in 2026; graph-style association is now vector-native. Three memory scopes: user (cross-session persistence), session (ephemeral per run), agent (runtime state). Two deployment paths: OSS library (BYO LLM + BYO vector store) or fully managed cloud (Qdrant-backed, auto-scaled). 23+ official integrations span LangChain, LangGraph, CrewAI, AutoGen, Vercel AI SDK, OpenAI Agents SDK, Google ADK, AWS Bedrock, LiveKit, ElevenLabs, Dify, Flowise, and more.

Best for: Fastest drop-in memory with the largest integration ecosystem when time-to-working-agent is the constraint · Token-cost-sensitive production agents needing sub-7k retrieval tokens and single-pass extraction without full-context overhead · SOC 2 / HIPAA workloads and AWS Agent SDK users needing managed, auditable memory with no infrastructure to run

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

Three-stage ECL pipeline: Extract ingests 30+ multimodal formats (PDF, Slack, Notion, images, audio) via dedicated connectors with auto-OCR and transcription; Cognify runs LLM-powered entity/relationship extraction into subject-predicate-object triples with RDF/OWL ontology alignment and URI-based coreference resolution (unifying name variants across documents into canonical identifiers); Load dual-writes to a pluggable graph store (Postgres native, Neo4j, Kuzu) and vector store (pgvector, Qdrant, LanceDB). Retrieval combines graph BFS traversal, vector similarity, temporal filtering, and auto-routing query optimization; hot context is cached in session memory with transparent fallback to the persistent knowledge graph across sessions.

Best for: Cross-document multi-hop reasoning where entity identity must be preserved across ingestion runs (legal, finance, research evidence graphs) · LangGraph or CrewAI agents needing first-party persistent memory without building a custom graph layer · Enterprise knowledge-graph workflows over large mixed-format corpora where ontology-backed deduplication matters

Context Engineering Platform (Zep v3) built on Graphiti — a bi-temporal knowledge graph that models facts as triplets (entity-relationship-entity) with temporal metadata on every edge. Contradictions are resolved via temporal edge invalidation, not LLM judgment: when a fact changes, the old edge is superseded and a new one is created, preserving the full historical timeline. Ingestion uses discrete episodes (text or structured JSON) that maintain data provenance and enable incremental extraction. Zep Cloud delivers enterprise-grade managed hosting (SOC 2 Type II, HIPAA BAA, BYOC); Graphiti is the Apache-2.0 OSS engine underneath.

Best for: Agents tracking facts that change over time — customer profiles, evolving relationships, product details that must stay current without losing history · Enterprise multi-agent deployments needing SOC 2 / HIPAA compliance, BYOC deployment, and sub-200ms retrieval SLAs · Workflows requiring point-in-time historical queries ("what did the agent know about X on date Y?")

Production polish: sub-300ms, SOC2/HIPAA, connectors, context fencing via container tags. Writes auto-extract facts into dual-layer user profiles (static + dynamic) and a unified knowledge graph; an asynchronous background pass ('Dynamic Dreaming', shipped May 2026) reconsolidates fragmented memories, reweights contradictions, and infers cross-memory connections without blocking the write path. Claims #1 on LongMemEval/LoCoMo/ConvoMem (self-reported); publishes an open-source benchmarking harness, MemoryBench, that others can run against Mem0 and Zep, though Supermemory's own headline numbers still come from its own runs of it.

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

Tiered context (L0→L2) for token savings; unifies memory + resources + skills as a filesystem. Built by ByteDance subsidiary Volcengine; native hook-based integrations for OpenClaw, Hermes, Claude Code, and Codex CLI; MCP endpoint for generic MCP clients (Cursor, OpenCode, ChatGPT, etc.).

Best for: Token-lean, inspectable filesystem-based context (no vector DB required) · OpenClaw / Hermes / Claude Code / Codex CLI agent setups unifying memory + resources + skills · Teams that need observable, debuggable retrieval paths

A markdown-repo-native memory layer: a git repo of frontmatter-tagged markdown pages is the canonical store, synced into either embedded PGLite or Postgres/pgvector as a disposable, rebuildable index. A contract-first BrainEngine interface (~47 operations) is implemented identically by both storage engines, so the CLI and MCP server are generated from one source. On top of storage sits an optional synthesis layer (`gbrain think`) that composes cited answers with explicit gap analysis, plus a cron-driven 'dream cycle' that enriches, dedupes, and detects contradictions overnight.

Best for: Developers on Claude Code, Codex, or Cursor who want git-backed markdown memory wired in via MCP in two commands · Power users building a personal brain over meetings, email, and notes who want graph-aware recall and synthesized cited answers · Small teams wanting a self-hosted, OAuth-scoped shared institutional memory

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

Encodes conversation turns as hierarchically structured facts — world facts and experience facts consolidate into observations that merge into mental models, with automatic deduplication and evidence-tracking across updates. TEMPR retrieval runs four strategies in parallel (semantic, keyword/BM25, entity-graph, temporal) and merges results before returning them to the agent. Reflect reasons over retained memories using configurable mission, directives, and disposition settings per memory bank. Iris Extract provides a separate LLM-mediated structured-extraction pass for document ingestion. Memory banks are isolated namespaces; 40+ official framework adapters plus a first-party MCP server expose all operations.

Best for: Apps where recall accuracy is the priority (strong LongMemEval scores) · Persistent memory for coding agents (Claude Code / Cursor / Continue.dev / OpenCode / Roo Code) · Teams needing enterprise-grade memory: bank isolation, audit logs, webhooks, SSO, RBAC, and a managed cloud option

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 (@tencentdb-agent-memory/memory-tencentdb); integrates with OpenClaw and Hermes via plugins and exposes a REST Gateway API at port 8420 for use from any HTTP-capable agent framework.

Best for: Long-horizon agent tasks needing token-efficient, fully-local memory with traceable layered recall · Agents running on OpenClaw or Hermes wanting zero-config long-term memory with no external API · Teams that want a standalone REST Gateway memory sidecar callable from any agent framework

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. LoCoMo benchmark: 81.95% accuracy at ~1,294 tokens/query (self-reported). Paper: arxiv.org/abs/2603.19935.

Best for: Cost-sensitive production: skip the vector DB and run on the SQL infra you already have · Inspectable, debuggable memory you can query directly · Agents where what the agent *did* (tool calls, decisions) matters as much as what the user *said*

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(). The SKILL.md layer auto-extracts reusable workflow patterns from agent tool traces on every memorize() call, letting agents improve at recurring tasks without manual tagging.

Best for: Agents needing a multimodal, file-system-shaped memory workspace with source-traceable Markdown layers · Teams wanting a managed cloud memory API with a free starter tier before committing to self-hosted infrastructure · LangGraph or n8n workflows where a drop-in memory adapter with built-in skill extraction is needed

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. Exposes a local REST API server (OpenAPI-documented) for agent integration; optional multimodal ingest extra handles images, PDFs, audio, and office documents.

Best for: Makers wanting a portable, local-first, Git-versioned Markdown memory layer shared across multiple agents, apps, and AI coding assistants · Agents that need user-profile memory and agent-skill memory as separate, orthogonally-scoped tracks in one runtime

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. v2.0 adds multi-cube knowledge base management, multi-modal memory, tool-use history, async ingestion via MemScheduler, and natural-language feedback and correction.

Best for: Teams wanting a self-hosted memory layer with hybrid retrieval and skill reuse · Projects needing an MCP-accessible memory server that can run locally or in the cloud

Peer-centric memory built on four primitives: Workspaces (app-level isolation), Peers (any long-lived entity — user, agent, group, project, or idea), Sessions (many-to-many interaction threads between peers), and Messages (data units that trigger reasoning). Honcho 3.0 (Jan 2026) split reasoning into three stages run by the deriver worker process: ingestion reasoning extracts deductive (explicit) and inductive (inferred) conclusions in parallel on write; an async Dreaming Agent handles lower-priority background work (summarization, peer-card generation, surprisal-prioritized reprocessing) off the request path; a query-time Dialectic Agent answers chat() calls with an agentic search-and-synthesize loop across five reasoning depths (minimal to max). Configurable LLM backends (OpenAI, Anthropic, Gemini); queries target this derived conclusion/representation layer rather than raw message history.

Best for: Personalization that must model a user's evolving beliefs, preferences, and contradictions over many sessions (theory-of-mind, not fact recall) · Multi-agent or multi-party systems where what peer A knows about peer B — or what an AI agent knows about a human — needs to persist and update · Coding-assistant memory (Claude Code plugin, Cursor MCP) where context must survive across sessions, directories, and projects

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

Pre-compression capture + human-editable markdown tree; tiered retrieval (cache → FTS → LLM fallback). Primary cache/FTS paths are sub-100ms and LLM-free; cloud sync is optional.

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

A neurobiologically inspired long-term memory framework that builds a knowledge graph over documents and retrieves with Personalized PageRank, enabling continual integration of knowledge. HippoRAG 2 improves multi-hop associativity and sense-making.

Best for: Multi-hop retrieval and knowledge integration over large document corpora

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

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

A modular multi-agent memory system that can be plugged into any LLM agent stack. Specialized agents manage six memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) under a meta-agent coordinator that orchestrates writes and retrieval. Backed by PostgreSQL with BM25 full-text search and embedding-based vector similarity. Exposed as a self-hosted REST API or via managed hosting at app.mirix.io. The screen-activity tracking desktop app was deprecated in v0.1.6 and lives on a separate branch.

Best for: Agent developers needing a drop-in, multi-type memory layer behind a REST API · Projects requiring BM25 + vector hybrid retrieval across distinct memory categories · Teams that want local-first, self-hosted storage with an optional managed fallback

Splits memory into three tiers: working (in-session, ephemeral), episodic (graph-based conversational history in Neo4j), and profile (long-term user facts in Postgres). Agents interact through a REST API, Python or TypeScript SDKs, or a native MCP server. An optional retrieval agent layer (split-query and chain-of-query strategies) orchestrates multi-tool retrieval for complex questions rather than issuing a single lookup. LLM-agnostic across OpenAI, Anthropic, Bedrock, and Ollama, and ships an in-repo evaluation harness covering LoCoMo, WikiMultiHop, and HotpotQA.

Best for: Teams that want separate working, episodic, and profile tiers and are comfortable operating Postgres plus Neo4j · Multi-framework shops wanting one memory backend wired into LangChain, CrewAI, LlamaIndex, or n8n via first-party adapters · Applications where multi-hop reasoning over conversation history matters more than single-shot recall

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. Runs as a local service (default port 2333) exposing a REST/MCP API; integrates with Claude Code via a first-party HTTP MCP plugin (v0.4.0.5) and with AgentScope-based agents via an in-process SDK adapter.

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) · Claude Code users wanting persistent cross-session memory with zero infrastructure beyond a local Python service

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

BEAM (Bilevel Episodic-Associative Memory): a working-memory tier (hot context, auto-injected before LLM calls, TTL eviction) consolidates into an episodic long-term tier, alongside a TripleStore temporal knowledge graph with version chains and as-of queries. Optional LLM-driven fact extraction and entity extraction at write time; a `sleep` command runs consolidation. Memory banks give per-domain isolation. Ships Hermes-first (native plugin with lifecycle hooks) but is framework-agnostic via MCP, Python SDK, and CLI.

Best for: Local-first or offline personal agents where memory must stay on-device with no cloud in the read path · Coding-agent memory over MCP (Claude Code, Cursor, Codex CLI, Windsurf) with sub-millisecond in-process recall · Low-resource deployments (Raspberry Pi, 1 GB VPS) that can't carry a vector DB or Postgres · Hermes Agent users wanting a native memory provider with automatic context injection

A CLI-first memory agent built on three primitives — remember, recall, answer — over 13 typed memory categories with conflict detection and temporal versioning. All retrieval runs through Moorcheh's proprietary information-theoretic search engine, which the CLI provisions either as a local Docker container (fully offline, no account) or as a managed cloud backend. External agents reach it via an MCP server, a local REST API, a TypeScript SDK, or one-command `memanto connect <tool>` wiring for a documented roster of coding agents and frameworks.

Best for: Developers wanting persistent memory shared across several coding agents with zero backend to manage · Teams wanting typed, versioned memory with conflict detection without standing up a vector or graph store · Offline or air-gapped setups that can run the local Docker engine with no account

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

Best for: Teams already on LangChain/LangGraph who need agents that improve from feedback

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 via heat-based promotion/demotion. Four core modules: Storage, Updating, Retrieval, and Generation. Published as an EMNLP 2025 Oral.

Best for: Personalized conversational agents needing tiered long-term user memory · Claude Desktop / Cursor / Cline setups wanting plug-in memory via MCP

A single Rust server that gives coding agents a shared, persistent markdown wiki in a git repo. Lifecycle hooks fire-and-forget capture every prompt, tool call, and session boundary; at session end (or PreCompact) the relevant pages are consolidated into a coherent narrative, and the next agent that starts in the same directory receives a 'where you left off' handoff before its first prompt. Exposes MCP + an HTTP /web browser UI on the same axum server; a thin-client CLI talks to the server over HTTP.

Best for: Developers who switch between coding-agent CLIs/IDEs and want portable, git-native project memory with automatic session handoff · Teams wanting a self-hosted, grep-able wiki of decisions shared across agents and machines

Rejects background auto-extraction on principle — the project's position is that with proxy memory 'the AI doesn't know what it remembers and has no say in what gets recorded.' Instead the agent itself authors, classifies, and writes its own recall trigger for every memory through seven first-person MCP tools. A Python/FastAPI backend stores memories as a node–memory–edge–path graph addressed by human-readable URIs (core://agent/identity), with an automatic version-chain snapshot on every AI write and a React dashboard offering diff and rollback.

Best for: Solo users wanting a persistent, portable, human-auditable identity layer that follows them across any MCP-capable model or client · Developers who want full local control on a single SQLite file with zero external services · Anyone who wants the agent to explicitly decide and disclose what it remembers rather than have it extracted in the background

A Go REST API server is the single source of truth, fronted by thin, stateless per-runtime plugins for OpenClaw, Hermes Agent, Claude Code, OpenCode, Codex, and Dify, plus a documented raw HTTP API for any custom client. Two deployment modes: Direct mode talks straight to a TiDB Serverless database with no server to deploy, while Server mode self-hosts the Go binary in front of TiDB or Postgres and adds multi-agent space management and LLM-based conflict merging. The design principle is explicit — plugins stay thin because storage, search, ingest, and policy all live in the server.

Best for: Teams already inside the OpenClaw ecosystem wanting managed shared memory with minimal setup · Multi-agent orgs needing one memory layer across several coding-agent runtimes without writing a plugin per tool · Teams that want a hosted start with a genuine self-host exit ramp that does not require an API rewrite

Runs a fixed four-stage LangGraph pipeline per turn (working-memory manager, search coordinator, synthesizer, reasoning agent), with a background consolidator that extracts seven typed memory record kinds and fuses near-duplicates by embedding cosine into a hierarchical composite-record tree. It also runs a working-memory token-budget manager, a procedural skill store using HyDE retrieval, and an optional multimodal visual-memory store with an Ebbinghaus-style forgetting curve. Everything persists to an embedded SQLite and LanceDB pair with no external database server.

Best for: Solo developers and researchers wanting a lightweight, fully local Python memory service with fine-grained typed records · Teams already on OpenClaw, Claude Code, or Hermes wanting native plugin memory · Anyone who wants an embeddable memory library without standing up a graph or vector database server

A git-based differential memory backend: markdown files store the current 'now' state of knowledge while Git's commit graph preserves how facts evolved over time. A git-native retrieval agent explores the repository via sandboxed shell commands (`grep`, `git log`, `git diff`, `git blame`) to build targeted context — no vector database, no embeddings, no BM25, just git and an LLM. Ships as a small FastAPI service and is also importable as a Python library.

Best for: Builders of long-horizon conversational or personal-assistant agents who want human-readable, git-versioned memory without a vector store · Teams that value auditability and 'smart forgetting' via git history over embedding-based recall

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

A Flask REST API backed by two storage layers: FalkorDB holds memories as graph nodes connected by eleven authorable typed relationships plus three system-added edge types, while Qdrant holds a 1024-dimension embedding per memory. Recall blends semantic similarity, graph traversal, temporal alignment, tag overlap, and importance into a nine-component score, with multi-hop bridge discovery that surfaces the memory connecting two seed results rather than just the seeds themselves. Background enrichment and biologically-inspired consolidation cycles (daily decay, weekly creative linking, monthly clustering, optional forgetting) run continuously.

Best for: Solo developers and small teams wanting one shared memory across several coding-agent tools via MCP · Users who specifically want typed-relationship reasoning rather than similarity search alone · Teams comfortable running Docker or Railway infrastructure who value an honestly-benchmarked self-hosted backend

Local cognitive memory for MCP-compatible agents, shipped as a single ~25MB Rust binary with a 13-tool MCP server (consolidated from 34 tools in the v2.2.0 'Tool Consolidation' release — old names remain dispatchable as hidden back-compat aliases), 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, Retroactive Salience Backfill, 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

Three memory tiers: short-term (per-session conversation history with vector and text search), long-term (a POLE+O knowledge graph of People, Objects, Locations, Events, and Observations with entity resolution and deduplication), and reasoning (traces of agent tool use and decisions, retrievable for similar-task lookup). Multi-stage entity extraction via spaCy, GLiNER, or an LLM, plus relationship extraction with GLiREL and optional background enrichment from Wikipedia or Diffbot. Two independently versioned SDKs share one memory model and talk either directly to a self-hosted Neo4j over Bolt or to Neo4j's hosted memory service over REST, with cross-SDK behaviour enforced by a companion conformance suite.

Best for: Teams that want an actual queryable knowledge graph rather than vector recall as agent long-term memory · Multi-framework agent stacks needing one shared memory backend across LangChain, CrewAI, ADK, and others · Organizations already running Neo4j who want to reuse that operational expertise

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

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

Dual-mode memory infrastructure: Local mode stores an atomic disk snapshot plus append-only journal under ~/.retaindb with no external dependencies (no Postgres, Redis, or Qdrant). Server/Cloud mode uses PostgreSQL with pgvector. Both modes share the same retrieval pipeline: BM25 lexical search + vector similarity + knowledge-graph signals (updates/contradicts/supports/extends/derives relations), fused with RRF then reranked. Supports 12 typed memory categories with temporal validity (validFrom/validUntil), recall reinforcement (access counts + memory-strength decay), and token-budgeted delta compression for context packing.

Best for: Coding-agent workflows: single-machine persistent memory for Codex, Claude Code, or OpenCode via MCP or CLI, no cloud account required · Agents needing multi-modal recall — exact-string hits (codes, IDs, error strings) that semantic-only search misses, plus preference, correction, and decision memory across sessions · Product teams wanting a self-hosted or cloud memory API with per-user isolation, session ingestion, and knowledge-source connectors (GitHub, Notion, Slack, PDF, arXiv, npm/PyPI docs)

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 55 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 LangChain, CrewAI, Haystack, Pydantic AI, Google ADK (all on PyPI), plus source-only LangGraph and AutoGen adapters and a web dashboard. Renamed from Mimir (earlier Mneme) on 2026-07-08.

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

A local-first memory engine built on one Postgres store shared by every client — CLI, MCP, HTTP API, a browser viewer, and the raw Postgres wire. The same schema and the same SQL run across three tiers (embedded PGLite with no Docker, local Postgres, cloud Postgres), so moving tiers is a config swap. Its distinguishing bet is human-in-the-loop conflict handling: when a new memory contradicts an old one, memloom keeps both active and queues a conflict for you to resolve (keep new / keep existing / keep both / merge), and every resolution is reversible. Beliefs are versioned — restating or editing a fact appends a version sharing a root_id and stales the prior one, so history() shows how a fact changed.

Best for: One shared memory across several AI clients on your own machine (Claude Code, Claude Desktop, Cursor) without a hosted service or account · Cases where a silent overwrite is a liability and you want to review and revert what the agent decided to believe · Teams that want memory in plain Postgres they can query, audit, and back up with tools they already run · Mixing your own notes and PDFs into agent recall with citations back to the exact section and page