Every tool on this page makes the same promise: your AI remembers. The taglines will not help you choose, because they all read alike (“never forget”, “your second brain”, “local-first”) while the machinery underneath points in opposite directions.
Three questions do the sorting: whether you can open your memory and read it, what you keep if the vendor moves on, and who decides what gets remembered. Each has a plain answer per tool and a consequence you live with. imprnt is one set of answers. Where your answers differ, this page routes you to the tool that fits, by name.
Most AI-memory tools store what they learn as a vector index: your words converted into long lists of numbers so a model can find text with similar meaning. That is a real technique with real strengths and one hard limit: a person cannot read it. If the store holds a wrong fact about you, there is no line to find and fix.
The other camp keeps memory as notes: plain Markdown text files on your disk, openable and editable like any document. The AI searches the same files you do.
A vector index, a knowledge graph, or an encrypted blob. Capture is automatic, scraped from your chat turns. You almost never open the raw store, and would learn little if you did.
most of the funded field
Plain Markdown you read, edit, grep, and graph in Obsidian with none of the tooling running. The AI reads it too, but the file is the thing and you are the first reader.
the smaller corner, where imprnt lives
That split decides everything downstream: whether you can audit what was stored, whether the memory survives the tool being uninstalled, and whether a wrong fact is a line you fix or an opaque vector you cannot find.
The same choice decides the next question in advance, because a store you cannot read is a store you cannot take with you.
In March 2026 a notes app called Reor was archived by its owner, after about a year without updates. Its users kept their notes, because the notes were plain Markdown files on their own disks. They lost the search and the map of related notes, because both lived in an index only the app could read.
Direction changes like that are normal in a young field, and you do not have to guess how they go. Here is the record of the last eighteen months across this page’s own table, each item taken from the vendor’s own repo or announcement:
what happened Retired memory search, session summaries, and document collections, weeks after deprecating the self-hostable Community Edition ("no longer supported").
what users keep A graph-database dump that needs Graphiti or a custom reader to interpret.
what happened Archived by its owner after roughly a year without updates. No successor named.
what users keep The Markdown survives. The semantic search and the related-notes map lived in the app's index and go with it.
what happened Khoj Cloud sunset on April 15. The team moved to two new products, Pipali and Open Paper, and the repo coasts.
what users keep The hosted service is gone. Self-hosters keep a server and a Postgres database to run themselves.
what happened OpenMemory, the local-first memory server it launched in May 2025, "is being sunset" per its own README, pointing users at the self-hosted server instead.
what users keep The local option retires. Its memories sit in a vector store and Postgres that only mem0's own stack reads.
what happened Mid-move from plain files to a SQLite database that makes Markdown an export. The beta README warns "data loss is possible". The newest stable release is dated 2025-12-01.
what users keep File-version users keep plain Markdown, for as long as they stay on the old version.
what happened Announced its "next phase": server memory tools removed "in favor of straightforward filesystem operations" over Markdown files tracked in git.
what users keep The one move toward files. A memory company rebuilding its flagship around the format users get to keep.
All of these were defensible business calls. The question to ask a memory tool up front is what you keep when its vendor makes one. The pattern in the ledger: users keep whatever was plain files and lose whatever lived in the tool’s own store.
One row points the other way, and it is the strongest evidence on the page because it comes from the other camp. Letta, a memory company, ran a benchmark where plain files scored 74.0%, ahead of both its own specialized memory tools and mem0’s best variant at 68.5%. The numbers are vendor-run, and they were published against the vendor’s own prior product, which is the rare direction that earns trust. Letta is now rebuilding its flagship around Markdown files tracked in git, the same version-history tool developers use for code.
iai earns a fair mention here. It is local, open source, and upfront about its design, and everything it stores lives in an encrypted database. Apply the same test and the answer is blunt: if iai vanishes, you keep an encrypted blob and a key.
The field’s default is ambient capture: hooks that watch every chat and save memories automatically, so nothing is missed and nothing is chosen. That produces a large pile of auto-logged turns, and finding anything in a pile like that needs matching by meaning rather than by exact words, which is why those tools carry vector indexes.
imprnt takes the other path. You say “file this” when something is worth keeping, and the AI writes a careful note once: typed, tagged, summarized, linked to the people and things it mentions. The judgment is spent at write time. That yields a small, clean corpus, searchable with BM25, plain ranking arithmetic with no model inside the search (how it works). Nothing costs per query, and the search works on any computer that has the files.
Neither choice is free. Ambient capture costs you a readable store, since only a machine can digest everything it saves. Conscious capture costs a moment of attention, and anything you never file cannot be found. Pick by which cost you would rather pay.
Benchmarks look like the neutral way to decide, so it matters what they measure. The public leaderboard for AI memory is LongMemEval, a test that logs thousands of chat turns and asks whether facts can be found again. It scores the ambient-capture task, and the tools built for that task report strong numbers on it, each measured by the vendor itself.
Different benchmarks, not one leaderboard. The two on the left score recall over thousands of auto-captured turns. imprnt's runs plain-language questions against curated vaults a tenth the size. A score on one does not carry over to the other.
imprnt’s figures come from its own small eval: 39 hand-written questions against two curated example vaults, with the questions and the scoring script public in eval/ so you can run it yourself. The two figures round from 89.7% and 97.4%: the first note returned answers about nine questions in ten, and the top five catch nearly all of them. Read them as an early indication that BM25 over a tagged vault answers the questions people actually ask it. The task differs from LongMemEval’s, and scores do not convert between the two.
There is a second reason to hold scores loosely: the vendors cannot agree on them.
One question, three published answers: what does Zep score on the LoCoMo memory test?
mem0's own pages disagree with each other too: LoCoMo 91.6 on its README against 92.5 on its research page, and LongMemEval 93.4, 94.4, or 94.8 depending on which mem0 page you read. No neutral third party has settled any of it.
Every number above is self-reported, each vendor running its own test setup. A public audit goes further on mempalace, alleging that its headline score is just the score of the stock database component it builds on, and that most of its stars arrived in one week from bot accounts. That analysis stays an allegation, but the safe conclusion holds either way: when the same tool on the same test has three published scores depending on who ran it, the architecture columns are a sounder basis for your decision than a decimal point.
Facts below come from each project’s own README, docs, and repo data (checked 2026-06-20, freshness re-checked 2026-07-02).
| Tool | Where memory lives | Retrieval | Capture | AI reads via |
|---|---|---|---|---|
| imprnt | Plain Markdown files you own | BM25 + grep, no model in loop | Conscious, on demand | Greps the files directly, no server |
| Karpathy's LLM Wiki pattern, with impls like obsidian-wiki, llmwiki | Plain Markdown: immutable raw/ plus an LLM-compiled wiki/ | Index-first: the LLM reads index.md, then full pages. No embeddings | Conscious: drop a source, tell the LLM to compile it | Agent reads files directly, no server (optional qmd search) |
| Basic Memory | Markdown files plus a derived SQLite index | Hybrid: SQLite full-text plus vectors (default), full-text fallback | Conscious write_note | MCP server |
| Obsidian base app, plain files, no DB pivot | Plain Markdown files you own | Human-driven: links, tags, search, graph, Dataview/Bases. No AI by default | Conscious: you write notes and links by hand | Its own GUI app. AI only via a plugin that adds a vector store |
| Logseq file version canonical, a SQLite DB version is replacing it | Plain Markdown/org files (original). The new DB version makes a local SQLite store canonical, Markdown an export | Human-driven: block refs, links, Datalog queries, graph. No AI by default | Conscious: you outline blocks and links as you write | Its own app and query engine. AI only via a sidecar plugin |
| Reor archived March 2026 (dormant since 2025) | Markdown files plus LanceDB vectors | Embeddings, vector similarity | Auto-embed on every write | Built-in desktop app, no MCP |
| Khoj self-host only, cloud closed 2026 | Its own Postgres plus pgvector DB | Embeddings plus neural re-rank | Sync and index your docs | Its own app: query embedded, recalled, reranked, fed to the chat LLM |
| mem0 | Managed multi-store: vector (~20 backends) plus optional graph | Hybrid: semantic plus BM25 plus entity matching, fused | Auto-extract from turns | API or OpenMemory MCP |
| Letta / MemGPT | Postgres plus pgvector memory blocks | Embeddings over archival memory | Agent self-edits its own memory | Letta server / API |
| Zep / Graphiti | Temporal knowledge graph (Neo4j default) | Hybrid: embeddings plus BM25 plus graph | Auto-extract into the graph | SaaS (Zep) or MCP (Graphiti) |
| cognee | Graph plus vectors plus relational | Hybrid, with a model on the read path | Auto-extract from many formats | Library or MCP |
| mempalace | Vector DB (ChromaDB default) | Embeddings plus boosting plus optional LLM re-rank | Manual and auto hooks | MCP server (35 tools) |
| Supermemory | Cloud store, with a real self-host mode | Embeddings | Auto-capture | API, MCP, or local binary |
| iai | Encrypted SQLite ("Hippo", AES-256), 3 tiers | Local embeddings (bge-small) plus graph links plus recency, ranked, no LLM in the hot path | Automatic, via Claude Code / Codex hooks | MCP server |
| ECC config pack for coding agents - memory is one subsystem | Markdown session summaries plus YAML/JSONL habit files under the home dir, plus a SQLite state store | None. Newest session summary injected at session start (7-day window, 30-day retention) | Automatic hooks on every session, plus a background model distilling habits | Harness injection at session start. Mid-session needs explicit commands |
Where the tools run varies too. mem0, Zep, and Supermemory sell a hosted service and keep an open-source local path. Letta and cognee self-host, each with an optional vendor cloud. mempalace and iai run local only. Khoj is self-host only since its cloud closed in April 2026. Obsidian and Logseq are local apps with optional paid sync. Karpathy’s wiki, ECC’s memory layer, and imprnt have no hosted mode and no account.
The biggest star count on this page belongs to ECC, and it sits in a different category. ECC is a pack of prompts, rules, and configuration for coding-agent harnesses, the programs that run an AI assistant in a terminal, with memory as one bolt-on subsystem among many: it writes a summary of each coding session and injects the newest one at the next start, with a seven-day window and thirty-day retention by default. Nothing searches it, so a fact captured 40 days ago has aged out. Credit where due, ECC keeps plain local files, uses no embeddings, and states a local-by-default policy.
The 225k stars are real, and engagement runs far behind them: about one watcher (a person subscribed to the repo’s updates) per 196 stars, where giants like React sit closer to one per 40, and roughly 42,000 installer downloads total. Its memory answers “what was I doing last session”, where a vault answers “what do I know”. Both are real jobs, and neither tool does the other’s.
One card per tool: what it is, where it parts from imprnt, and the case where it is the better pick. Several cards mention an MCP server, the standard plug that lets an AI assistant call an external tool.
Markdown the user owns and reads. The split is the machinery on top, and who the first reader is.
A pattern, not a product: immutable raw sources, an LLM-compiled Markdown wiki, a schema file. Implementations range from desktop apps to MCP servers.
Markdown as the source of truth with a derived SQLite index, reached over an MCP server. The closest shipped product.
Plain Markdown files you own, the field's strongest your-files stance, no DB pivot. The base app ships no AI.
A local-first block outliner. The original keeps Markdown or org files, and the DB version now in beta makes a local SQLite database canonical.
Embeddings as the core recall driver, into a vector store, usually auto-captured. The bulk of the field.
A desktop notes app: Markdown files plus a LanceDB vector index, auto-embed on every write. No longer maintained.
A self-hosted server (Postgres plus pgvector) that indexes many file types and answers with two-stage neural search: one model recalls candidates, a second re-ranks them.
A $24M-funded universal memory layer for agents: a managed multi-store (vector across about 20 backends, optional graph, key-value) that auto-extracts facts from chat turns.
A memory-palace MCP server (35 tools) over ChromaDB and SQLite, embeddings with boosting and an optional LLM rerank, auto-saving transcripts from coding-agent hooks.
An encrypted-SQLite memory (AES-256, three tiers) over MCP, with local embeddings and fully automatic capture from Claude Code and Codex hooks.
Cloud-first infrastructure with a real self-host binary: a vector-graph engine that auto-extracts facts, builds user profiles, and auto-forgets.
An LLM-built knowledge graph as the store, queried by traversal. Strong at multi-hop, heavy to run.
A bi-temporal knowledge graph (Neo4j by default) where every fact carries a validity window. Hybrid semantic, BM25, and graph traversal, auto-extracted on ingest.
A pipeline that ingests sources and runs an LLM extraction pass into graph, vector, and relational stores, with many search modes and a model on the read path.
Memory as the live state of a running agent, served from a database. A different problem from a personal vault.
A stateful agent runtime with OS-style tiered memory in Postgres and pgvector, the agent self-editing its own memory, served over an API.
A catalog of prompts, rules, and configs for coding agents, with memory as one bolt-on subsystem, measured on the same axes.
A pack of 268 skills, 66 agent definitions, and config trees for eleven coding-agent harnesses, plus lifecycle hooks that write a per-session summary and re-inject the newest at the next start.
Karpathy’s LLM Wiki is imprnt’s nearest relative, published as a pattern in April 2026 in a post with a reported 21 million views. Same shape: raw sources kept immutable, an AI-compiled Markdown wiki, an index the model reads first. Karpathy’s own note says the design “works surprisingly well at moderate scale” while avoiding embedding infrastructure, and he puts the comfortable range at a few hundred pages. The pattern stops at index-reading, so past that range recall means the model rereading a growing catalog. imprnt is that design shipped as a tool, with a BM25 ranker so search holds up as the vault grows and a typed contract so the same person never splits into two pages.
Basic Memory is the closest shipped product, and it treats Markdown files as the truth just as imprnt does. Around the files it makes the opposite calls: a derived database kept in sync, a small server program the AI talks to instead of reading the files directly, and, since March 2026, semantic search on by default, which puts a model inside every search. If you want the owned-files floor with conventional machinery on top, it is a good tool. imprnt exists for the reader who wants the files with nothing between them and the AI.
Answer the three questions differently and you land somewhere else. The honest routes:
Zero-effort ambient memory
pick instead mem0, Zep, mempalace, iai
You want the assistant to silently remember every chat with no filing step. imprnt's conscious capture gets in the way. These capture turns automatically.
Encrypted automatic memory behind Claude Code
pick instead iai
It installs hooks, captures every turn, and keeps an encrypted local store. imprnt keeps plain files with no encryption layer, since privacy comes from the directory being yours and owner-only.
A product, not a personal vault
pick instead mem0, Zep, Supermemory
A multi-user app needs a memory API, a hosted service, and per-user isolation. imprnt is single-owner, local, no API surface.
An agent that manages its own state at scale
pick instead Letta
The purest version of an agent that pages and self-edits its own memory across long runs.
An outliner and graph you drive by hand
pick instead Logseq, Obsidian
Block notes, bidirectional links, a graph view, and queries you run yourself. imprnt has no GUI and no human query language. It is a typed vault an agent greps. If the point is you navigating the knowledge, a PKM app wins.
Semantic recall across messy unlabeled text
pick instead any embeddings tool above
If your corpus is large, unstructured, and you will not tag it on the way in, embeddings out-recall BM25. imprnt's bet pays off because the write path does the labeling. Skip that work and the bet weakens.
Zero-effort session continuity in a coding agent
pick instead ECC
It ships a huge skills catalog plus hooks that summarize each session and inject the newest one at the next start, so picking up where you left off costs nothing. imprnt ships no catalog and asks you to decide what is worth keeping.
imprnt is for one person who answers all three the same way: memory they can read, in files no vendor can take away, filed by their own choice. If that describes you, the rest of this page was due diligence. If it does not, the cards above name your tool.