Letta: Stateful Agents That Actually Remember What They're Doing

You've probably run into the same wall I have with AI agents: they're great at one-off tasks, but the moment you need them to carry context across a conversation—or worse, across days—they forget everything. It's like working with a brilliant colleague who has amnesia. Letta (formerly MemGPT) is built to solve exactly that problem, giving agents persistent memory that they can learn from and improve over time.

Letta is an open-source platform for building stateful agents. The project has moved its active development to a new home, but the core idea remains: instead of treating every interaction as a fresh start, Letta agents carry their memory, identity, and conversations with them wherever they go.

What It Does

Letta is a framework for building agents that maintain state. The current source code lives in the letta-ai/letta-code repository, which includes the agent harness, an interactive terminal UI, an App Server, channel integrations, and the runtime that powers both desktop and web applications.

The project has been around for a while—it started as MemGPT, and the name change to Letta reflects the broader vision. The original V1 server code is preserved on an archive branch for historical reference, but it's explicitly unsupported and shouldn't be used in production.

The tech stack is TypeScript-based, which makes sense for a project that wants to be embedded in modern web applications. You install it via npm, and you can interact with it in several ways: through a terminal UI, a self-hosted server, a desktop app for macOS/Windows/Linux, or through the hosted version at chat.letta.com.

Why It's Cool

Here's what makes Letta interesting to me:

• State is the whole point. Most agent frameworks treat memory as an afterthought—a vector store bolted on the side. Letta is built around the concept of agents that maintain persistent state across sessions. That's a fundamentally different architecture.

• Multiple access points. You're not locked into one interface. You can use the terminal UI for development, run a server for self-hosted deployment, or plug into Slack, Telegram, Discord, and custom channels. The Agent SDK lets you embed Letta agents directly into TypeScript applications.

• Cloud sync for agent identity. Letta Cloud keeps agent memory, identity, and conversations available across computers. That's a practical feature if you're building agents that need to follow you or your users across devices.

• Active development with a clear roadmap. The project isn't abandoned—it's actively developed, just relocated. The README is transparent about where the code lives now and what's supported versus what's archived. That's refreshing.

• The name change makes sense. MemGPT was clever but tied to a specific technique. Letta reflects the broader goal: agents with memory that learn and improve. The rebrand signals maturity.

How to Try It

Getting started is straightforward. First, install Letta from npm:

npm install -g @letta-ai/letta-code

Then launch the interactive terminal UI:

letta

That's the quickest way to start experimenting. If you want to run agents as a service, you can start the App Server instead:

letta server

From there, you have options. You can use the desktop app for a more polished interface, head to chat.letta.com in your browser, or integrate with your team's existing tools like Slack, Telegram, or Discord. If you're building applications, the Letta Agent SDK is the way to go for embedding agents into TypeScript projects.

For the latest installation and deployment instructions, check out the Letta documentation and the active repository at letta-ai/letta-code. The original repo at github.com/cpacker/MemGPT now serves as a landing page, so make sure you're looking at the right place for current code.

One word of caution: if you come across the archived V1 server code, don't use it in production. It's preserved for historical reference and reproducibility, not for real workloads. Stick with the actively maintained letta-code repository.

Final Thoughts

Letta is a solid choice if you're building agents that need to maintain context over time—whether that's a personal assistant that remembers your preferences, a customer support bot that tracks conversation history, or a tool that needs to learn from each interaction. The project is in a transitional phase with the repository reorganization, but the active development is continuing in the new location.

The honest take: if you need stateless, one-shot agents, Letta might be overkill. But if you've been fighting the "my agent forgot everything again" problem, it's worth a look. The terminal UI makes it easy to prototype, and the SDK gives you a path to production. Stateful agents are the direction the field is heading, and Letta is one of the more practical implementations of that idea right now.

Follow @githubprojects for more developer tools and open source projects.