What Is Letta AI? Stateful Agents with Real Memory

Letta is an open-source platform for building stateful AI agents — agents that remember. Most chatbots forget everything the moment a conversation ends; a Letta agent carries memory forward across sessions, learning and accumulating context over time. It grew out of MemGPT, a research project from UC Berkeley, and turns that research into a practical framework for production agents.

The problem: LLMs are stateless

A large language model has no memory of its own. Everything it “knows” in a conversation has to fit inside its context window, and once that window fills up — or the session ends — the information is gone. For a one-off question that’s fine. For an agent meant to act as a long-running assistant, teammate, or companion, it’s a fundamental limitation.

The usual workaround is to stuff prior context back into every prompt, but context windows are finite and re-sending everything is expensive and lossy. Letta takes a different approach.

The core idea: an LLM as an operating system

Letta’s defining concept is treating the LLM like an operating system managing its own memory. Just as an OS juggles fast RAM and slower disk, a Letta agent manages tiers of memory and decides what to keep in front of it:

• Core memory lives directly in the context window — the agent’s working memory, which it can read and edit itself (for example, updating what it knows about you).
• Recall memory is the searchable history of past conversations, stored outside the context window and queried when relevant.
• Archival memory is long-term storage the agent writes to and searches via tool calls — its long-term knowledge base.

Crucially, the agent manages this memory itself, through tool use, rather than relying on an external pipeline to decide what to inject. It chooses what to remember, what to retrieve, and when to update its own notes.

What you can build with it

Letta is open-source (with a managed cloud option) and model-agnostic — you can run agents on different underlying LLMs. It ships a visual Agent Development Environment for designing and debugging agents, and exposes APIs so agents become services your application can call. Because agents are stateful, they’re a natural fit for:

• Long-running personal assistants that remember your preferences
• Customer-support agents that recall a user’s full history
• Research or coding agents that accumulate knowledge across a project

The project has continued to evolve quickly, including a model-agnostic coding agent (Letta Code) and desktop tooling, but the throughline is constant: memory as a first-class feature of the agent.

How it relates to other agent tech

Letta focuses on the memory and state layer of agents. That’s complementary to standards like the Model Context Protocol, which standardizes how agents connect to tools and data — an agent can have both persistent memory (Letta’s strength) and a clean way to reach external systems (MCP’s strength). It’s part of the broader shift toward capable, autonomous agents covered in our look at the state of AI coding assistants.

The takeaway

Letta is what you reach for when you need an AI agent that persists — one that remembers across sessions and improves over time instead of resetting with every conversation. Its OS-inspired, self-managed memory model (core, recall, and archival tiers) is the practical answer to the statelessness that limits ordinary chatbots. If you’re building an assistant meant to stick around, memory is the missing piece, and Letta is built around it. Learn more at letta.com.