...
[Comparison ยท as of November 16, 2026]

claude-mem vs Honcho

claude-mem runs a second agent next to your coding agent that takes notes on every tool call, then opens your next session in that project with an index of those notes. It's free, Apache-2.0, and keeps everything in SQLite on your machine. Honcho stores your conversations, reasons over them into a model of you, and gives that model to every agent you connect, across projects and tools. claude-mem remembers what happened in a project. Honcho remembers who you are and how you work.

How memory gets built
claude-mem
Notes on every tool call, by an observer agent
Honcho
Reasons over messages into conclusions
What you pay for
claude-mem
Free; the observer runs on your plan
Honcho
$2.00 per million tokens ingested
Open source
claude-mem
Apache-2.0
Honcho
AGPL-3.0
Self-hosting
claude-mem
Runs locally by default
Honcho
Same code as the hosted service
[Summary]

claude-mem or Honcho: the short answer

choose claude-mem if

Choose claude-mem if

  1. 01You want project memory that stays on your machine with no account. claude-mem keeps everything in ~/.claude-mem, and cloud sync is opt-in.
  2. 02You want a permissive license. claude-mem is Apache-2.0.
  3. 03You want a record of what the agent did: files read, commands run, and a summary of each session.
choose Honcho if

Choose Honcho if

  1. 01You want your preferences and working style to follow you into every project. claude-mem scopes memory to the project you're in.
  2. 02You switch between Claude Code, Codex, Hermes, and other agents and want them to share one model of you.
  3. 03You want memory processing off your Claude plan. claude-mem's observer runs on your Anthropic plan by default; Honcho reasons on its own models for $2 per million tokens, and context reads are unlimited.
[Mechanism]

How memory gets built

claude-mem
write01Hooks capture each tool call
02An observer agent writes notes as you work
03Observations and a session summary in SQLite
read04Session start in the same project
05An index of past observations
06Search tools fetch full notes on demand
Honcho
write01Each message, stored as sent
02The deriver reasons over it in the background
03Conclusions about each peer
read04session.context()
05Representation, summary, and recent messages
06Inside your token budget, in about 200ms

Each step restates the vendor's own docs, listed under Sources.

[Comparison table]

claude-mem and Honcho, row by row

What it isclaude-mem
"Persistent memory for AI coding agents: the next session starts where the last one left off", by Alex Newman
Honcho
An open-source memory layer for the agents and apps you already run
How memory gets builtclaude-mem
Notes on every tool call, by an observer agent
Hooks send every tool call to a local worker. An observer agent, Claude Haiku by default, writes short observations as you work and a summary when the session ends
Honcho
Reasons over messages into conclusions
Stores each message as sent. A background deriver reasons over new messages and writes conclusions about each participant; dreaming consolidates them later
Whose memory it keepsclaude-mem
One project on one machine
One project on one machine. Startup context comes from the current agent unless you turn on all sources. Cross-device sync and team memory are paid add-ons
Honcho
Peers: users, agents, and groups
Peers: any user, agent, or group, plus each peer's view of the others
What a query returnsclaude-mem
An index at session start, then search tools
A compact index of past observations at session start, from the second session in a project. MCP tools search, open a timeline, and fetch full observations on demand
Honcho
context() in about 200ms, or chat()
context() returns a representation, a summary, and recent messages inside a token budget you set, in about 200ms. chat() answers a plain-language question about a peer
What you pay forclaude-mem
Free; the observer runs on your plan
Free and open source. The observer's model calls run on your Anthropic plan or your own OpenRouter or Gemini key. CMEM Pro, $30 a month, runs the observer off your plan and adds cloud sync
Honcho
$2.00 per million tokens ingested
$2.00 per million tokens ingested. Reading context is unlimited. chat() queries cost $0.001 to $0.50 each, by reasoning level
Open sourceclaude-mem
Apache-2.0
Apache-2.0, open core. Hosted cloud and team sync sit outside the open-source code
Honcho
AGPL-3.0
Server and SDKs, AGPL-3.0
Self-hostingclaude-mem
Runs locally by default
Local by default: npx claude-mem install. Needs Node, Bun, and uv. SQLite with FTS5, plus Chroma for vector search
Honcho
Same code as the hosted service
honcho start --setup runs the API, Postgres, and Redis on Docker, plus an LLM key. The hosted service runs the same code
Works withclaude-mem
Records sessions in 15 agents, including Claude Code, Codex, Cursor, OpenCode, Pi, and OpenClaw. Copilot CLI, Goose, Roo Code, Warp, and Zed can search memory only
Honcho
Plugins for Claude Code, Codex, OpenCode, Hermes Agent, OpenClaw, Kilo Code, Pi, and DeepSeek Harness. A hosted MCP server for other clients. Guides for the Vercel AI SDK, LangGraph, CrewAI, and n8n
Published benchmarksclaude-mem
No memory benchmarks published. A code-navigation token comparison against Claude's Explore agent, on its own codebase. Self-reported
Honcho
LongMemEval S 90.4, LoCoMo 89.9, BEAM 1M 61.8 and 10M 40.9. Self-reported, with configs and raw outputs on GitHub

