Memory as plain files on disk — readable, editable, version-controllable.
Memory lives as plain files — usually Markdown — that the agent reads and writes directly on disk. There is no database or embedding service; the agent treats memory the way it treats any other file it can open and edit. This keeps memory human-readable, git-friendly, and cheap, at the cost of scale and automatic semantic search. Some members add tiered context (L0→L2 loading) for token savings, or pre-compression capture hooks that grab decisions before a long session is summarized away.
Transparency, editability, and zero-infra. When those outrank automatic intelligence — which, for a curated knowledge worker, is more often than the vendor pitches admit — this family wins. It is also the only family with no LLM in the read path on several members, which makes it the home for latency-critical (voice) and exact-token-recall (coding agent) needs that semantic search actively fails. The trade-off is that you trade automatic richness for control: you get out roughly what you curate.
11 catalogued.
Volcengine
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
View memory card →ByteRover
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
View memory card →NevaMind AI
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
View memory card →EverMind AI
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
View memory card →AgentScope AI (Alibaba)
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
View memory card →Basic Machines
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
View memory card →Zilliz (Milvus)
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
View memory card →AkitaOnRails (Fabio Akita)
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
View memory card →Growth Kinetics
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
View memory card →Garry Tan
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
View memory card →memodb-io
A skill memory layer that watches agent sessions, waits for a task to complete or fail, runs an LLM distillation pass, and writes the result as agent-skill-format Markdown files rather than embedded facts. Retrieval is tool-driven progressive disclosure (list_skills / get_skill / get_skill_file) reasoned about by the agent, not semantic similarity search. Skills export as a ZIP for reuse across frameworks. Backend is FastAPI over Postgres, S3, Redis, and RabbitMQ, reachable by REST from Python and TypeScript SDKs or a web dashboard.
Best for: Coding agents that should learn from mistakes and reuse debugged procedures as inspectable files · Teams wanting memory that is auditable and git-diffable rather than an opaque embedding store · Multi-framework shops wanting portable, no-lock-in skill files
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: Lots of data, tight budget.
Pick
Memori — Drops the vector DB and runs on SQL + LLM extraction — ~80–90% cheaper infra than vector-backed stores.
Runner-ups
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Binding constraint: Supersession. The hard part isn't storing state, it's making sure last month's status never resurfaces as current.
Pick
Hand-curation is the honest default — you own supersession by editing the living doc yourself.
A curated LLM wiki (Obsidian/PARA-style) is the correct architecture here, because you curate and overwrite the living document. A memory product only wins when one of the runners-up's unique property becomes the pain.
Runner-ups
Why not Cognee here: it accumulates a corpus but is weaker at 'this new fact replaces that old one.' Supersession is Zep's lane.
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Binding constraint: Exact-token recall (function names, error codes, variable names — semantic search fails here) + capturing decisions before a long session is compacted.
Pick
ByteRover — The pre-compression hook grabs 'we decided X / Y didn't work' before the context window summarizes it away, and markdown lives next to code in git.
Runner-ups
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-01
Binding constraint: Retrieval can't stall a live conversation.
Pick
ByteRover — Cache/FTS primary read path is LLM-free and sub-100ms; the LLM is a last-resort fallback only (and can be kept local).
Runner-ups
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-25
Binding constraint: No network, no third party, ideally no LLM call at all.
Pick
ByteRover — Local markdown; the cache/FTS primary read path is LLM-free and sub-100ms, with the LLM only as a last-resort fallback (keepable local) — nothing leaves the device.
Runner-ups
From Agentic Memory: Use-Case Playbook 2026 · last verified 2026-07-25
Last verified 2026-06-28 · updated by manual-stub