↓ Skip to main content
tomrochette.com
  1. Agents/
  2. Memory/

Memory Feature Matrix

Author
glm-5.3, glm-5.3-flash
History / Edit / PDF / EPUB / MD
Created: / Updated: / Status: finished / Readability: 3 / 35 minutes read (~6904 words)
agent-curated 572 agent-memory 19 ai-agents 19 comparison 24 fully-ai-generated 675 llm=glm-5.3 169 llm=glm-5.3-flash 582 memory 32
Table of Contents

This matrix compares the thirty-two memory approaches profiled in this section, feature by feature: the keyless session-memory server, the two file-rooted members (the file convention and the knowledge base that productizes it), the MCP-native markdown knowledge base, the session-compression plugin, the retroactive transcript-indexing binary, the session-mined personal working profile, the cross-model episodic memory engine, the markdown-canonical local runtime, the memory-first harness, the temporal local-first engine, the four memory APIs, the memory agent that manages the others, the graph-plus-SQL layer, the reversible-compression plugin, the self-hostable graph pipeline, the self-hostable memory OS, the agent-curated memory wiki, the portable memory format, the single-file frame format, the provenance-first personal brain, the learning-from-feedback engine, the cross-harness shared-engram engine, the screen-capture timeline, the belief-graph memory layer, the verbatim pull-only recall index that publishes to the Hub, the OKF-standard knowledge-bundle implementation, the context database, and the agent-maintained documentation brain.

For coding agents I would start with plain files and not buy any service on benchmark claims, because the only memory problem files cannot solve at any price is contradiction over time, and Zep is the only vendor whose architecture faces it head on.

Legend: ✓ supported, ✗ not supported, ~ partial or conditional, ? not verified. Each column links to the full research note; every cell below traces to a source cited there or in the references.

The matrix
#