As of November 16, 2026. Benchmark scores are each vendor's own, from separate runs, and aren't directly comparable.

[claude-mem]

claude-mem takes notes on what your agent does in each project

claude-mem installs hooks into your coding agent. In Claude Code they fire at session start, on each prompt, around every tool call, and when the session stops, and each one hands the event to a local worker. A second agent, the observer, turns that activity into short observations as you work and writes a summary when the session ends. The default observer is Claude Haiku through the Claude Agent SDK, and Codex, Gemini, OpenRouter, or any OpenAI-compatible model can stand in (README, configuration).

Everything is stored in SQLite at ~/.claude-mem, with full-text search, and Chroma adds vector search. From your second session in a project, the agent starts with a compact index of past observations. It calls MCP tools to search them, see a timeline, and pull full observations only when it needs the detail, which the project calls progressive disclosure. Wrap text in <private> tags and it isn't stored.

The open-source plugin is free. The observer's model calls come out of your Anthropic plan unless you bring an OpenRouter or Gemini key, or pay for CMEM Pro at $30 a month, which runs the observer off your plan and adds cloud sync. Team memory, called TeamBrain, is in a paid pilot (pricing).

[Honcho]

Honcho reasons over every message into a model of each peer

Honcho stores each message as it was sent, labelled with the peer who said it. A peer is any participant: a person or an agent. A background process called the deriver reasons over new messages and writes conclusions about each peer, including things that follow from what was said but were never stated outright. When a user corrects a fact, the deriver writes a new conclusion with a timestamp, and the old one stays for now. Dreaming runs later, once enough new conclusions have built up, deletes conclusions a newer fact has replaced, and merges ones that say the same thing.

Your agent reads memory two ways. session.context() returns the representation, a summary, and recent messages inside a token budget, in about 200 milliseconds, and those reads are unlimited. peer.chat() takes a question and reasons over the representation to answer it, at one of five levels from minimal to max, priced per query from $0.001 to $0.50.

Writes are asynchronous. A conclusion lands after the deriver runs, in time for the next turn but not the same one. Each peer can also keep its own view of every other peer it has observed. A support agent's model of a customer and the customer's model of that agent are separate objects.

[Where claude-mem fits better]

Pick claude-mem for local, project-scoped memory with no account

claude-mem works out of the box on your machine. You don't create an account, nothing leaves your laptop unless you turn on cloud sync, and the Apache-2.0 license clears policies that rule out Honcho's AGPL-3.0. It records more agents than Honcho has plugins for, and it's widely used, with more than 117,000 GitHub stars.

It's also built around a different question: what happened in this repo last time. If you want your agent to recall the file it edited, the command that failed, and how the last session ended, claude-mem keeps that record per project and shows it in a local viewer. Honcho's plugin saves your conversation, and tool calls only if you turn that on. Its writes land after a background step, in time for the next turn but not the same one.

[Why Honcho]

Honcho remembers you across every project and agent, on its own models

Honcho reasons over your sessions into a model of how you work and gives it to Claude Code, Codex, Hermes, and every other agent you connect, in every repo. Context reads are unlimited and the reasoning doesn't touch your Claude plan. Start on Honcho Cloud with credits, or self-host the same server.

[Questions]

FAQ

01Can I use claude-mem and Honcho together?+

Yes. They hook into Claude Code separately. claude-mem adds notes on the current project at session start, and Honcho adds what it knows about you before each prompt. Both add to your context window, so watch the size of what gets injected.

02Which one is cheaper?+

claude-mem's plugin is free, but its observer makes model calls as you work, billed to your Anthropic plan or your own API key unless you pay $30 a month for CMEM Pro (pricing). Honcho charges $2.00 per million tokens it saves, reasons on its own models, and doesn't meter context reads; chat() queries cost $0.001 to $0.50 each (pricing). Which costs less depends on how much your agent does per session.

03Does either one share memory across Claude Code, Codex, and Hermes?+

claude-mem records sessions in many agents, and by default each agent's startup context comes from its own history; a setting includes every source (README). Honcho has plugins for Claude Code, Codex, OpenCode, Hermes, and OpenClaw, and agents pointed at the same workspace share one model of you.

04Where does my data go?+

claude-mem keeps it in ~/.claude-mem on your machine. Cloud sync uploads observations, summaries, and prompts only if you turn it on, and anonymous usage analytics are on by default until you run npx claude-mem telemetry disable (telemetry). Honcho's plugin sends your sessions to Honcho's hosted API under your account, or to your own Honcho server if you self-host.

05Can I use either one commercially?+

Yes. claude-mem is Apache-2.0, so you can modify it and keep changes private. Honcho is AGPL-3.0: you can modify it and run it as a service, and if you do, you publish your changes. Honcho Cloud has no such requirement.