Letta Review 2026: Git-Backed Agent Memory, Thin Public Proof
Introduction
Letta comes from the creators of MemGPT, the UC Berkeley research project on virtual context management. Its homepage now describes an AI research lab building "machines that learn", and the lead product is Letta Agent, which Letta calls "a self-improving AI agent whose memory, identity, and capabilities evolve with experience." The CLI comes from npm as the package @letta-ai/letta-code.
Our overall score is 5.5/10, set on 2026-09-29. Letta's memory design is specific and easy to inspect on paper. The public evidence that it produces better results is weak, and Letta's own estimates show hosted coding work can cost several times the Pro price. This review reports Letta's pages and docs plus one outside article. We did not run the product.
How Letta's memory works
The docs describe MemFS, a memory filesystem backed by a git repository that belongs to the agent. Each memory is a Markdown file with YAML frontmatter, so a memory labelled persona maps to persona.md. Every edit becomes a commit, which gives you version history and conflict handling through a tool you already know.
Context loading follows the folder layout. Files at the memory root load into the system prompt on every turn. A directory with its own MEMORY.md index stays out of context until the agent follows a pointer to it. That makes the cost of a bloated root easy to reason about: everything placed there is paid for in context on each turn.
Search is the main trade-off. Per the docs, MemFS has no semantic or vector index by default, and agents use ordinary file-search and read tools. An optional MemFS Search mod adds keyword search, while semantic and hybrid modes require QMD indexed over the memory directory. If your agent needs fuzzy recall from a large store, plan for that extra piece.
Where it runs
The self-hosting docs describe two shapes. The first is a local runtime through the CLI, with no Letta account required. The second is a self-hosted App Server, which keeps local agents on an always-on machine and exposes them to client apps through the Agent SDK. The CLI needs Node.js 22.19+. Hosted deployment needs a container platform that accepts a Dockerfile, plus persistent storage at /root/.letta.
Self-hosting has real limits. Those agents can't be reached through chat.letta.com, and nothing backs up their state automatically. For local-only agents the MemFS docs say "you are responsible for backing it up." Prompts also still go to any remote model provider you connect, so a fully local setup needs something like an Ollama server.
On the hosted side, the docs list cloud agents with connections to GitHub and Slack, plus hosted MCP and ACP. Local-backend agents can talk through messaging channels covering Telegram, Slack, Discord, Signal, WhatsApp and custom channels. Some older docs pages surfaced in search still label channels as beta and describe different limits, so check the current guide before you commit to one.
Pricing Breakdown
These figures come from Letta's pricing docs.
| Plan | Price | Stateful agents | Storage per memory repository | What you get |
|---|---|---|---|---|
| Free | $0/month | Up to 3 | 5 MiB | No included model usage. Bring your own keys or external coding plans, or buy credits. |
| Pro | $20/month | Up to 20 | 50 MiB | $20 in monthly credits, usable on any model and for remote sandboxes. |
| Teams Pro | $20/seat/month | Not stated | Not stated | Everything in Pro, plus teammates, shared agents and access control. |
| Enterprise | Custom | Not stated | Not stated | Volume pricing, role-based access control, SAML/OIDC SSO and dedicated support. |
The Pro price is easy to misread. Your $20 buys $20 of credits, and credits drain at model API rates. Letta's own estimates, which it says are not guaranteed, suggest chat users often stay inside that allowance and limited coding may fit. Casual coding, described as a few hours a day, typically lands around $100/mo or more, and power users often approach or exceed $200+/mo. So by Letta's own figures, a casual coder on hosted credits pays about five times the Pro price.
Bringing your own keys changes the sums. That usage goes through your provider account and consumes no Letta credits, though you still pay the provider. Client-side tools such as bash in the CLI carry no credit cost, and neither do remote MCP tools. Letta's built-in tools are free apart from web search and fetch. Server-side tools bill CPU time at $0.00015 per second, which works out to $0.54 for an hour.
Forecasting takes some work, because a team bill can combine seats, credits, CPU time and provider charges. One discrepancy needs checking too. Our September record lists a usage-based Developer plan at $0.10 for each active agent, plus metered LLM costs, yet the pricing pages we fetched on 2026-11-09 don't show that plan or charge. Search results still surface it from other sources, so get written confirmation from Letta before you budget around it.
As of 2026-11-09
We captured Letta's pricing page on 2026-11-09. This is a dated capture of public pages, showing prices as they appeared on the vendor's page that day, and it involved no first-hand use of the product.
The entry plan is named "Free" and listed at "$0/month". Pro is listed at "$20/month". Letta's usage estimates put casual coding at around "$100/mo" and say power users can approach or exceed "$200". CPU time for server-side tools is billed at "$0.00015" per second.
How we scored it
Scores come from public evidence (the tool's own pages and documentation, and independent reviews); we do not test every tool hands-on. The numbers are in the full score breakdown. What follows is the evidence behind them, including where it has aged or looks weaker on a second read.
Output quality. The only outside figure is a dev.to post by Everest An that lists Letta at "~83% (LoCoMo)". Our September scoring counted this as independent, and it deserves less weight than that label suggests. The author maintains Awareness, a competing memory layer, and says Letta "points at its own numbers". The post gives no method for the Letta figure and places it in a table column headed LongMemEval R@5, a different benchmark. Read it as a vendor number relayed by a competitor. Letta's featured case studies (Bilt, 11x, Kognitos and Hunt Club) add context but no comparable measurement.
Ease of use. The npm install is simple, but our September check could not find a docs page or any onboarding evidence. The docs home now links a quickstart for the web app or CLI and offers paths by goal, such as coding assistants and recurring automation. Those pages show that guidance exists. They say nothing about how smooth setup is, and we found no independent account of that.
Pricing value. This was the strongest area of the scoring, thanks to a usable free tier, a low Pro price and published unit rates. The usage estimates above temper that for anyone coding heavily on hosted credits.
API and integration. This was the weakest area, because the September check found no API or integration material. The evidence has moved since then. The docs now list an Agent SDK, MCP, ACP, GitHub, Slack and messaging channels, although the docs home has no dedicated API reference section. Treat the published score here as dated until we rescore it.
Problem fit. We found no evidence for this criterion, so it has no score.
Who Is It For
Letta suits a developer building a long-running agent who wants to read, diff and roll back what that agent remembers. Git-backed Markdown is a good fit for that kind of debugging. If you already pay a model provider, the Free plan with your own keys gives you 3 agents to experiment with and no Letta credit spend.
Hold off if you need to justify the purchase with independent results, or if finance wants a predictable monthly number for heavy hosted coding. Teams with strict data rules can self-host, but they take on backups and must choose their model provider with care. If you want to own orchestration and storage yourself, look at LangGraph. If you only want memory added to Claude Code, Claude-Mem is the narrower option.
Verdict
Try Letta on the Free plan with your own API keys. The memory model is concrete, the entry cost is low, and the MemGPT lineage gives the design some research history. Before you rely on it, run your own recall evaluation on your own data, because the ~83% figure can't carry a buying decision.
Don't roll out Teams Pro yet unless your pilot produces results you can defend and you have modelled credit burn against the $100/mo estimate. Move to Pro when you want remote sandboxes or more than 3 agents, and watch your first month of credit use closely.