Feature agentmemory Basic Memory Belief Context Graph Cabinet claude-mem Cognee deja Emulo Engrim EverOS File-based agent memory Funes GBrain Hindsight Letta LongMemory mem0 Memanto MemMachine Memoryfields MemOS memU Memvid MetaClaw OKF Agent Memory OpenViking Operator Memory PLUR Screenpipe Supermemory TencentDB Agent Memory Zep
Kind local memory server on a pinned iii engine, hooks plus MCP plus plugins, no hosted tier local MCP knowledge base, markdown files plus a derived knowledge graph, optional cloud belief-graph memory layer over agent trajectories, Python SDK plus optional HTTP service plus a Codex wrapper, local-first JSON artifacts, no hosted tier self-hosted knowledge base and scheduled agent team over markdown files local plugin, engine plus cloud OSS platform, library plus cloud local transcript-indexing recall binary, one Go program over the session files agents already write, no capture step local miner that turns the messages you typed to your coding agents into a personal you.md working profile, CLI plus skills plus one MCP tool, no server local engine, CLI plus hooks and MCP local-first memory runtime, markdown files canonical with SQLite and LanceDB indexes, optional managed cloud convention, no vendor verbatim session-memory index, one Rust binary with pull-only recall plus read-only MCP, optional publication as a Hugging Face dataset repo, no hosted tier personal memory daemon with a hosted team-workspace service beside it, markdown pages over your own database, MCP-served memory engine, OSS Postgres-backed server plus pay-as-you-go cloud platform, harness plus cloud self-hostable temporal memory engine, library plus CLI plus optional server hosted service, self-hostable memory-management agent over pluggable stores, CLI plus local server, cloud optional memory layer server, graph episodic plus SQL profile, self-hosted or free cloud account open file format, spec plus tooling memory OS platform, OSS engine plus harness plugins plus hosted cloud agent-curated memory wiki, hosted service plus self-hosted mode single-file memory engine, Rust core with SDKs and CLI meta-learning layer over OpenClaw-family assistants, skills plus scheduled RL OKF v0.2 knowledge-bundle implementation, zero-dependency Go binary plus stdio MCP server over a git-tracked knowledge/ directory context database, AGPL virtual filesystem for knowledge, memory, and skills harness-agnostic documentation brain, markdown partitions over your repos and home directory, npm helper plus lean per-harness adapter plugins, no hosted tier local-first shared-memory engine, npm CLI plus MCP server plus adapter plugins, one YAML store under every wired harness, optional git-remote team stores local screen-and-audio capture engine plus desktop app, memory as a recorded timeline hosted memory API plus MIT local binary OpenClaw and Hermes memory plugin, local-first with an optional Tencent Cloud backend hosted service, enterprise
Memory model captured session observations with confidence scores, lifecycle states, and a derived knowledge graph, BM25 recall keyless with optional local MiniLM embeddings markdown notes with observations and wikilinks forming a knowledge graph, semantic search with optional reranking belief and decision nodes with per-node confidence and confidence history, typed depends_on, supplements, and contradicts edges, evidence links to exact source offsets, merge history for duplicates markdown files and folders on disk, the knowledge base doubles as agent memory compressed observations, SQLite FTS5 plus optional vectors graph plus vector plus relational the raw transcripts are the memory: a local inverted index with incremental per-file state and credential redaction at index time, promoted notes outranking raw hits, optional embedding sidecar mined working profile: rules with dated verbatim quotes from your own messages in work, design, writing, and video layers, quotes machine-checked against the mined corpus by emulo verify curated episodic records, SQLite FTS5 plus model2vec vectors, 4,000-char boot pack markdown pages as the source of truth, user episodes and profiles plus agent cases and skills, a knowledge wiki, reflection merging episode clusters between sessions plain markdown files verbatim timestamped chunks in an append-only Lance dataset, no LLM in ingest, session-and-turn provenance on every row, one pinned embedding model per memory explicit markdown pages with sources, corrections and withdrawal, typed entity graph with no-LLM auto-linking world and experience facts, evidence-grounded observations with kept history, mental models and self-written knowledge pages editable memory blocks, learned immutable Hydrograph nodes with typed edges, provenance and hashes, separate recorded and valid time, four recall modes from strict to associative vector plus graph plus KV 13 typed categories (instruction, decision, preference, and more) with confidence and provenance, nightly consolidation, contradiction surfacing for review, policy-driven expiry with restore episodic conversational memory in a Neo4j graph, long-term profile facts in SQL, a short-term working set per session flat markdown pages plus optional SQLite vector index graph-backed unified memory, MemCube knowledge bases, multi-modal traces and skills, hybrid retrieval markdown wiki of distilled memory and skills the agent writes and retrieves itself append-only immutable Smart Frames in one .mv2 file (embedded WAL, Tantivy BM25, optional HNSW vectors, time index), the QR-in-video v1 deprecated incrementally extracted turns plus cross-session Contexture facts injected into prompts two layers, a 400-token push codex (AGENTS.md in the RFC-written Agent Action Grammar micro-syntax) plus a pull-layer OKF bundle of provenance-carrying knowledge objects with trust tiers and lifecycle metadata, searched by in-memory BM25 with progressive disclosure through index files viking:// virtual filesystem of resources, memories, and skills with L0-L2 generated summaries and directory-scoped search living documents, not captured memories: specs, decisions, standards, research, and lessons the working agent writes and rewrites at their source, routed each session by catalogs and read_if code indexes loaded deterministically plain-text YAML engrams (typed assertions with ACT-R activation decay, hierarchical scopes, do/don’t polarity, associations) plus timestamped episodes, recalled by local hybrid BM25 plus BGE embeddings with reciprocal rank fusion event-driven screenshots paired with accessibility-tree text (OCR fallback) plus local Whisper transcripts in SQLite FTS5, a DVR-style timeline agents query extracted facts, user profiles, and RAG chunks in one graph-backed store, contradictions resolved and stale facts expired short-term tool logs offloaded to files with a Mermaid state canvas recalled by node_id, long-term L0-L3 pyramid (conversation, atoms, scenarios, persona) in readable Markdown temporal knowledge graph
Self-host ✓ fully local Node server plus the pinned engine, file-backed state store, optional plain-Redis backend (no TLS on its client) ✓ fully local, notes on your disk, air-gapped friendly ✓ fully local, artifacts are JSON and JSONL on disk, the hybrid backend builds graphs with a local vLLM model, local embeddings, and a local classifier, the unified backend bills your own OpenAI-compatible endpoint ✓ free self-host, complete product locally ✓ fully local by default ✓ full engine, BYO backends ✓ fully local, one binary, no server, no account ✓ fully local stdlib-only Python, extraction through redaction and the profile on disk; a local model keeps the whole run local ✓ fully local, one SQLite file ✓ fully local Python runtime, no external database, cloud is the managed path ✓ no infra needed ✓ fully local single binary with local embeddings and reranker, Lance dataset on disk; the optional Hub layer is your own dataset repo, private by default ✓ runs locally on your hardware, DB, and keys, remote over Tailscale MCP ✓ Docker, Helm, or pip with an embedded PostgreSQL, cloud is the managed path ~ V1 server archived ✓ fully local in-process SQLite, or Docker server with dashboard and one-click templates ✓ OSS SDK and server ✓ fully local, Docker plus Ollama, no account or outbound calls ✓ Docker or pip against your own Neo4j and SQL databases ✓ fully local, it is just files ✓ docker compose with Neo4j and Qdrant, plus fully local SQLite plugins for OpenClaw, Hermes, and DeepSeek Harness ~ self-host is single-device with your own embedding key, the hosted tier is the multi-device path ✓ fully local, no server at all ✓ runs locally beside the wrapped harness ✓ fully local single binary, no database, no account, no runtime ✓ self-host server or one-click Railway, enterprise private deployment documented ✓ fully local markdown in three partitions (user, project private, project shared), git is the sync layer, no server at all ✓ fully local Node packages, the store is YAML on your disk, sync is your own git remote ✓ capture and storage local by default, desktop app or CLI, cloud paths optional ✓ local binary (MIT), same API as the platform; Scale adds a self-host option ✓ fully local SQLite plus sqlite-vec by default with your own model key, Tencent Cloud Vector Database optional ~ Graphiti engine only
Open source license ✓ Apache-2.0 ✓ AGPL-3.0, cloud proprietary ✓ MIT, whole engine ✓ MIT ✓ Apache-2.0 ✓ Apache-2.0, whole engine ✓ MIT ✓ MIT ✓ MIT, whole engine ✓ Apache-2.0 ~ memU Apache-2.0 ✓ Apache-2.0, whole binary ✓ MIT ✓ MIT ✓ Apache-2.0 ✓ Apache-2.0, n8n node MIT ✓ Apache-2.0 ✓ MIT ✓ Apache-2.0 ✓ AGPL-3.0 tool, MIT skill and spec ✓ Apache-2.0 ✓ Apache-2.0 ✓ Apache-2.0 ✓ MIT ✓ MIT, whole tool ✓ AGPL-3.0, restrictive for product embedding ✓ BSD-3-Clause, whole system ✓ Apache-2.0 (Enterprise tier unpriced) ~ source-available commercial license, free non-commercial, paid commercial ✓ MIT ~ MIT terms under a Tencent notice the GitHub detector cannot classify ~ Graphiti Apache-2.0
Contradiction and decay handling ~ confidence scores and lifecycle states on memories, no temporal validity or decay pass ~ observations and links accrue, no temporal model or contradiction pass ~ contradicts edges typed at construction and confidence propagates support or contradiction deterministically, no decay pass, and the project itself flags its probability semantics as not yet formally grounded ~ source history on operating views, no automated decay or contradiction pass ~ summaries and compaction ~ bi-temporal memory on Enterprise BYOC only ~ promoted notes carry accepted and rejected lifecycle states and hits report when the ground moved, no temporal validity model ~ re-mining rewrites the profile and a quote checker rejects invented receipts, no temporal validity or contradiction pass ~ manual supersede, merge resolution, opt-in prune ~ reflection refines profiles and skills offline, no documented temporal model or contradiction pass ✗ manual pruning ✗ append-only by design: obsolete passages stay and the reader judges at read time; a 30-day recency half-life reorders hits but nothing expires ~ corrections and withdrawal are first-class operations, no automated decay ~ observations refine with history kept and freshness-aware stale checks, no bi-temporal validity ~ sleep-time consolidation ✓ supersession and point-in-time truth in the open engine, deterministic opt-in decay ~ Dream, temporal retrieval ~ supersedes rather than appends and keeps what was believed and when, conflicts surfaced for review, expiry is policy-run ~ the working set ages out per session, no documented contradiction or decay pass ~ page status flags for outdated memories, no temporal model ~ natural-language memory feedback and correction, no bi-temporal validity ~ the agent patches or rewrites wiki pages at distill time, no automated contradiction handling ✗ append-only timeline, no contradiction or decay pass ~ support/query separation against stale rewards, no contradiction detector ~ trust tiers separate human-verified from agent-generated and lifecycle fields (status, stale_after) mark staleness, but invalidation is metadata discipline, not a temporal engine ~ memory subtree holds preferences and experience, no documented contradiction or decay pass ~ facts are rewritten in place when truth changes instead of appended, but enforcement is prompt discipline, no temporal model or contradiction pass ~ ACT-R decay fades stale engrams and feedback reweights injection, corrections via forget, no temporal validity model ✗ raw capture accrues, no contradiction model ~ documented auto-resolution and expiry, vendor-claimed ~ L1 extraction dedups and flags conflicts, no temporal validity model ✓ bi-temporal invalidation
Cross-user, cross-app memory ~ one shared server across your agents on one machine, multi-instance via data dirs, not a multi-user API ~ one user local, a Teams shared workspace in the cloud ~ one run’s or one project’s graph on one machine, artifacts are plain files, no multi-user API ~ one shared team workspace, not per-user or per-app memory APIs ✗ machine-local, cloud sync optional ✓ documented multi-user mode ~ one user’s machine-wide index shared across every wired agent, ssh sync between your own machines, not a multi-user API ✗ one person’s sessions on one machine ~ cross-CLI on one machine, merge for multi-machine, not cross-user ~ retrieval scoped by user, agent, app, project, and session ids locally, no server-side isolation product ✗ machine-local, per-repo ~ one host’s agents share one bound memory; cross-machine and team sharing through your own Hub dataset repo, not a multi-user API ~ one brain shared across your agents over MCP, company brains add source and operation grants ✓ banks per user or agent, fully isolated, team collaboration on cloud ~ agent-scoped persistence ✓ tenant, project, team, role, and agent scopes enforced server-side ✓ apps and thousands of users ~ one fleet estate with per-agent namespaces, not a multi-user API ~ org, project, user, agent, and session ids scope memory server-side, multi-tenant by design ~ corpus is transport-portable (S3, git, HTTP), single-corpus ✓ multi-cube knowledge bases with isolation and controlled sharing ~ one personal wiki across your own agents and devices, not a multi-user API ✗ single-user files; capsules are shareable artifacts, not a multi-user API ~ per-user and per-project context, scoped to the wrapped claws ~ one knowledge bundle per repo shared through git like code, no multi-user API ~ multi-user agents documented in prose, not a per-user memory API ~ the shared partition travels with the repo to every teammate and cloud agent, the user partition stays personal, no multi-user API ~ one store shared across every wired harness by design, team scopes sync through git remotes and Enterprise, no per-user API ~ per-device timelines, Business seat management without shared context ✓ hosted multi-user by design, tens of millions of end users claimed ~ per-user personas and per-session canvases on one machine, not a multi-user API ✓ millions of per-user graphs
Integration surface MCP (54 tools), REST, native plugins for Claude Code, Codex, Cursor, OpenClaw, Hermes, and pi, hooks for 20+ agents, skills, Python and Rust and Node clients MCP-native (Claude, Codex, Cursor, ChatGPT), Obsidian-compatible files Python SDK, optional HTTP streaming service, bundled reference terminal Agent, bcg codex wrapper for Codex, install script, uv web workspace, onboarding wizard, Drive, Gmail, Slack, Notion connectors hooks, MCP, skills, 10+ hosts Python/TS/Rust SDKs, MCP, HTTP, CLI one-tool MCP server, session-start and pre-tool hooks, a search skill, 42 agent CLIs wired by deja install, npm, Homebrew, Scoop, and winget installers pip CLI, Claude Code and Codex plugins with five skills, file installs for AGENTS.md, Cursor, Gemini, and OpenCode, one MCP tool (load_emulo_profile) hooks, MCP, CLI, skills, 7 agent CLIs REST API, Python library, plugins for OpenClaw, Hermes, and DeepSeek Harness, Dify support, built into the vendor’s Raven agent file conventions, native everywhere read-only MCP (recall, get, status), read tools and per-turn hooks for Claude Code, Codex, pi, and Hermes, community integrations for OpenCode and jcode, JSONL turns format, funes ask one-question CLI MCP over stdio or HTTP, Tailscale remote, guides for Grok Bot, Muse, Codex, Claude Code Python, TypeScript, and Go SDKs, REST, MCP server, 18 coding-agent CLIs SDK, CLI, cloud API npm library, CLI, HTTP, MCP (13 governed tools), dashboard, VS Code, session porter for six coding agents, n8n node API, MCP, CLI, skills CLI, REST, Python, TypeScript, and Go SDKs, MCP, web dashboard, connect commands for 13 coding CLIs, OKF export plus migrate-in from Mem0, Letta, Supermemory, Zep, and Hindsight Python and TypeScript SDKs, REST, MCP (stdio and HTTP), LangChain, LangGraph, CrewAI, LlamaIndex, AWS Strands, n8n, Dify, FastGPT, NVIDIA NeMo Agent Toolkit skill, CLI, any file transport REST API, Python SDK, MCP, plugins for OpenClaw, Hermes, and DeepSeek Harness record/inject host adapters for ChatGPT, Claude Code, Cursor, OpenClaw, Hermes, WorkBuddy Rust crate, npm SDK and CLI, PyPI SDK, MCP per the marketing site only CLI, OpenClaw extension, Tinker/MinT RL backends stdio MCP (okf_search, okf_show, okf_create, okf_validate), Go library and CLI, brew install, plain markdown everywhere else MCP, npm CLI, Python and Go SDKs, adapters for Claude Code, Codex, Cursor, Hermes, OpenCode adapter plugins for Claude Code, Codex, OpenCode V1/V2, Pi, DeepSeek Harness, and Kiro, npm helper, plain markdown everywhere else MCP server, CLI, adapter hooks plus plugins for Claude Code, Codex, Cursor, OpenCode, OpenClaw, Hermes, Antigravity CLI, and DeepSeek Harness, tools-only for Windsurf and Gemini CLI, Python SDK, npm packages MCP server, localhost REST, JS/TS SDK, markdown-defined pipes with YAML data permissions, skills for the major coding agents TS and Python SDKs, REST, hosted MCP, CLI plugins, skills OpenClaw plugin, Hermes provider and gateway (port 8420), npm tooling, tdai memory-search agent tools API, MCP, plugins
Audit trail ~ session replay and a queryable observation store, no provenance chain ~ markdown diffable in git, no provenance chain ~ every belief carries evidence offsets, confidence history, and merge history, and state replays from JSON and JSONL, no external audit log ~ document source history visible in the UI, no formal audit log ~ queryable observation store ? ~ every hit cites the session it came from and redactions are marked at index time, no formal provenance chain ~ every rule carries dated verbatim quotes with session ids that emulo verify re-checks against the corpus ~ origin-agent provenance and flight-recorder log ~ readable editable markdown and wiki pages, no formal provenance chain ~ git diffs only ~ every hit cites its session and turn with the passage as written, and get reassembles the full turn; no external audit log ~ every page carries its sources, corrections and withdrawal tracked ~ observations cite evidence with quotes and proof counts, reflect cites what it used ~ inspectable blocks ✓ immutable content with hashes, provenance, and traces ? ~ every belief carries confidence, source, and timestamp, expired memories stay recallable with the rule that retired them ~ memories carry uids and metadata, no documented provenance chain ~ readable pages, sha256-pinnable, no provenance ? ~ the wiki is readable markdown, no provenance chain ~ immutable frames with timestamps and checksums, timeline queries over past states ~ conversation transcripts persist, no audit log ~ git-native, every memory a diffable file with sources and code_refs, no external audit log ~ pages readable in Studio and via file tools, no formal provenance chain ~ ordinary markdown read and diffed through git, no provenance chain beyond git history ~ engrams are diffable YAML and episodes timestamped events, git history is the record, no provenance chain ~ the raw timeline is the audit record, and per-pipe permission enforcement is deterministic ? ~ every layer is a readable file with node_id and result_ref links back to raw logs ✓ fact-to-episode provenance
Pricing model free, Apache-2.0, no hosted tier, compression bills your own provider when enabled free AGPL local, Team $15/seat/mo, Business $30/seat/mo, custom agent tier free, MIT, no hosted tier; the unified backend bills your own model provider, the hybrid backend runs local models free self-host; Cloud Pro $20/mo and Max $49/mo waitlist, Cabinet AI from $10/mo free local, CMEM Pro $30/mo with a 30-day trial, Heavy $70/mo, Max $100/mo, TeamBrain $50/seat/mo self-serve OSS free, cloud $1.00 per 1M tokens plus $5 per workspace free, MIT, no hosted tier; the optional embedding sidecar bills your own endpoint free, MIT; one optional unpriced hand-edit service on the site free, MIT, no hosted tier free runtime, managed EverOS Cloud with no published price found free free, Apache-2.0, no hosted tier; the Hub dataset lives in your own account free, MIT daemon; hosted Personal $49/mo, Teams $199/mo with $100/mo AI credit free self-host (MIT), cloud pay-as-you-go on tokens (retain $10.00/1M, recall $0.75/1M, as of 2026-10-12) free BYOK, $20/mo, per-agent metering free, Apache-2.0, no hosted tier freemium, $19 to $249/mo free (MIT) local mode, free cloud key tier (100k operations), no published paid tier free OSS (Apache-2.0), free cloud account, enterprise version announced unpriced free free OSS and plugins, hosted Free $0, Starter $19 and Pro $286 both launch-free free, hosted beta plus Apache-2.0 self-host free, Apache-2.0, enterprise engagement unpriced free OSS; RL mode bills the Tinker or MinT training API free, MIT, no hosted tier free AGPL self-host, enterprise deployment contact free, BSD-3-Clause, no hosted tier free, Apache-2.0, local search costs nothing; Enterprise for team stores referenced with no published price freemium, Free $0, Basic $21/mo, Business $42/seat/mo, Enterprise custom credits (SM tokens), free tier, $19 to $399/mo free (Tencent MIT), local backend needs only your model key, Tencent Cloud Vector Database billed separately credits, $104/mo entry
Lock-in risk low-medium, Apache-2.0 local state, the pinned iii engine is the coupling low, plain markdown exits cleanly, the cloud sync is the proprietary layer low, MIT and plain JSON artifacts on disk, the coupling is the graph-construction prompt pipeline low, files on disk with a documented export path low-medium, SQLite local, cloud optional low, engine is portable low, the index is a rebuildable cache over transcripts you already own; the coupling is the 42-parser registry none, plain markdown you own and a re-runnable miner low, plain SQLite file, bus factor one low-medium, markdown and Apache-2.0 exit cleanly, the cloud and Raven integrations are the vendor path none, plain text low, Apache-2.0 binary over a rebuildable derived dataset with the transcripts as source of truth; the couplings are the turns format and the per-memory embedding model low for the MIT daemon, markdown pages on your own database, MCP exit; the hosted workspace is the vendor path low-medium, MIT engine and a PostgreSQL you own, cloud metering is the paid path medium, pivot churn low, SQLite files and Apache-2.0; the risk is the project’s age medium, paid-only brain low, OKF markdown export plus one-command migrate-in from five rivals low-medium, Apache-2.0 server on your own databases, the cloud path is the vendor’s none, plain text zip medium, local plugins are portable SQLite, the graph core wants Neo4j and Qdrant operations low-medium, the wiki is markdown, but the hosted service is the only multi-device path today low-medium, the .mv2 format is a single-vendor spec moderate, value concentrated in the wrapper, harnesses run without it low, MIT over a published spec, the coupling is OKF v0.2 itself and the bundle conventions medium, AGPL core with a proprietary enterprise path, viking:// URIs are the interface none-low, plain markdown and git, the coupling is the catalog and index conventions low, plain YAML against an open versioned spec exits cleanly, adapters are re-creatable; the Enterprise team-store path is the proprietary layer medium, local SQLite data but a proprietary-source app and format medium, MIT local binary and same-API exit, proprietary metering medium, files and SQLite exit cleanly, the compression patch and the cloud backend are the Tencent paths high, managed engine core

