A memory toolkit you import and wire into your own agent stack.
A memory toolkit you import and wire into your own agent stack, keeping control of where data lives. You call its APIs to store and recall; it does not impose a runtime or a hosting model. Storage and retrieval are yours to deploy, which is the main trade-off versus a managed offering. The standout capability here is procedural memory — learning how to do a recurring task and rewriting the agent's own prompts or behavior from past episodic successes.
Control and procedural learning. Unlike managed-extract-retrieve (which owns the pipeline) or agent-runtime (which owns the whole agent), this family hands you the memory primitives and gets out of the way. That makes it the only home for procedural memory — getting better at a recurring task by learning from past wins and rewriting behavior — which is a different thing entirely from remembering facts. The trade-off is that you own deployment and integration.
11 catalogued.
LangChain
Procedural memory — learns how to do tasks and rewrites the agent's own behavior/prompts.
Best for: Teams already on LangChain/LangGraph
View memory card →AGI Research (Rutgers)
An agentic memory library that structures memories dynamically using Zettelkasten principles: each new memory becomes a note with generated context, keywords, and tags, then is linked to related notes — and adding memories can trigger evolution of existing ones. Published at NeurIPS 2025.
Best for: Agents needing adaptive, self-linking long-term memory without fixed memory ops
View memory card →thedotmack
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
View memory card →rohitg00
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
View memory card →Gentleman Programming
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
View memory card →MemPalace
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
View memory card →Memvid
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
View memory card →samvallad33
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
View memory card →taOS
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
View memory card →Perseus Computing
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
View memory card →Redis, Inc.
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
View memory card →Top-down recommendations from the use-case playbook. Each names the one binding constraint that picks the tool, the primary pick (which may sit in another family when the case spans more than one), and runner-ups.
Binding constraint: Procedural learning — get better at a recurring task, update behavior from past wins.
Pick
LangMem — The only one with explicit procedural memory + prompt optimization from episodic successes (native if you're on LangGraph).
Runner-up
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-06-28
Last verified 2026-06-28 · updated by manual-stub