Letta vs Honcho
Letta Code is a stateful agent harness: you run a Letta agent, and it keeps its memory in a git-backed folder it edits itself. Honcho reasons over conversations from the agents and apps you already run into a representation of each person or agent. Both are open source and both run locally.
- Letta
- The agent edits its own memory
- Honcho
- Reasons over messages into conclusions
- Letta
- Per agent, plus LLM usage
- Honcho
- $2.00 per million tokens ingested
- Letta
- Apache-2.0 (Letta Code)
- Honcho
- AGPL-3.0
- Letta
- Local backend. Letta Cloud by default
- Honcho
- Same code as the hosted service
Letta or Honcho: the short answer
How memory gets built
Each step restates the vendor's own docs, listed under Sources.
Letta and Honcho, row by row
| Row | Letta | Honcho |
|---|---|---|
| What it is | Letta "A stateful agent harness": a Letta agent you run from a CLI, the browser, or chat apps, with memory built in | Honcho An open-source memory layer for the agents and apps you already run |
| How memory gets built | Letta The agent edits its own memory The agent rewrites its own memory, skills, and prompts, then commits the changes to MemFS, a git-backed folder. Dreaming subagents review recent conversations in the background | 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 keeps | Letta One agent One agent. Memory is shared across that agent's conversations. Other agents can search its messages, but a new agent starts without its memory | Honcho Peers: users, agents, and groups Peers: any user, agent, or group, plus each peer's view of the others |
| What a query returns | Letta Your app messages the agent Memory blocks sit in the agent's own context, and the agent searches its files and past messages with tools. Your app reaches memory by messaging the agent | Honchocontext() 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 for | Letta Per agent, plus LLM usage The agent. Free is "limited to 3 stateful agents", Pro is $20 a month for up to 20 with a usage quota and overage, and the API plan is $20 a month plus $0.10 per active agent and $0.00015 per second of tool execution. LLM usage on top, or your own keys | 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 source | Letta Apache-2.0 (Letta Code) Letta Code, Apache-2.0 | Honcho AGPL-3.0 Server and SDKs, AGPL-3.0 |
| Self-hosting | Letta Local backend. Letta Cloud by default Letta Code runs against a local backend ( letta backend local). Letta Cloud is the default and stores agent state. The V1 Python server is retired | 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 with | Letta It's the agent itself: a CLI, chat.letta.com, Slack, Telegram, Discord, and custom channels. /connect adds your own OpenAI, Anthropic, and other model keys | 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 benchmarks | Letta LoCoMo 74.0, from a filesystem agent on GPT-4o mini. 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 October 19, 2026. Benchmark scores are each vendor's own, from separate runs, and aren't directly comparable.
Each Letta agent keeps its own memory in a git-backed folder it edits itself
Letta Code is "a stateful agent harness". You talk to a Letta agent from the CLI, the browser at chat.letta.com, or Slack, Telegram, and Discord, and it rewrites "its own memory, skills, prompts, and even the harness itself" as it learns (README).
Memory lives in MemFS, "a git-backed memory filesystem" the agent can inspect and edit. It "is shared across the agent's conversations", you can teach it directly with /remember, and dreaming runs background subagents that review recent conversations (memory docs). You can sync MemFS to your own GitHub repository.
Memory belongs to the agent. Letta Cloud is the default backend and stores agents' memory and conversations, and letta backend local runs it on your machine (README).
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.
Pick Letta if you want one agent that edits its own memory
Letta fits when you're choosing a new agent. Letta Code agents rewrite their own prompts, skills, and memory, run on schedules, and call each other as subagents (README). Honcho adds memory to the agents you already run, including Claude Code, Codex, OpenCode, Hermes, and OpenClaw, and each one reads the same memory.
Letta's memory is files in git that you can read, diff, and sync to your own repository. Each agent keeps its own files, shared across that agent's conversations (memory docs). Honcho keeps memory outside any one agent, and any agent or app with your key reads it through the API.
Letta Code is Apache-2.0, and you can keep changes to it private. Honcho is AGPL-3.0: if you modify Honcho and run it as a service, you publish your changes. Honcho Cloud has no such requirement.
Honcho gives every agent you use the same memory
Letta gives you one agent with memory. Honcho is memory for whatever you run or build: Claude Code, Codex, OpenCode, Hermes, and OpenClaw, plus your own chatbots, support agents, and products. Each one starts with what the others learned. Memory costs $2 per million tokens ingested.
FAQ
01Do I have to stop using Letta to use Honcho?+
No. Honcho is a memory layer. Install it in Claude Code, Codex, OpenCode, Hermes, or OpenClaw. Letta can keep running beside them.
02Can two Letta agents share memory?+
Each Letta agent keeps its own MemFS. Agents can search each other's conversations with /search (README), and an open issue tracks new agents starting without the memory other agents built (#2666). In Honcho, every agent you connect to the same workspace reads the same representation of you.
03Is Letta or Honcho cheaper?+
Letta prices the agent: Pro is $20 a month for up to 20 agents with a usage quota, and the API plan adds $0.10 per active agent a month plus tool execution time, with LLM usage on top (pricing). Honcho prices memory only: $2 per million tokens ingested, with context reads included, and you keep paying for your agent and model the way you do now (Honcho pricing).
04I'm on the retired Letta server. Can I move?+
Yes. Letta's security policy says the V1 Python server "is retired, unsupported, and receives no fixes or security updates" (SECURITY.md). Send your existing conversations to Honcho as messages and it builds its own representation of each user from them. For a larger move, we can help on a call.
05Can I self-host both?+
Yes. Letta Code runs with a local backend via letta backend local, and some features, like remote computers and secrets, need a Letta sign-in (README). Honcho's honcho start --setup runs the API, Postgres, and Redis on Docker and needs an LLM key, and the hosted service runs the same code.