Reading the matrix
#

The Kind row is really an architecture row: the non-convention members each put memory in a different place, beside the agent as a plugin (claude-mem) or a cross-model engine (Engrim), inside the harness (Letta), beside it as an API (Mem0 or Supermemory), or under it as governed infrastructure (Zep), or over the whole machine as one shared server (agentmemory) or under every wired harness as one shared YAML store (PLUR) or as one append-only verbatim log the agents query only when they ask (Funes), deja skips the capture step by indexing the transcripts the harnesses already wrote, while Screenpipe records the screen itself, Memvid freezes memory into one file, LongMemory governs it in SQLite, EverOS keeps it in markdown files with indexes beside them, and the convention puts it in your repo, which Operator Memory productizes as an agent-maintained documentation brain and OKF Agent Memory formalizes as a knowledge bundle on Google’s published OKF format. That placement decision drives every other row, from integration surface to lock-in. Basic Memory and memU stay on the repo side of that line and add a layer on top, a graph-and-search view or a cross-agent wiki, which is why their lock-in cells read low. Memoryfields is the extremum on the same axis: it removes the architecture entirely by shipping memory as a spec’d data format, which is why its row is the cheapest and the thinnest at once.

The contradiction row is the only one with a clean winner, and it is the row I would weight most. Zep’s bi-temporal invalidation marks old facts invalid instead of overwriting them; Mem0’s April 2026 rewrite added entity linking and temporal retrieval, a convergence its own note reads as Zep validating the architecture first; Supermemory claims automatic resolution and expiry, but at README level, and the one independent run I found scored it below plain BM25 on LoCoMo at a matched budget; MemOS corrects through natural-language feedback rather than validity windows; Letta consolidates at sleep time; files just rot, and conflicting rules get resolved arbitrarily.

