Letta shows up in almost every search for an agent memory layer, and for good reason. It is one of the more credible attempts at giving large language model agents memory that persists across sessions, rather than starting from a blank context window every time. This review looks at what it does well, what it costs, and where its design stops short of what a growing company actually needs.
What Letta actually is
Letta is a Berkeley AI Research Lab spinout, and it raised a $10 million seed round led by Felicis Ventures in September 2024, at a $70 million post-money valuation. The pitch is simple: agents built on top of a large language model forget everything once the context window fills up or the session ends. Letta gives an agent a memory architecture with two tiers, a fast in-context layer for what the agent is actively using, and a persistent store it can write to and pull from later.
That is a real, well-scoped problem, and Letta's engineering answer to it is solid. Its open source repository shows an active project with a clear API for defining memory blocks, tools, and how an agent should decide what to keep. If you are building an agent from the ground up in Python and want to own its memory design, Letta gives you the primitives without forcing a particular architecture on you.
Who Letta is actually built for
Letta's documentation and API are aimed squarely at developers building a single agent, or a small family of related agents, and shipping that as a product. Think a customer support bot, a coding assistant, or a research agent with a defined job. The memory layer belongs to that agent. You decide what it remembers, how long it keeps it, and how it retrieves it.
That is a different starting point from a company that already has a CRM, a wiki, a ticketing system, and a Slack history, and wants an AI layer that understands all of them for whoever is asking, whether that is a person or another piece of software. Letta does not model "who is allowed to see what" as a first-class concept. You would build that yourself, on top of it, if you needed it.
Is Letta good for company context?
For a single well-defined agent, yes. For a shared context layer serving many askers across many of a company's systems of record, it is the wrong shape of tool, not because it is poorly built, but because that was never the job it was designed for. A stateful agents framework and a company-wide context layer solve adjacent problems that look similar from a distance and diverge quickly once you look at entitlement, ingestion from many sources, and staleness.
"Granting LLMs unchecked autonomy to take action can lead to unintended consequences, jeopardizing reliability, privacy, and trust."
OWASP Top 10 for Large Language Model Applications, on excessive agency
That warning is aimed at agent autonomy generally, but it applies directly here. A memory layer that any agent can write to and read from, without a check on who is allowed to see what it stores, is exactly the kind of unchecked surface the warning describes. Letta leaves that check to you.
A worked example
Picture a 12-person startup building a coding assistant as their actual product. Letta is a strong pick here: one agent, one memory store, full control over what it remembers about a codebase and a developer's preferences across sessions. The team wires it up in an afternoon and ships.
Now picture a 90-person logistics company that wants an internal assistant answering questions from support, sales, and finance, each of whom should see different things. Support should not see finance's margin data. A contractor should see less than a full-time employee. Building that on Letta means building an entire entitlement and multi-source ingestion layer around it before the memory problem is even the interesting part. That is the point where the tool and the job stop matching.
Letta pricing and self-hosting
Letta is free and open source to self-host; you run the server yourself and pay only for your own infrastructure. Its hosted Pro tier is priced around $20 a month, aimed at an individual developer running a handful of agents rather than a company-wide deployment with dozens of askers. There is no published multi-tenant entitlement tier because entitlement across many askers is not the product's core job.
| Dimension | Letta | Contextely |
|---|---|---|
| Core unit | One agent's memory | A company's systems of record, shared |
| Entitlement model | Build it yourself | Enforced inside the retrieval scoring function |
| Freshness | Agent-managed, no built-in TTL | Source-set TTL, re-fetches over MCP when stale |
| Self-hosting | Free, open source | Free, Docker, no feature gating |
| Best fit | Developers shipping one agent | Companies giving many askers shared context |
Table 1: Letta and Contextely solve adjacent but different problems; check which one matches your actual use case before picking either.
Common pitfalls when evaluating Letta
- Assuming it solves company-wide access control. It gives one agent memory. It does not decide what a support contractor is allowed to see versus a finance lead.
- Underestimating the ingestion work. Wiring Letta up to a CRM, a wiki, and a ticketing system, and keeping all three current, is work you do yourself, not a feature you switch on.
- Comparing list prices only. The $20 a month Pro tier looks cheap next to enterprise search tools, but it is solving a narrower problem for one developer, not a company-wide deployment.
- Treating "stateful agents" and "company context layer" as the same category. They overlap in vocabulary, not in what they are built to do.
Where Letta fits, honestly
If you are a developer building an agent from scratch and want full control over its memory architecture, in-context and persistent, Letta is a genuinely strong, well-engineered choice, and its self-hosting story is clean. It is a letta alternative to rolling your own memory code from zero, not a company-wide context layer, and it was never trying to be one. Most teams who reach for it already know which of those two jobs they actually have.
If what you actually need is a ready-made layer that already understands your company's existing systems, refreshes itself when a fact goes stale, and enforces who can see what before an answer is drafted rather than after, that is a different piece of infrastructure entirely, closer to plumbing than to an agent framework. Contextely was built for exactly that gap: self-hostable via Docker with no feature gating, entitlement enforced inside the retrieval scoring function rather than as a redaction pass, and both an MCP server and an MCP client so it can refresh itself from your own tools. See how the two compare directly on the Letta comparison page, or check pricing if the free tier is what you are weighing against Letta's Pro plan. For the closest adjacent review, our look at Zep and temporal memory covers the same framework-versus-ready-made-layer question from another angle, and it is worth reading before you commit to either shape of tool.