Letta

Letta (formerly MemGPT) is an open-source framework for building stateful AI agents with persistent memory. Born from the MemGPT research paper ("Memory-GPT") at UC Berkeley in 2023, it gives agents a memory hierarchy: core memory blocks stay in-context while external memory is stored in Postgres and loaded as needed. This lets agents remember conversations indefinitely without blowing up their context windows.

Key Features

• Memory Hierarchy: Core memory blocks in-context plus external memory in Postgres, loaded on demand — agents remember everything across sessions.
• Sleep-Time Compute: Agents process and store memories between conversations — memory reflection and agentic memory built in.
• Editable Memory Blocks: Memory blocks can be inspected and edited by tools, giving transparent state.
• Client-Server Architecture: Letta 2.0 splits the agent loop into a client library and a state server (letta-server) for multi-agent support.
• Self-Hostable: Deploy with Docker; REST API and Python SDK included.
• ADE (Agent Development Environment): Letta Cloud IDE for building agents visually.
• Managed Cloud: Letta Cloud for hosted agents with the same memory engine.
• Use Cases Proven: Personal AI companions, support agents, research assistants, and long-running autonomous agents.

Use Cases

Who Should Use This Tool?

• Memory-Critical Agents: Builders of assistants that must remember users, projects, and conversations over long periods.
• Self-Hosters: Teams that want their agent memory engine on their own infrastructure.
• Research & Companionship: Personal AI companions and research assistants needing persistent context.

Problems It Solves

1. Context window limits: External memory means unlimited conversation history without context bloat.
2. Session amnesia: Agents remember across sessions, not just within one.
3. Memory transparency: Editable memory blocks make agent state inspectable.

Pricing

Advantages & Unique Selling Points

Compared to Competitors:

1. Proven memory model: Backed by the MemGPT paper and years of agent-memory research.
2. Self-hostable state server: Your agents' memory lives on your infrastructure.
3. Sleep-time compute: Memory reflection that competitors lack.

What Makes It Stand Out:

• 15,000+ GitHub stars and a strong research pedigree.
• Editable, inspectable memory blocks.
• From self-hosted server to managed cloud in one stack.

Getting Started

Quick Start Guide

1. Install: pip install letta or use the Docker image.
2. Start the server: Run letta-server (or use Letta Cloud).
3. Create an agent: Use the Python SDK or ADE to define your agent with memory blocks.
4. Chat: Your agent now remembers across sessions automatically.

Integration

Integrates with:

• Docker self-hosting
• Python SDK and REST API
• Letta Cloud and ADE

Frequently Asked Questions

How is Letta different from other agent frameworks?

Its core focus is persistent memory — the MemGPT memory hierarchy that survives sessions without context bloat.

Does it require a database?

Yes — external memory is stored in Postgres, giving durable, queryable agent memory.

Can I self-host it?

Yes — the server is open source and runs with Docker; Letta Cloud is the managed alternative.

Alternatives

If Letta isn't the right fit, consider these alternatives:

• LangGraph: Stateful orchestration with built-in memory via checkpoints.
• CrewAI: Role-based teams with delegation and memory.
• Google ADK: Google's framework with shared state across agent teams.

Tips & Best Practices

1. Design memory blocks deliberately: What an agent should always remember belongs in core blocks.
2. Use sleep-time compute: Let agents reflect and consolidate between conversations.
3. Inspect memory via tools: Editable blocks give you transparency and control over state.

Conclusion

Letta is the framework that makes agent memory a solved problem — persistent, inspectable, and self-hostable, with the MemGPT research pedigree behind it. If your agents must remember across sessions and contexts, Letta is the most proven choice in the category.