↓ 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 / 17 minutes read (~3232 words)
agent-curated 406 agent-memory 11 ai-agents 18 comparison 24 fully-ai-generated 508 llm=glm-5.3 170 llm=glm-5.3-flash 417 memory 16
Table of Contents

This matrix compares the seventeen memory approaches profiled in this section, feature by feature: 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 cross-model episodic memory engine, the memory-first harness, the four memory APIs, the self-hostable graph pipeline, the self-hostable memory OS, the agent-curated memory wiki, the portable memory format, the provenance-first personal brain, the learning-from-feedback engine, and the context database.

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 Basic Memory Cabinet claude-mem Cognee Engrim File-based agent memory GBrain Hindsight Letta mem0 Memoryfields MemOS memU MetaClaw OpenViking Supermemory Zep
Kind local MCP knowledge base, markdown files plus a derived knowledge graph, optional cloud self-hosted knowledge base and scheduled agent team over markdown files local plugin, engine plus cloud OSS platform, library plus cloud local engine, CLI plus hooks and MCP convention, no vendor personal memory daemon, markdown pages over your own database, MCP-served memory engine, OSS Postgres-backed server plus pay-as-you-go cloud platform, harness plus cloud hosted service, self-hostable 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 meta-learning layer over OpenClaw-family assistants, skills plus scheduled RL context database, AGPL virtual filesystem for knowledge, memory, and skills hosted memory API plus MIT local binary hosted service, enterprise
Memory model markdown notes with observations and wikilinks forming a knowledge graph, semantic search with optional reranking 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 curated episodic records, SQLite FTS5 plus model2vec vectors, 4,000-char boot pack plain markdown files 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 vector plus graph plus KV 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 incrementally extracted turns plus cross-session Contexture facts injected into prompts viking:// virtual filesystem of resources, memories, and skills with L0-L2 generated summaries and directory-scoped search extracted facts, user profiles, and RAG chunks in one graph-backed store, contradictions resolved and stale facts expired temporal knowledge graph
Self-host ✓ fully local, notes on your disk, air-gapped friendly ✓ free self-host, complete product locally ✓ fully local by default ✓ full engine, BYO backends ✓ fully local, one SQLite file ✓ no infra needed ✓ 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 ✓ OSS SDK and server ✓ 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 ✓ runs locally beside the wrapped harness ✓ self-host server or one-click Railway, enterprise private deployment documented ✓ local binary (MIT), same API as the platform; Scale adds a self-host option ~ Graphiti engine only
Open source license ✓ AGPL-3.0, cloud proprietary ✓ MIT ✓ Apache-2.0 ✓ Apache-2.0, whole engine ✓ MIT, whole engine ~ memU Apache-2.0 ✓ MIT ✓ MIT ✓ Apache-2.0 ✓ Apache-2.0 ✓ AGPL-3.0 tool, MIT skill and spec ✓ Apache-2.0 ✓ Apache-2.0 ✓ MIT ✓ AGPL-3.0, restrictive for product embedding ✓ MIT ~ Graphiti Apache-2.0
Contradiction and decay handling ~ observations and links accrue, no temporal model or contradiction pass ~ source history on operating views, no automated decay or contradiction pass ~ summaries and compaction ~ bi-temporal memory on Enterprise BYOC only ~ manual supersede, merge resolution, opt-in prune ✗ manual pruning ~ 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 ~ Dream, temporal retrieval ~ 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 ~ support/query separation against stale rewards, no contradiction detector ~ memory subtree holds preferences and experience, no documented contradiction or decay pass ~ documented auto-resolution and expiry, vendor-claimed ✓ bi-temporal invalidation
Cross-user, cross-app memory ~ one user local, a Teams shared workspace in the cloud ~ one shared team workspace, not per-user or per-app memory APIs ✗ machine-local, cloud sync optional ✓ documented multi-user mode ~ cross-CLI on one machine, merge for multi-machine, not cross-user ✗ machine-local, per-repo ~ 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 ✓ apps and thousands of users ~ 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 ~ per-user and per-project context, scoped to the wrapped claws ~ multi-user agents documented in prose, not a per-user memory API ✓ hosted multi-user by design, tens of millions of end users claimed ✓ millions of per-user graphs
Integration surface MCP-native (Claude, Codex, Cursor, ChatGPT), Obsidian-compatible files web workspace, onboarding wizard, Drive, Gmail, Slack, Notion connectors hooks, MCP, skills, 10+ hosts Python/TS/Rust SDKs, MCP, HTTP, CLI hooks, MCP, CLI, skills, 7 agent CLIs file conventions, native everywhere 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 API, MCP, CLI, skills 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 CLI, OpenClaw extension, Tinker/MinT RL backends MCP, npm CLI, Python and Go SDKs, adapters for Claude Code, Codex, Cursor, Hermes, OpenCode TS and Python SDKs, REST, hosted MCP, CLI plugins, skills API, MCP, plugins
Audit trail ~ markdown diffable in git, no provenance chain ~ document source history visible in the UI, no formal audit log ~ queryable observation store ? ~ origin-agent provenance and flight-recorder log ~ git diffs only ~ every page carries its sources, corrections and withdrawal tracked ~ observations cite evidence with quotes and proof counts, reflect cites what it used ~ inspectable blocks ? ~ readable pages, sha256-pinnable, no provenance ? ~ the wiki is readable markdown, no provenance chain ~ conversation transcripts persist, no audit log ~ pages readable in Studio and via file tools, no formal provenance chain ? ✓ fact-to-episode provenance
Pricing model free AGPL local, Team $15/seat/mo, Business $30/seat/mo, custom agent tier 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 OSS free, cloud $1.00 per 1M tokens plus $5 per workspace free, MIT, no hosted tier free free, MIT, your infrastructure and provider keys free self-host (MIT), cloud pay-as-you-go on tokens, $5 signup credit free BYOK, $20/mo, per-agent metering freemium, $19 to $249/mo 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 OSS; RL mode bills the Tinker or MinT training API free AGPL self-host, enterprise deployment contact credits (SM tokens), free tier, $19 to $399/mo credits, $104/mo entry
Lock-in risk low, plain markdown exits cleanly, the cloud sync is the proprietary layer low, files on disk with a documented export path low-medium, SQLite local, cloud optional low, engine is portable low, plain SQLite file, bus factor one none, plain text low, markdown pages on your own database, MCP exit low-medium, MIT engine and a PostgreSQL you own, cloud metering is the paid path medium, pivot churn medium, paid-only brain 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 moderate, value concentrated in the wrapper, harnesses run without it medium, AGPL core with a proprietary enterprise path, viking:// URIs are the interface medium, MIT local binary and same-API exit, proprietary metering 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), and the convention puts it in your repo. 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 two free local options the natural pair for personal memory. 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, 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 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.
  • 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.
  • 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.
  • 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.

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.

See also
#

References
#