The file column wins every row it appears in on price, and loses exactly two: cross-user memory and audit. Auto memory is machine-local and per-repository, so the moment memory must follow users across apps and machines, the free option drops out, which is the precise boundary where the services earn their keep. Engrim is the second zero-cost column, and it loses the same two rows (audit partial, cross-user absent), which makes the free local options the natural set for personal memory; deja joins as the third, trading a capture step for retroactive indexing of what the harnesses already wrote, PLUR as the fourth, one YAML store that every wired harness itself reads and writes, and Funes as the fifth, a verbatim recall index the agents query only when they choose to. Operator Memory and OKF Agent Memory are free the same way, markdown brains over your own git with no hosted tier at all. Basic Memory and memU join the cheap-and-local side with working multi-file servers and adapters, but their cross-user stories are one user with a cloud add-on.

Open source here does not mean what the license row suggests, and the self-host row is the correction. Letta’s 25.0k-star repo is a landing page with the V1 server archived unsupported; Zep’s self-hostable Community Edition is discontinued and only the Graphiti engine remains open; Mem0’s benchmarked brain is the paid platform while the OSS SDK is directionally weaker. Cognee and Engrim are the exceptions the row now proves: Cognee’s entire engine is Apache-2.0 with no paid-only core, and Engrim is MIT over a plain SQLite file, which is why their lock-in cells are the only lows among the services, with Basic Memory’s markdown-local design reading the same way under an AGPL license. The only column with no gap between what is open and what runs is the convention, because there is nothing to close.

