# recall vs Honcho

Honcho stores an app's messages and has a background worker reason over them into a representation of each person or agent, which you query by asking it questions. recall indexes the chats Claude Code, Codex and Cursor already keep, with no model calls, and writes notes overnight with a model you choose.

Checked 17 Oct 2026 · recall 0.5.1 · [Honcho on GitHub](https://github.com/plastic-labs/honcho)

## At a glance

Honcho's idea is that an agent should know who it is talking to: a representation of each person and agent, written by a background reasoner from everything they said, which your app can ask questions. recall's idea is narrower: your coding agents should remember what you have worked on. It keeps the chats searchable and distils a few notes a night from them.

| | recall | Honcho |
| --- | --- | --- |
| Runs | On your machine | Honcho's cloud, or self-hosted on Postgres with pgvector |
| Licence | MIT | AGPL-3.0 |
| Model calls to store a chat | **0** | **A deriver call per message** or small batch, plus dreamer and summariser |
| A search takes | **11 ms** local, 47 with embeddings | **~200 ms** for a context call, its site's figure |
| Price | **Free** | $2 per million tokens ingested; chat questions $0.001 to $0.50 |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to its US cloud and its sub-processors |
| Claude Code, Codex, Cursor | MCP, skill, session hook | Hosted MCP server, Claude Code plugin, skills |

## Where both were measured

Honcho's evals page gives 90.4% on LongMemEval with Claude Haiku 4.5 answering and GPT-4o judging, 92.6% with Gemini 3 Pro, and 62.6% for the same Haiku reading the whole history with no memory. recall 0.4.1 scores 88.4% with Claude Haiku 5.5 as both, two points under Honcho's Haiku figure with a different judge, which is within what a judge moves. Honcho's own statistics show its run answering two thirds of questions without retrieving at all; recall's retrieval alone finds an answering session in the top five 98.7% of the time.

On coding work Honcho has no figures. recall finds the past fix in its top five 80% of the time on SWE-ContextBench, and its notes at session start lift an agent from 32% to 75% on long MemoryCode histories.

**Fig 1. recall 0.5.1 and Honcho** LongMemEval: answers correct as each reports it, and the latency of a context call.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Answers correct | Honcho · Gemini 3 Pro | 92.6% | its evals page, GPT-4o judging |
| Answers correct | Honcho · Haiku 4.5 | 90.4% | its evals page, GPT-4o judging |
| Answers correct | recall 0.4.1 | 88.4% | Claude Haiku 5.5 answering and judging, reading the top 10 chats |
| Answers correct | Full history · Haiku 4.5 | 62.6% | Honcho's own baseline: the whole history in the prompt, no memory |
| Latency of a context call | Honcho · context() | ~200 ms | its site's figure, a hosted call |
| Latency of a context call | recall 0.4.1 · keywords | 11 ms | median search on ~2,800 chats, no model in the path |
| Latency of a context call | recall 0.4.1 · hybrid | 47 ms | with the local embedding model, the query's embedding included |

LongMemEval_S · Honcho's evals page, December 2025 · recall 0.4.1, all 500 questions · latency from Honcho's site and recall's laptop Honcho: Claude Haiku 4.5 or Gemini 3 Pro answering, GPT-4o judging; its no-memory baseline is Haiku 4.5 reading the whole history. Its own statistics show the run answering 66% of questions without a retrieval call. recall: Claude Haiku 5.5 answering and judging.

## Cost

Honcho charges $2 per million tokens ingested, so a day of coding-agent transcripts costs what it weighs; context calls are free, and asking the representation a question costs $0.001 to $0.50 by depth. Behind the price is the deriver, an LLM pass over every message.

recall spends no model calls to index or search. Its one model cost is the nightly notes, with a model you choose: nothing through a local one, covered by a subscription, batch prices on an API key.

| | recall | Honcho |
| --- | --- | --- |
| Model calls to store a chat | **0** | **A deriver call per message** or small batch, plus dreamer and summariser |
| Price | **Free** | $2 per million tokens ingested; chat questions $0.001 to $0.50 |
| To take in 300 sessions | **$0**, no model calls | $2 per million tokens, plus a question each query |
| Cost of memory | One nightly run, your model | Ingestion by the token; reasoning by depth |

## Latency

Honcho's site puts a context call at about 200 ms, a round trip to its cloud; a question to the dialectic endpoint takes as long as the reasoning behind it. No benchmark latency is reported.

recall's search is a local index: 11 ms at the median on ~2,800 chats, 47 ms with the embedding model, and at session start the notes are a file read.

| | recall | Honcho |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | **~200 ms** for a context call, its site's figure |
| Wait at write time | **None**: reads saved chats | The deriver, in the background |

## Privacy

Honcho's cloud runs on US infrastructure and lists Anthropic, Groq and Google Cloud as sub-processors; its privacy policy retains customer content 90 days by default and says it is not yet SOC 2 certified, though its site shows a SOC 2 badge. Self-hosting is a Postgres and an LLM key of your own, under the AGPL.

recall is MIT and runs on your machine. It reads chats read-only, redacts secrets before indexing, sends no telemetry, and makes no network calls except to the model you chose for the nightly notes. With a local model, nothing leaves.

| | recall | Honcho |
| --- | --- | --- |
| Runs | On your machine | Honcho's cloud, or self-hosted on Postgres with pgvector |
| Licence | MIT | AGPL-3.0 |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to its US cloud and its sub-processors |
| Compliance | Nothing to certify: no service | Policy says not yet SOC 2; a badge says Type II |
| Telemetry | **None** | 90-day retention by default on the cloud |

## How memory is built

Honcho's memory is a representation: the deriver's conclusions about each peer, consolidated by the dreamer and summarised into a card, with the raw messages alongside. You do not read it so much as ask it, through a chat endpoint that reasons over it at the depth you pay for.

recall's memory is files you can read: an index of every chat, and notes in markdown under git typed as preferences, project facts, decisions, lessons and open threads, each with a quote from its chat, consolidated rule by rule once a night. Edit a note and the edit wins. Notes written by Claude Haiku 5.5 hold 91% of the conventions a mentor set on MemoryCode.

| | recall | Honcho |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Your app sending messages |
| Memory is | Markdown notes in git, plus an index of every chat | A representation of each peer, asked not read |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | A chat endpoint over the representation; message search |
| You can edit it | **Yes**, and the edit wins | Through the API |

## Which to pick

**Pick Honcho if**

- You are building an app that should understand each of its users, and want to ask a model what a user is like.
- You want a hosted service with a per-token price and are fine with your messages passing through its models and sub-processors.
- Your memory comes from your application's conversations, not from coding-agent transcripts on disk.

**Pick recall if**

- You want Claude Code, Codex and Cursor to share a memory of your own work, read from the chats they already keep.
- You want search with no model calls and millisecond latency, and notes you can read rather than a model you have to ask.
- You want nothing to leave your machine, and MIT rather than AGPL.

## Questions

**Does Honcho work with Claude Code?**

Yes, through a hosted MCP server, a Claude Code plugin and agent skills, which send what the agent saves to Honcho's cloud. recall also connects through MCP and a skill, but reads the transcripts Claude Code, Codex and Cursor already write, so nothing is sent and nothing has to be saved by hand.

**Which scores higher on LongMemEval?**

Honcho reports 90.4% with Claude Haiku 4.5 and a GPT-4o judge; recall measures 88.4% with Claude Haiku 5.5 as both. That gap is within what a judge moves, and Honcho's run answered two thirds of questions without retrieving. recall's retrieval alone finds an answering session in the top five 98.7% of the time.

**Can I self-host Honcho?**

Yes: Postgres with pgvector and an LLM key of your own, under the AGPL. The deriver still sends every message to that LLM. recall needs no server, and its nightly notes can use a local model.

**What does Honcho charge?**

$2 per million tokens ingested, context calls free, and chat questions from $0.001 to $0.50 each by reasoning depth. recall is free; the nightly notes cost what your model costs, which with a local one is nothing.

## Sources

- Honcho on GitHub: https://github.com/plastic-labs/honcho
- Honcho: architecture: https://honcho.dev/docs/v3/documentation/core-concepts/architecture
- Honcho: evals: https://honcho.dev/evals
- Honcho's LongMemEval_S run statistics: https://github.com/plastic-labs/honcho-benchmarks/blob/main/a1d689b/longmemeval_s_stats_20251212_201328.json
- Honcho: pricing on its home page: https://honcho.dev
- Honcho privacy policy: https://app.honcho.dev/privacy
- recall's chat benchmark runs, with the other systems' figures: https://github.com/alirng/recall/blob/main/docs/research/retrieval-benchmarks.md