Vendor: letta-ai
Letta (formerly MemGPT) is a stateful agent platform from UC Berkeley, pioneering OS-inspired hierarchical virtual memory paging for lifelong, self-editing agent memory and persona persistence.
| Repository | letta-ai/letta |
|---|---|
| GitHub Stars | ★ 24.5k |
| Forks | 2.6k forks |
| Primary Language | Python |
| License | Apache-2.0 |
| Technical Domain | AGENTS |
$ bash
pip install letta
Letta (letta-ai/letta, formerly MemGPT) is an open-source stateful agent architecture and memory platform developed by Charles Packer and the UC Berkeley AI research team. In standard LLM interactions, an agent's memory is bounded by the model's fixed context window—once conversation length exceeds capacity, earlier facts are irreversibly truncated. Letta breaks this limitation by drawing a groundbreaking architectural analogy to operating system virtual memory paging.
Architecturally, Letta treats the LLM context window as high-speed RAM and persistent vector databases as disk storage. It organizes agent memory hierarchically into:
1. Core Memory: In-context persistent blocks containing the agent's persona and user profile, editable via autonomous internal function calls;
2. Recall Memory: A chronological event log of past conversational interactions;
3. Archival Memory: An out-of-context semantic vector store for large-scale external knowledge.
In terms of autonomous agent skills, Letta equips agents with self-editing memory capabilities. When a user reveals a new preference, the agent autonomously invokes memory tools to update its Core Memory blocks. When solving complex multi-session tasks, the agent autonomously pages relevant archival memories into active context, delivering lifelong continuity and personalized evolution.
Letta (originally MemGPT) marked the paradigm shift of code AI from stateless conversational bots to stateful digital minds. In conventional RAG setups, models receive external context passively without the ability to self-modify long-term beliefs or develop persistent, evolving personas through continuous user interactions.
The UC Berkeley AI research team drew inspiration from computer architecture: operating systems do not load entire hard drives into RAM, but page memory blocks as needed. Similarly, an LLM only needs its core persona and active working memory in context (RAM), dynamically swapping historical and archival knowledge via autonomous memory tools. This paradigm revolutionized agent memory engineering.
In state machine design, Letta gives the agent active control over its own cognitive state. Rather than a passive text generator, the agent is an active computational entity capable of issuing system-level interrupts and memory primitives.
In lifelong personalized AI assistance, agents remember personal preferences, family details, professional domains, and coding quirks across hundreds of sessions spanning years.
In enterprise CRM and long-horizon client management, agents maintain dedicated memory blocks per client, updating budget limits and decision stakeholders autonomously during each interaction.
In multi-week software engineering collaboration, agents preserve architectural rationale and legacy decisions, ensuring design coherence across long development sprints.
In immersive gaming and NPC simulations, non-player characters maintain episodic memories, dynamically evolving trust and behavioral patterns based on cumulative player history.
Install Letta via pip:
pip install lettaLaunch the local Letta server and Agent Development Environment (ADE):
export OPENAI_API_KEY="your-key"
letta serverCreate and interact with a stateful agent with persistent core memory in Python:
from letta import create_client
# 1. Connect to local Letta client
client = create_client()
# 2. Instantiate persistent agent with initial core memory
agent_state = client.create_agent(
name="personal_mentor",
memory={
"persona": "You are a patient AI architecture mentor who explains concepts via operating systems analogies.",
"human": "The user is a senior engineer exploring agent memory architectures."
}
)
# 3. Message the agent and observe autonomous memory self-editing
response = client.user_message(
agent_id=agent_state.id,
message="Hello! Please note that I am primarily developing high-throughput middleware in Rust."
)
print("Agent:", response.messages[-1].text)
# 4. Verify updated core memory
updated_memory = client.get_agent_memory(agent_id=agent_state.id)
print("Updated Human Core Memory:", updated_memory.core_memory.human)Inspect and edit memory blocks visually using the web ADE interface at http://localhost:8283.
In architectural maturity, Letta evolved from a research prototype into an enterprise-grade Server-Client architecture backed by PostgreSQL persistence, supporting multi-tenant concurrency and containerized cluster deployments.
Regarding model compatibility, because Letta relies on autonomous memory tool dispatches (core_memory_append, archival_memory_search), it performs best with frontier models (Claude 3.7, GPT-4o) or specialized fine-tuned agent weights capable of precise function calling.
For context window governance, Letta triggers automated recursive background summarization when active recall queues reach saturation.
With over 24,500 GitHub stars, Letta (MemGPT) is recognized worldwide as the premier stateful agent memory standard, supported by venture backing and active contributions from UC Berkeley researchers.
Enterprise healthcare assistants, personal AI companions, and long-horizon autonomous coding systems incorporate Letta as their foundational cognitive state engine.
In an eldercare robotic companion deployment, Letta-powered agents maintained persistent memories over 6+ months, increasing engagement and user trust metrics threefold compared to stateless baselines.
Letta (formerly MemGPT) - OS-Style Hierarchical Memory & Stateful Agent Platform is an open-source AI project developed primarily in Python under the Apache-2.0 license. Letta (formerly MemGPT) is a stateful agent platform from UC Berkeley, pioneering OS-inspired hierarchical virtual memory paging for lifelong, self-editing agent memory and persona persistence.. Letta (originally MemGPT) marked the paradigm shift of code AI from stateless conversational bots to stateful digital minds. In conventional RAG setups, models receive external context passively without the ability to self-modify long-term beliefs or develop persistent, evolving personas through continuous user interactions. The UC Berkeley AI research team drew inspiration from computer architecture: operating systems do not load entire hard drives into RAM, but page memory blocks as needed. Similarly, an LLM only needs its core persona and active working memory in context (RAM), dynamically swapping historical and archival knowledge via autonomous memory tools. This paradigm revolutionized agent memory engineering. In state machine design, Letta gives the agent active control over its own cognitive state. Rather than a passive text generator, the agent is an active computational entity capable of issuing system-level interrupts and memory primitives.
Install Letta via pip:
pip install lettaLaunch the local Letta server and Agent Development Environment (ADE):
export OPENAI_API_KEY="your-key"
letta serverCreate and interact with a stateful agent with persistent core memory in Python:
from letta import create_client
# 1. Connect to local Letta client
client = create_client()
# 2. Instantiate persistent agent with initial core memory
agent_state = client.create_agent(
name="personal_mentor",
memory={
"persona": "You are a patient AI architecture mentor who explains concepts via operating systems analogies.",
"human": "The user is a senior engineer exploring agent memory architectures."
}
)
# 3. Message the agent and observe autonomous memory self-editing
response = client.user_message(
agent_id=agent_state.id,
message="Hello! Please note that I am primarily developing high-throughput middleware in Rust."
)
print("Agent:", response.messages[-1].text)
# 4. Verify updated core memory
updated_memory = client.get_agent_memory(agent_id=agent_state.id)
print("Updated Human Core Memory:", updated_memory.core_memory.human)Inspect and edit memory blocks visually using the web ADE interface at http://localhost:8283.
Letta (formerly MemGPT) - OS-Style Hierarchical Memory & Stateful Agent Platform is well-suited for Lifelong Personalized AI Assistants, Multi-Session Long-Horizon Customer CRM Agents, Long-Term Project Collaboration Partners, Persistent Role-Playing & Virtual Companions. With an overall rating of 4.8/5, it offers strong community activity, reliable performance, and easy integration with existing AI pipelines.
In architectural maturity, Letta evolved from a research prototype into an enterprise-grade Server-Client architecture backed by PostgreSQL persistence, supporting multi-tenant concurrency and containerized cluster deployments. Regarding model compatibility, because Letta relies on autonomous memory tool dispatches (core_memory_append, archival_memory_search), it performs best with frontier models (Claude 3.7, GPT-4o) or specialized fine-tuned agent weights capable of precise function calling. For context window governance, Letta triggers automated recursive background summarization when active recall queues reach saturation.
Minimal tool for running large language models locally