Pricing spreads from zero to $104/month at entry, and the hosted services now bracket each other from both ends: Basic Memory’s cloud is the cheapest first paid tier at $15, Mem0 and Supermemory both start at $19, claude-mem’s restructured ladder begins at $30, GBrain’s hosted Personal plan at $49, and Zep at $104, roughly a 7x gap between cheapest and priciest first paid tier, and what the premium buys is governance (provenance, access control, compliance), not memory quality. Supermemory meters every layer in its own SM tokens; Mem0’s $19 Starter undercuts the hosted field at the low end; Zep’s credit metering prices the audit trail, not the tokens; MemOS now lists $19 and $286 tiers and runs both free during the launch promo, and Hindsight Cloud meters tokens with no fixed monthly fee.

Choosing from the matrix
#

  • Coding agent in one repo, one machine: write the AGENTS.md/CLAUDE.md pair, prune monthly, pay nothing.
  • User-facing personalization across apps and thousands of users: Mem0, accepting a managed dependency.
  • The same job with the engine runnable on your own disk and benchmark tooling included: Supermemory, after running its MemoryBench on your own workload.
  • Facts change over time (preferences, roles, prices) and “why did the agent say that” needs an auditable answer: Zep.
  • Always-on agents that must accumulate a self, or you want to hack on where memory is going: Letta, or steal its memory-block and sleep-time patterns into a harness you already run.
  • Must self-host everything: Cognee (the whole engine runs on your backends), files, or Mem0 OSS, or Graphiti plus your own graph database if you can operate one.
  • Memory across many users with flat billing instead of seats or credits: Cognee Cloud at $1.00 per 1M tokens processed.
  • Solo builder on no budget: files, full stop; Zep’s own note says the graph stack is heavy at small scale.
  • One server shared by every coding agent you run, working before you configure any provider: agentmemory, rerunning its eval harness on your own sessions first.
  • OpenClaw or Hermes agents that burn tokens on tool logs and need the trail kept: TencentDB Agent Memory, after rerunning its vendor benchmark table on your own sessions.
  • Recall of what every agent on this machine already fixed, with no capture step to run: deja, one MIT binary over the transcripts on disk, after rerunning its benchmark scripts on your own history.
  • A mined first draft of your own unwritten rules, receipts attached: Emulo, after reading its published 0-for-9 placebo page and running emulo verify on the result.
  • A markdown-canonical local runtime with separate user and agent tracks for OpenClaw, Hermes, or DeepSeek Harness: EverOS, accepting a young, vendor-led dependency.
  • One developer, multiple agent CLIs, one repo: Engrim, the only column that keeps one provenance-tagged store every CLI reads.
  • Markdown notes in the Obsidian style that your agent grows into a knowledge graph through MCP: Basic Memory, free locally, $15/seat/mo for cloud sync.
  • A research-grade belief layer scoring every memory with confidence and contradiction edges: Belief Context Graph, accepting zero releases and self-published benchmarks.
  • Memory and skills that follow you across ChatGPT, Claude Code, and Cursor: memU, the wiki the agents curate themselves.
  • Benchmark-first buyers who want receipts: Hindsight, the only member publishing per-run benchmark artifacts alongside named outside reproducers.
  • Product agents on LangGraph or CrewAI stacks that want OSS episodic plus profile memory on their own databases: MemMachine, after running your own evaluation, since it publishes none.
  • A fleet whose memory needs managing, not just storing (contradictions, expiry, pre-task briefs): Memanto, accepting a young vendor-led manager.
  • One correctable brain across your own agents: GBrain, MIT and self-hosted, with sources on every page.
  • A filesystem store for knowledge, memory, and skills together: OpenViking, accepting AGPL.
  • One memory shared across Claude Code, Codex, Cursor, and OpenCode on one machine, in files you can read and git: PLUR, after running plur-bench on your own corpus before trusting the benchmark claims.
  • Auditable recall of what was actually said across Claude Code, Codex, pi, and Hermes, publishable as a Hub dataset you own: Funes, after measuring with the recency half-life off, since the project’s own A/B runs found its retrieval extras buy cost and not recall.
  • OpenClaw, Hermes, or DeepSeek Harness agents with a local-first memory that can scale to a shared graph: MemOS.
  • Memory that must follow you across machines and apps without a vendor: Memoryfields, with the caveat that the spec is a draft and its contradiction handling is a status flag rather than a temporal model.
  • An offline single-file memory archive with working indexes: Memvid, after verifying its benchmark claims on your own corpus, and with the quiet-train caution attached.
  • Temporal and governed memory you administer yourself: LongMemory, the only open engine here with point-in-time truth, accepting a young dependency.
  • Agents that should know what you did on this machine, with a capture-everything budget and a paid license for work: Screenpipe.
  • Documentation as the memory, maintained by the harness you already run: Operator Memory, reading its comparison doc first, since the project rejects benchmarks outright and offers prose instead.
  • Memory on a published standard format rather than a vendor’s store: OKF Agent Memory, accepting that every published number is latency-side and self-measured.

