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.
A third shape appeared in 2026 and now holds the field’s biggest repos. The personal-agent runtimes - OpenClaw, Hermes Agent, nanobot, CowAgent, QwenPaw, ZeroClaw, NanoClaw, IronClaw - sell the assistant itself, with memory as one built-in subsystem: usually notes the agent authors for itself, sometimes with a derived search index on top. Where each lands on this page’s questions depends on which half you look at, so all eight are measured on the table below.
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 since mid-2025 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 Its founder joined OpenAI two months after launch, moving the project to a young foundation: "OpenClaw will move to a foundation and stay open and independent."
what users keep The Markdown workspace is yours either way. The SQLite search index, channel logins, and gateway are runtime state riding on the foundation's stewardship.
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, was sunset: first "is being sunset" per its own README, and by August 2026 its directory is gone from the repo entirely.
what users keep The local option retired. Its memories sit in a vector store and Postgres that only mem0's own stack reads.
what happened Split into two products: the SQLite database version keeps the Logseq name and shipped 2.0 in July as "an early beta", while the plain-files version became maintenance-mode "Logseq OG". The README still warns "data loss is possible".
what users keep OG users keep plain Markdown with "no forced migration", on a version that now gets security fixes rather than new features.
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 comes from the other camp. Letta, a memory company, published a LoCoMo run where a plain-files approach scored 74.0%, ahead of its own specialized memory tools and of mem0’s best variant at 68.5%. Published against a vendor’s own prior product is the rare direction that earns trust, and Letta has since rebuilt its flagship around Markdown files tracked in git. The retrieval half of that bet is no longer a lone data point, it is the new camp’s default setting. Hermes Agent (236k stars, Nous Research) does cross-session recall with SQLite full-text search and documents nothing vector-shaped. Alibaba’s QwenPaw ships BM25 over linked Markdown with embeddings off by default. ZeroClaw’s shipped default is keyword-only FTS5, its own config docs spelling out the reason: “no API calls, no vector cost.” Four independent teams, all landing where this page’s own search already sits.
We ran imprnt on the same benchmark, and the result is not a win.
LoCoMo is a public academic benchmark of 1,986 questions about long multi-session conversations. Every vendor including us scores the same 1,540 of them, because the adversarial category is dropped by Letta, mem0 and Zep alike. We scored it with Letta’s own published grader, unmodified, and graded the answers with OpenAI’s gpt-4.1, the judge model their grader specifies. Both arms use identical questions, the same grader and the same judge. The variable is the model, and it does imprnt’s writing as well as its reading, so the vaults differ too: gpt-4o-mini wrote about 40 notes per conversation, Sonnet about 78. The gain below is write quality and answer quality together, not the answering step alone.
| run | answering model | score | 95% CI |
|---|---|---|---|
| imprnt | gpt-4o-mini, the model Letta’s run used | 58.6% | 56.2-61.1% |
| imprnt | Claude Sonnet | 76.3% | 74.2-78.4% |
Letta, as published | gpt-4o-mini | 74.0% | not stated |
Two harness details, since both favour us. An LLM shapes each question into keywords before the ranker runs, which is imprnt’s documented read path but is not what LoCoMo’s reference harness does. And one line was added to the answer prompt telling the model to name every item when a question asks for a set. That line was written after reading multi-hop failures. Both are in the committed harness.
Read the first row before the second. On the same model Letta used, imprnt loses by about fifteen points, and 74.0% sits well outside our interval. Letta published none of their own. The second row is not a rebuttal to that: a stronger model is worth roughly seventeen points to imprnt, so comparing our Sonnet number to their gpt-4o-mini number would be comparing two different things.
Three things you should know before using any number on this page, ours included:
The judge moves the score more than the design does. Grading one fixed set of imprnt’s answers with Claude instead of gpt-4.1 changed the result by nine points (68.4% against 77.6%) on one conversation’s 152 answers, on identical text, with agreement at 89.5% and the disagreements running fifteen-to-one in one direction. The three figures this page stands next to, mem0 68.44%, Letta 74.0% and Zep 75.14%, span less than seven points. That is narrower than the swing from changing the judge.
Letta’s 74.0% cannot be reproduced from what they published. Their benchmark code exists and their blog links a specific line of it, but the post states no question count, category set, repeat count, or chunking, and no run configuration or result file is recoverable from the repository, though that repository commits no benchmark’s raw results at all, so the absence is not specific to LoCoMo.
Our own number has a real limit. The vaults built from one LoCoMo conversation run from 8 notes to 55, so returning the top fifteen hands over a third of the corpus, and on the smallest one all of it. That says nothing about how the ranking holds at a thousand notes, which is the case that actually matters.
The harness, every prediction, every judge verdict and the scripts are in the repository. Re-run it before believing any of the above.
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 README publishes 92.5% on LoCoMo where its own committed per-question results recompute to 91.56%, and 91.8% where they recompute to 82.66%. The commit that set those figures changed only README.md, and mem0's own commit message attributes them to a newer run that is not in the repository. No neutral third party has settled any of it.
Every number above is self-reported, each vendor running its own test setup. 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, Hermes Agent and OpenClaw checked 2026-08-26).
| 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 DB version is now the main product (2.0 beta), file version is maintenance-mode Logseq OG | Plain Markdown/org files (Logseq OG). The DB version, now the main line, 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 MCP server (OpenMemory retired Aug 2026) |
| Letta / MemGPT agent-state runtime turned personal agent | MemFS: git-backed Markdown tree (legacy server path: Postgres plus pgvector) | Agent greps and reads its own files, model in the read loop | Agent self-edits plus /remember plus background dreaming subagents | Terminal agent, desktop app, channels (Telegram, Slack, Discord...), or 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", own Rust engine, AES-256), 3 tiers | Local embeddings (bge-small) plus graph links plus recency, with a BM25 lexical lane fused in, no LLM in the hot path | Automatic, via hooks (Claude Code, Codex, Cursor, and more) | 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 |
| Hermes Agent personal agent, memory is a built-in feature | Two capped Markdown files (~3.5KB total) plus SQLite session history | FTS5 full-text over raw session messages, no vectors documented | Agent self-curates on periodic nudges, approval gate off by default | Capped files injected whole at session start, session_search for history |
| OpenClaw personal assistant runtime, foundation-stewarded | Plain Markdown workspace plus a derived SQLite index | Hybrid vector plus keyword in SQLite, OpenAI embeddings by default | Agent-written: dailies, silent pre-compaction flush, dream sweeps | Local gateway agent, memory_search tool, core files always in context |
| nanobot HKUDS personal agent, 47k stars in seven months | Plain Markdown workspace (MEMORY.md, USER.md, SOUL.md) plus append-only history.jsonl, git-versioned | None: MEMORY.md injected whole every turn, agent greps history on demand, no index or vectors | Automatic: consolidator summarizes turns, a Dream pass edits the files every 2h by default | System-prompt injection plus its own grep and file tools |
| CowAgent formerly chatgpt-on-wechat, China-first agent harness | Plain Markdown workspace (~/cow) plus a derived SQLite index | Hybrid: 0.7 vector plus 0.3 FTS5 BM25, OpenAI embeddings by default, keyword-only without a key | Agent-written dailies plus a nightly Deep Dream pass that rewrites MEMORY.md | Local harness agent over 12 channels, memory_search / memory_get tools |
| QwenPaw Alibaba's personal agent, CoPaw rebranded Apr 2026 | Agent-written Markdown with frontmatter and wikilinks (ReMe workspace) plus verbatim session history | BM25 plus bounded wikilink expansion by default, embeddings off by default, optional RRF fusion and rerank | Automatic: conversations continuously digested, dream-cron consolidation | Assistant runtime via ReMe search (CLI/MCP/HTTP), chunks with line ranges plus linked neighbors |
| ZeroClaw Rust personal-agent runtime, 32.7k stars in six months | SQLite brain.db in the agent workspace (flat Markdown backend optional) | FTS5 BM25 keyword-only by default, embeddings and hybrid opt-in | Ambient: auto-saves what you tell it, plus explicit memory_store | Runtime injects a [Memory context] block, memory_recall tool mid-turn |
| NanoClaw personal agent runtime, the security-first OpenClaw answer | Plain Markdown (OKF) per agent group, no DB, no embeddings | Agent-driven rg/find plus hand-kept index links, model in the loop | Agent self-writes mid-session, steered by an editable definition file | index.md injected at context start (16k cap), files read in-container |
| IronClaw NEAR AI's Rust reimplementation of the OpenClaw idea | Rows in an embedded DB (libSQL, Postgres served) shaped as a virtual path workspace | Deterministic FTS5 plus optional vector, RRF-fused, agent-invoked | Agent-written unprompted, with editorial policy plus a background curation pass | Gateway agent over REPL, webhooks, WASM channels, memory tools mid-turn |
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. OpenClaw and Hermes Agent self-host on your own machine and API keys. Karpathy’s wiki, ECC’s memory layer, and imprnt have no hosted mode and no account.
The biggest repos on the page are the personal-agent runtimes, led by OpenClaw at roughly 388k stars and Hermes Agent at roughly 237k. Most of the camp keeps canonical memory as plain Markdown you own and can read, which is its good half (IronClaw is the exception: paths that look like files but are rows in an embedded database). The read path is where the camp quietly splits, and it deserves a closer look before you trust any “plain files” pitch. Five of the eight search lexically or not at all: Hermes and ZeroClaw with SQLite full-text, QwenPaw with BM25 over linked Markdown, nanobot and NanoClaw with the agent grepping its own files. The other side embeds by default, through a third-party API. OpenClaw’s own memory docs state it plainly: “OpenClaw uses OpenAI embeddings by default.” On a stock install, every memory the agent writes is sent to OpenAI’s API to be embedded into a local index, and semantic recall depends on that provider from then on. CowAgent’s source makes the same choice with numbers attached: recall weights API embeddings 0.7 against BM25’s 0.3, OpenAI’s text-embedding-3-small as the default provider. Local embedding exists in both, behind explicit configuration. If you picked a files-you-own tool for the privacy, that default is worth knowing before the first note is written.
The camp narrowed one more of imprnt’s claims in August: the typed contract is no longer imprnt’s alone. NanoClaw’s memory format (OKF) is strikingly close - one Markdown concept per file, frontmatter declaring a type like person or decision, tags, links between entities, an index file, no database, no embeddings. The remaining difference is governance, and their own documentation states it: “The format is a convention, not a gate. A file with missing or malformed frontmatter still works as memory; the agent repairs metadata when it next touches the file.” And, on types: “Types are the agent’s vocabulary, not a fixed list.” imprnt makes the opposite choice on both counts. The contract is an invariant imprnt check refuses to guess about - a note that breaks it gets flagged by code, never quietly repaired by a model - and the tag vocabulary grows only through a human’s ratification. Two tools with the same file format, split on the question that splits this whole page: who decides, and can code check it.
ECC sits in a different category too. 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, split in two since April 2026. The DB version (local SQLite canonical) keeps the Logseq name and shipped 2.0 as a beta. The Markdown/org file version continues as maintenance-mode Logseq OG.
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, own Rust engine) over MCP, with local embeddings plus a fused BM25 lane and fully automatic capture hooks for Claude Code, Codex, Cursor, and more.
Cloud-first infrastructure with a real self-host binary (since v0.0.7 licensed up to 10,000 documents, per its release notes): 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.
The MemGPT company, mid-convergence: its flagship now keeps memory as MemFS, a git-backed Markdown tree the agent edits with bash, and since August 2026 it ships the assistant itself with channels, schedules, and a desktop app.
The assistant is the product and memory is one subsystem: agent-authored files plus a search index, reached through chat channels. Eight members including the field's biggest repos, and most of them default to lexical search.
Nous Research's self-hosted personal agent. Durable memory is two hard-capped files (~3.5KB total) injected whole each session, and cross-session recall is FTS5 full-text search over raw SQLite session history.
The 2026 wave's flagship personal assistant (~388k stars): a local gateway to ~30 chat channels whose memory is agent-written Markdown indexed into SQLite hybrid search.
HKUDS's ultra-lightweight self-hosted personal agent in readable Python. Durable memory is plain Markdown files a scheduled Dream pass edits surgically, over an append-only JSONL history, all git-versioned with rollback commands.
The renamed chatgpt-on-wechat: a China-first agent harness (WeChat, Feishu, DingTalk, QQ, plus Telegram, Slack, Discord) whose memory is agent-written Markdown in ~/cow, indexed into SQLite hybrid search and distilled nightly by an LLM Deep Dream pass.
Alibaba's AgentScope personal assistant: seven chat channels from one instance, its own 2B/4B/9B local models needing no API key, and a durable memory layer (ReMe) of user-editable Markdown with frontmatter and wikilinks, searched by BM25 with embeddings off by default.
A Rust single-binary personal-agent runtime (~32.7k stars): 30+ chat channels, hardware GPIO, supervised autonomy, and a pluggable memory that defaults to SQLite FTS5 with BM25 scoring and no embedding provider configured.
The security-minded minimal answer to OpenClaw: one process on the Claude Agent SDK, agents in isolated containers across 13 chat channels, memory as plain Markdown concept files (OKF: typed frontmatter, tags, links), no database and no embedding store.
NEAR AI's Rust reimplementation of the OpenClaw idea: a hardened gateway whose memory is rows in an embedded libSQL database shaped as a virtual path workspace, searched by deterministic FTS5 plus optional vectors fused with RRF.
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 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.
An assistant that acts, reachable from your chat apps
pick instead OpenClaw, Hermes Agent
Email, calendar, browser, shell, and cron, answered on WhatsApp or Telegram, with memory the agent keeps for itself. imprnt has no channels and takes no actions. It is the memory, not the assistant.
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.
MIT licensed. © 2026 Aleksandr Bogdanov.