Changes
#

  • 2026-08-24 - Created with four columns and rows adapted to memory (memory model and lock-in).
  • 2026-08-26 - Extended from four to five columns with Cognee, marking unverified contradiction and audit cells.
  • 2026-08-30 - Added the claude-mem column, reaching six, and updated the architecture-row prose.
  • 2026-09-04 - Extended from six to seven columns with Memoryfields and extended the reading and choosing sections.
  • 2026-09-10 - Extended from seven to eight columns with Engrim.
  • 2026-09-16 - Engrim’s integration cell moved to six agent CLIs with the OpenCode addition, and Memoryfields’ contradiction cell moved from not supported to partial with the spec’s new page status flags.
  • 2026-09-22 - Engrim’s integration cell moved to seven agent CLIs with the GitHub Copilot CLI adapter (v1.4.9).
  • 2026-09-24 - Renamed the Files column to its listing title, File-based agent memory, and the Mem0 column to mem0, matching the section index listing; no cells moved.
  • 2026-09-24 - Removed the verification preamble line on owner request.
  • 2026-10-02 - Extended from eight to ten columns with Cabinet (the markdown-file knowledge base with a scheduled agent team) and MetaClaw (the meta-learning layer over OpenClaw-family assistants), inserted in sorted position, traced both columns to the new notes, and updated the intro count and list.
  • 2026-10-03 - Moved the MetaClaw column to its case-insensitive sorted position between Memoryfields and Zep (the 2026-10-02 insert had placed it after Cabinet); no cell values moved, and the Engrim reference’s star figure was refreshed.
  • 2026-10-04 - Extended from ten to eleven columns with Supermemory (the benchmark-forward memory API with an MIT local binary), inserted in sorted position between MetaClaw and Zep and traced to the new note; the intro, reading, and choosing sections updated for the third hosted column.
  • 2026-10-06 - Extended from eleven to fourteen columns with Basic Memory (the AGPL MCP markdown knowledge graph), MemOS (the memory OS with OpenClaw, Hermes, and DeepSeek Harness plugins), and memU (the cross-agent memory wiki), inserted in case-insensitive sorted position and traced to the new notes; claude-mem’s pricing cell moved to the restructured CMEM ladder ($30/$70/$100, team pilot unpriced); the intro, reading, and choosing sections updated.
  • 2026-10-07 - Extended from fourteen to seventeen columns with GBrain (the MIT personal brain daemon), Hindsight (Vectorize’s learning memory engine), and OpenViking (ByteDance’s AGPL context database), inserted in case-insensitive sorted position and traced to the new notes; Basic Memory’s pricing cell moved to the per-seat Team/Business ladder, claude-mem’s integration cell moved to 10+ hosts with its pricing cell gaining the 30-day trial, and MemOS’s pricing cell moved to the published launch-promo tiers; the intro, reading, and choosing sections updated.
  • 2026-10-07 - Reworded the Basic Memory choosing bullet’s “Obsidian-shaped” compound to “in the Obsidian style” to keep the banned-terms rule.
  • 2026-10-08 - Extended from seventeen to twenty columns with LongMemory (CaviraOSS’s Apache-2.0 temporal local-first engine), Memvid (the single-file .mv2 memory engine, v1 QR approach deprecated), and Screenpipe (Negentropy Labs’ source-available screen-and-audio capture timeline), inserted in case-insensitive sorted position and traced to the new notes; the intro, Kind-row prose, and choosing section updated.
  • 2026-10-09 - Extended from twenty to twenty-two columns with agentmemory (the keyless session-memory server on a pinned iii engine) and EverOS (EverMind’s markdown-canonical local-first runtime), inserted in case-insensitive sorted position and traced to the new notes; the intro, architecture-row prose, and choosing section updated.
  • 2026-10-10 - Extended from twenty-two to twenty-three columns with deja (vshulcz’s MIT transcript-indexing recall binary over the session files 41 agents already write), inserted in case-insensitive sorted position between Cognee and Engrim and traced to the new note; the intro, architecture-row prose, the free-local-columns sentence, and the choosing section updated.
  • 2026-10-11 - Extended from twenty-three to twenty-six columns with Memanto (the MIT memory agent that manages rather than stores), MemMachine (the MemVerge-incubated graph-plus-SQL memory layer), and TencentDB Agent Memory (Tencent’s MIT OpenClaw and Hermes plugin built on reversible compression), inserted in case-insensitive sorted position and traced to the new notes; the intro and choosing sections updated.
  • 2026-10-11 - Extended from twenty-six to twenty-seven columns with Emulo (ohad6k’s MIT session miner that compiles the messages you typed into a you.md working profile with dated receipts), inserted in case-insensitive sorted position between deja and Engrim and traced to the new note; the intro and choosing sections updated, and the Emulo references added.
  • 2026-10-12 - Moved the Hindsight pricing cell from the retired $5 signup credit line to the pay-as-you-go rates the pricing page published this run (retain $10.00/1M, recall $0.75/1M), matching the note’s new Price history row.
  • 2026-10-14 - Extended from twenty-seven to twenty-eight columns with PLUR (plur-ai’s cross-harness shared-memory engine over plain-text YAML engrams), inserted in case-insensitive sorted position between OpenViking and Screenpipe and traced to the new note; the intro, architecture prose, the free-local sentence, and the choosing section updated.
  • 2026-10-16 - Extended from twenty-eight to twenty-nine columns with Belief Context Graph (BIGAI NLCO’s MIT belief-graph memory layer over agent trajectories, with computed confidence and typed contradiction edges), inserted in case-insensitive sorted position between Basic Memory and Cabinet and traced to the new note; the intro and choosing section updated.
  • 2026-10-16 - Extended from twenty-nine to thirty columns with Funes (Hugging Face’s Apache-2.0 verbatim session-memory index with pull-only recall and optional Hub publication), inserted in case-insensitive sorted position between File-based agent memory and GBrain and traced to the new note; the intro, architecture prose, the free-local sentence, and the choosing section updated.
  • 2026-10-17 - Extended from thirty to thirty-two columns with OKF Agent Memory (the MIT Go implementation of Google’s OKF v0.2 with in-memory BM25, progressive disclosure, and a built-in MCP server) and Operator Memory (the BSD-3-Clause harness-agnostic documentation brain), inserted in case-insensitive sorted position between MetaClaw and OpenViking and between OpenViking and PLUR respectively and traced to the new notes; the intro, architecture prose, the free-local sentence, and the choosing section updated.
  • 2026-10-18 - deja’s integration and lock-in cells moved to the 42-harness count shipped by v0.22.2 (Windsurf and Devin Desktop transcripts now read), and claude-mem’s pricing cell gained the TeamBrain $50/seat/mo self-serve tier announced in v14.0.0, both traced to the notes’ updates and Price history rows.
  • 2026-10-20 - GBrain’s Kind, pricing, and lock-in cells moved to record the hosted gbrain.io workspaces the README now fronts (Personal $49/mo, Teams $199/mo), traced to the note’s new Price history baseline, and the pricing-spread paragraph gained the $49 entry.

See also
#

References
#