/

Letta (MemGPT)

  • What it is:Letta (MemGPT) is an open-source agent framework and AI operating system from UC Berkeley researchers that equips stateless LLMs with persistent memory, enabling stateful, self-improving agents.
  • Best for:AI developers building stateful agents, Teams needing model flexibility, Coding agent enthusiasts
  • Pricing:Free tier available, paid plans from $20/month
  • Expert's conclusion:Letta would be best suited for technologically savvy teams developing high-level AI agents that require persistent memory and continuous improvement of themselves; however, it may not fit well as an easy-to-use solution for basic automation or no-code projects.
Visit website
Reviewed byMaxim Manylov·Web3 Engineer & Serial Founder

How Much Does Letta (MemGPT) Cost and What Plans Are Available?

Pricing information with service tiers, costs, and details
☐Service$CostℹDetails🔗Source
Free$03 stateful agents, BYOK (bring your own LLM API keys), ADE access, Letta Code—
Pro$20/monthUnlimited stateful agents, frontier model access, $20 monthly API credits, pay-as-you-go overage—
Max$200/monthEverything in Pro plus higher usage limits, optimized for Letta Code, early access (personal use only)—
EnterpriseCustomVolume pricing, increased quotas, RBAC, SAML/OIDC SSO, dedicated supportOfficial pricing page
Free$0
3 stateful agents, BYOK (bring your own LLM API keys), ADE access, Letta Code
Pro$20/month
Unlimited stateful agents, frontier model access, $20 monthly API credits, pay-as-you-go overage
Max$200/month
Everything in Pro plus higher usage limits, optimized for Letta Code, early access (personal use only)
EnterpriseCustom
Volume pricing, increased quotas, RBAC, SAML/OIDC SSO, dedicated support
Official pricing page

How Does Letta (MemGPT) Compare to Competitors?

FeatureLettaMem0LangGraphCrewAI
Core FunctionalityStateful agents with tiered memoryMemory layerAgent orchestrationMulti-agent teams
Memory SystemBuilt-in tiered (core/archival/recall)Standalone memory APIManual state managementBasic memory
Starting Price$20/moUsage-based$0 (open source)$0 (open source)
Free TierYes (3 agents)YesYesYes
Enterprise FeaturesSSO, RBAC—PartialPartial
API AvailabilityYes (REST API + SDKs)YesYesYes
Model AgnosticYes (OpenAI, Anthropic, local)YesYesYes
Self-HostedYesYesYesYes
Coding AgentYes (Letta Code #1 Terminal-Bench)NoNoNo
Core Functionality
LettaStateful agents with tiered memory
Mem0Memory layer
LangGraphAgent orchestration
CrewAIMulti-agent teams
Memory System
LettaBuilt-in tiered (core/archival/recall)
Mem0Standalone memory API
LangGraphManual state management
CrewAIBasic memory
Starting Price
Letta$20/mo
Mem0Usage-based
LangGraph$0 (open source)
CrewAI$0 (open source)
Free Tier
LettaYes (3 agents)
Mem0Yes
LangGraphYes
CrewAIYes
Enterprise Features
LettaSSO, RBAC
Mem0—
LangGraphPartial
CrewAIPartial
API Availability
LettaYes (REST API + SDKs)
Mem0Yes
LangGraphYes
CrewAIYes
Model Agnostic
LettaYes (OpenAI, Anthropic, local)
Mem0Yes
LangGraphYes
CrewAIYes
Self-Hosted
LettaYes
Mem0Yes
LangGraphYes
CrewAIYes
Coding Agent
LettaYes (Letta Code #1 Terminal-Bench)
Mem0No
LangGraphNo
CrewAINo

How Does Letta (MemGPT) Compare to Competitors?

vs Mem0

The primary difference between Letta and Mem0 is that Mem0 is simply a memory layer and does not provide the same level of functionality as a fully developed stateful agent platform like Letta. Letta is designed to support full agent development whereas Mem0 is merely a memory infrastructure.

For complete agent solutions, use Letta; to add memory to an existing agent use Mem0.

vs LangGraph

Where LangGraph shines in terms of agent orchestration and workflow support it falls short in terms of requiring manual state management. By utilizing an operating-system inspired memory hierarchy, Letta provides automated persistence and self editing memory out-of-the-box.

Use Letta when you need memory-first agents or for complex workflow orchestration use LangGraph.

vs CrewAI

CrewAI has focused on multi-agent collaboration with some memory capabilities whereas Letta focuses on single-agent intelligence using tiered memory that allows for learning and improvement of the agent over time.

If you are looking for an intelligent persistent agent solution, use Letta; if you are looking to build a team of agents, use CrewAI.

What are the strengths and limitations of Letta (MemGPT)?

Pros

  • A pioneering tiered memory architecture — Letta uses an OS-inspired core/archival/recall system from the MemGPT paper for its memory hierarchy.
  • Model-agnostic — Letta supports OpenAI, Anthropic, Mistral, local models, etc., and even includes the ability to bring your own key (BYOK).
  • Self-editing memory — Agents can modify their own memory blocks in real-time, allowing them to modify their memory dynamically during conversation.
  • #1 Coding Agent — Letta Code is the top-rated model-agnostic coding agent according to the Terminal-Bench Benchmark.
  • Cloud and Self-Hosted — Flexibility in deployment options with Letta Server — deploy your agent(s) in either the cloud or on-premises.
  • Academic Foundation — Built upon strong academic foundations — originally created at UC Berkeley BAIR research group — backed by YC with $10 million in funding.
  • Production Ready — REST API + SDKs — ready for use in production environments supporting agent microservices at scale.

Cons

  • Additional Latency — Tiered Memory Architecture — The added latency due to internal tools calls and memory management.
  • Reported Stability Issues — Especially in smaller/local models.
  • Strategy Scope Creep — Originally focused on memory research — pivoted to a full agent platform and then to a coding agent platform.
  • Maximum Plan Limited to Personal Use — Teams creating agent solutions for end-users must switch to the Pro pay-as-you-go plan.
  • Credit-Based Pricing Intransparent — The cost for APIs based on the type/model used — difficult to estimate monthly usage costs.
  • Young Company Risks — Less battle-tested than other popular agent platforms.
  • Some of the community are skeptical about pivoting from a non-commercial or even anti-commercial position towards a commercial position as a way of chasing the hype around commercial AI agents.

Who Is Letta (MemGPT) Best For?

Best For

  • AI developers building stateful agents — Advanced tiered memory architecture addresses LLM context limitation natively, meaning no need for external modules.
  • Teams needing model flexibility — The addition of true multi-LLM support with BYOK eliminates vendor lock-in and supports multiple vendors.
  • Coding agent enthusiasts — Letta Code is currently the number one model-agnostic agent on Terminal-Bench.
  • Researchers prototyping memory systems — Letta has an academic foundation and has its open-source roots. In addition, you have the ability to self-host Letta.
  • Power users with token-intensive workloads — The Max plan is designed to provide a high throughput experience with regard to agentic coding.

Not Suitable For

  • Teams needing simple no-memory agents — While Letta does provide more than enough capabilities for most use cases, it is possible that for very simple stateless use cases, you may find yourself using something like LangGraph or CrewAI.
  • Budget-conscious startups — Pricing for Letta is based upon credit usage which makes it difficult to predict your costs versus those of flat rate competitors.
  • Production teams needing battle-tested stability — We have had reports of stability issues with Letta, and if you want to avoid this problem, there are many more mature frameworks available.
  • Multi-agent orchestration focus — A single-agent memory-first architecture is different than a team-oriented workflow such as that provided by CrewAI and LangGraph.

Are There Usage Limits or Geographic Restrictions for Letta (MemGPT)?

Free Tier Agents
3 stateful agents
Free Tier Models
BYOK required, rotating free models
Pro API Credits
$20 monthly, pay-as-you-go overage
Max Plan Usage
Personal use only, higher daily request quotas
Model Credit Consumption
Varies by model pricing, resets monthly
Enterprise Quotas
Custom volume-based limits
Self-Hosted
Unlimited with own infrastructure

Is Letta (MemGPT) Secure and Compliant?

SAML/OIDC SSOEnterprise plan supports SAML/OIDC authentication
Role-Based Access ControlRBAC available in Enterprise plan
BYOK / BYOC SupportBring your own LLM keys (Free/Pro) and custom model deployments (Enterprise)
Self-Hosted OptionLetta Server deployment gives full infrastructure control
Postgres PersistenceAgents auto-persist state in Postgres with managed cloud or self-hosted
API AuthenticationREST API secured with standard authentication methods

What Customer Support Options Does Letta (MemGPT) Offer?

Channels
All plansEnterprise onlyletta.com/docsFree tier
Hours
Business hours standard, 24/7 dedicated for Enterprise
Response Time
Standard business hours response, priority for Enterprise
Satisfaction
N/A - early stage product
Specialized
Dedicated support for Enterprise customers
Business Tier
Volume pricing includes dedicated support for Enterprise
Support Limitations
•Free tier limited to community/documentation support
•No live chat or phone support mentioned
•Dedicated support Enterprise-only

What APIs and Integrations Does Letta (MemGPT) Support?

API Type
REST API with full-featured agents API
Authentication
API Key authentication via LETTA_API_KEY
SDKs
Python SDK (letta_client), JavaScript/TypeScript SDK (@letta-ai/letta-client), Rust client library
Documentation
Comprehensive at docs.letta.com with interactive code examples and core concepts guides for memory management and agent configuration
Key Features
Agent creation and management, memory block manipulation (retrieve, update, create), message handling with streaming support, stateful agent persistence
Use Cases
Building stateful AI agents with persistent memory, creating agents that learn and self-improve, integrating agents with custom applications, managing agent memory blocks programmatically

What Are Common Questions About Letta (MemGPT)?

Letta is the platform for creating stateful agents with advanced memory that can learn and improve themselves over time. MemGPT was migrated to Letta and expanded the scope of the project to create a full platform with APIs, SDKs, and production ready deployment options. Letta takes an LLM Operating System approach to memory management.

Letta organizes memory into a hierarchy of in-context and out-of-context memory. The memory used by agents is organized into persistent, editable blocks of memory that agents can autonomously edit, delete or search through. These blocks allow agents to retain context longer than they would normally be able to given token limits and allow them to learn and improve over time.

Letta has SDKs for Python, JavaScript/TypeScript, and Rust which will allow developers to create agents in whatever language they prefer. All of the SDKs will interface with the same REST API to ensure consistent interaction with the platform.

Yes, Letta is completely model-agnostic. You can use OpenAI models, local models through the LM Studio, and other models. Agents support both OpenAI and other models that you configure through the API.

Memory blocks can be defined at initialization of an agent with a label and value. They can also be modified programmatically via the API and retrieved so you can see what data is stored in each block. Common blocks include 'human' for user information and 'persona' for agent behavior.

Yes, Letta provides a method for generating streamable output, enabling real-time response to user input to provide a better user experience in conversational applications.

Yes, Letta is Open Source and is hosted on GitHub (github.com/letta-ai/letta). Additionally, it is production ready and can be installed either locally or using the Letta API Service.

Each Agent in Letta maintains an infinite (perpetual) message history, providing each agent with knowledge of all prior conversations and permitting continuous learning and improvement by drawing upon all previous interactions.

Is Letta (MemGPT) Worth It?

Letta represents a novel way of implementing Stateful AI Agents utilizing a persistently managed memory system developed from the foundation of the MemGPT research paper. This platform includes the production ready APIs and SDK's to fully utilize the Memory Hierarchy and Agentic Context Engineering included within this platform; however, the platform is relatively new and its ecosystem is still developing as opposed to existing automation platforms.

Recommended For

  • AI Developers and Researchers working with Advanced Agent Applications
  • Teams Developing Conversational AI that Requires Persistent User Context
  • Organizations Wanting Model-Agnostic Deployment of Their Agents
  • Organizations Requiring Agents that Can Learn and Improve Over Time
  • Developers Comfortable With Using APIs and SDKs Seeking Programmatic Control

!
Use With Caution

  • Teams Needing Extensive Pre-Built Integrations – Letta Focuses On Agent Capabilities Rather Than Application Connectors
  • Organizations Requiring Extensive Support and Professional Services
  • Projects That Require Extremely Tight Latency Requirements - Agent Decision Making Adds Processing Time

Not Recommended For

  • No Code Users Seeking Visual Workflow Builders
  • Teams Needing Simple Rule-Based Automation - Traditional Tools Are More Cost Effective
  • Organizations Requiring Compliance Certifications And/or Service Level Agreement (SLA) Guarantees
Expert's Conclusion

Letta would be best suited for technologically savvy teams developing high-level AI agents that require persistent memory and continuous improvement of themselves; however, it may not fit well as an easy-to-use solution for basic automation or no-code projects.

Best For
AI Developers and Researchers working with Advanced Agent ApplicationsTeams Developing Conversational AI that Requires Persistent User ContextOrganizations Wanting Model-Agnostic Deployment of Their Agents

What do expert reviews and research say about Letta (MemGPT)?

Key Findings

Letta is a modern AI Agent Framework based upon the MemGPT research paper. It has stateful agents that have persistent, editable memory blocks and perpetual message history. Letta offers production-ready REST APIs and SDKs (Python, JavaScript, Rust); model-agnostic support; and agents can run locally or through the cloud. Letta is an open-source project and is actively being developed with a focus on memory management and agentic context engineering.

Data Quality

Good - comprehensive information from official Letta documentation, GitHub repository, and API reference. Some enterprise features and pricing details may require direct contact with the company.

Risk Factors

!
Newer AI Agent Platform compared to traditional automation tools
!
Smaller number of integrations and templates available for the community
!
AI technology is still developing with future features in development
!
Developers are required to implement Letta
Last updated: February 2026

What Additional Information Is Available for Letta (MemGPT)?

Research Foundation

Letta was developed on top of a peer reviewed research paper that introduced the concept of a Long-Term Memory Management system called the LLM Operating System for managing memory in agents. The MemGPT research paper established the foundational concepts of self-editing memory, memory hierarchy, and agentic context engineering that differ Letta from all other AI Agent Platforms.

Open Source & GitHub

Letta is an open-source project located at GitHub (github.com/letta-ai/letta). There is active development occurring on this platform with examples of how to implement Letta, reporting issues, and community input. Users can deploy Letta either locally or utilize the managed Letta API Service.

Core Technology

Letta’s architecture separates agent memory into two types: persistent memory that is editable both in and outside of the current context window. Agents manage their own context window by having tools available to them to edit, delete, or search memory and enable agents to continuously improve and learn.

Integration Flexibility

Unlike many of today’s popular automation tools, Letta is totally model-agnostic. That means it can use models from OpenAI, as well as your own local models, or just about any other Large Language Model (LLM) provider you prefer. At the same time, all of these different models are run through the exact same agent framework and memory management systems.

Developer-First Approach

To help make development easier, Letta has a wealth of documentation, including examples written in several programming languages and an easy-to-understand API design. In addition, the Letta Platform is designed to be completely programmatically accessible so that you can create and manage your own agents and manipulate memory programmatically.

What Are the Best Alternatives to Letta (MemGPT)?

  • •
    LangChain: A popular, open source framework for creating applications that utilize large language models with memory and agents. More mature ecosystem with many integrations available. While LangChain is very good at providing flexibility and integration options for developers, Letta is great at creating stateful agents that have persistent memory. Therefore, if you want to provide your end-users the most flexibility and access to various integrations possible, then LangChain might be the better choice for you. (langchain.com)
  • •
    AutoGPT: An open source autonomous AI agent framework that supports self-improvement. While AutoGPT focuses on running tasks autonomously, Letta focuses on providing persistent memory and supporting user interactions. To get started with AutoGPT, you will need to set up and configure much more than with Letta. Therefore, AutoGPT may be best suited for those who are researching or developing autonomous agents. (github.com/Significant-Gravitas/AutoGPT)
  • •
    Zapier: A no-code automation platform that offers over 5,000 app integrations. Zapier allows users to create visual workflows without writing any code. However, Zapier does not offer native AI memory or learning capabilities like Letta. Therefore, if you are looking to simply automate apps and do not require AI-based memory or learning capabilities, then Zapier may be the best choice for you. (zapier.com)
  • •
    OpenAI Assistants API: The official API for building AI Assistants using GPT models and providing file management and basic memory functionality. If you plan to build AI Assistants using OpenAI models, then this API may be the easiest to use. However, this API has limited memory management capabilities when compared to the memory management capabilities of Letta’s architecture. Additionally, since this API is only compatible with OpenAI models, it may not be as flexible as Letta if you wish to integrate multiple models into your application. (platform.openai.com/docs/assistants)
  • •
    CrewAI: A framework to orchestrate multiple AI agents to collaborate. It emphasizes multi-agent coordination and role-based workflows. The less it does in terms of persistent memory per agent. It is ideal for developing complex multi-agent systems. (github.com/joaomdmoura/crewAI)

What Are Letta (MemGPT)'s Core Evaluation Metrics?

Unlimited effective context via memory hierarchy
Context Management Efficiency
Multi-session retention hierarchical memory
Conversation Persistence
High precision retrieval vector database integration
Semantic Search Accuracy
Autonomous memory management LLM-driven
Self-Editing Capability
Beyond LLM context window external memory tiers
Document Analysis Capacity
Multiple distinct agents role-based memory
Agent Persona Support

Letta (MemGPT) Architecture Components

Virtual Context Management

An operating system-inspired memory hierarchy that uses a main context (RAM) and an external context (disk).

Core Memory

Compressed essential facts and persona information are always accessible.

Recall Memory

Semantic search database used to rebuild prior interactions.

Archival Memory

LanceDB default long-term vector database storage for all significant information.

Self-Directed Memory Editing

LLM has complete autonomous control over managing memory using tool calls and function chaining.

Agent Persona System

Agents created have unique roles, knowledge bases and behavior attributes.

Multi-Tier Storage Hierarchy

Dynamic data movement is allowed between context tiers for unbounded context processing.

Cognitive Triage

LLM determines which information is most valuable for retention versus summarizing.

Letta (MemGPT) Adoption Metrics

Research Foundation
arXiv paper (2023) - foundational OS approach to agent memory
Commercial Availability
Letta.com production framework
Agent Memory Innovation
First LLM-as-memory-manager architecture
Vector Database Integration
LanceDB default for semantic search
Multi-Agent Persona Support
Distinct agent creation and management
Educational Recognition
DeepLearning.AI course material
Context Pollution Reduction
Precision-focused memory management

What Is Letta (MemGPT)'s Regulatory Compliance Requirements Status?

Data Persistence SecurityExternal memory encryption required
Memory Access ControlsAgent isolation needed for multi-tenant
Audit Trail GenerationMemory edit operations logged
PII Handling in MemorySemantic search PII detection recommended
Context Window IsolationMain/external context separation
Agent Persona GovernanceRole-based access controls needed

Letta (MemGPT) vs Leading Frameworks

FrameworkMemory ManagementContext HandlingAgent OrchestrationSelf-EditingLearning Curve
Letta (MemGPT)OS-style hierarchyUnlimited via tiersPersona-based agentsLLM autonomousModerate
LangChain + LangGraphExternal vector storesContext window limitedDAG workflowsExternal toolsModerate
CrewAITask memoryStandard contextRole-based teamsLimitedLow
AutoGenConversation historyContext windowsMulti-agent chatNo self-editingModerate-High
LlamaIndexRAG-focusedRetrieval basedQuery agentsIndex managementLow-Moderate

Letta (MemGPT) Security Strategies

Memory Tier Isolation

Main context is separated from external storage so all of the data will not be exposed at once.

Self-Editing Audit

All LLM memory operations are recorded as traces for auditing and reviewing.

Semantic Search Filtering

Queries made against a vector database allow you to implement access controls and filter out PII.

Agent Persona Containment

There are separate memory spaces for each agent to help prevent cross-contamination.

External Context Validation

Memories retrieved are verified before they are inserted into the main context.

Function Call Sandboxing

Tools to manage memory are run within a controlled environment.

Letta (MemGPT) Enterprise Use Cases

Persistent Customer Support AgentsLong-term Project Memory ManagementDocument Analysis Beyond Context LimitsMulti-Session Relationship BuildingPersona-Based Enterprise AssistantsLegal Contract AnalysisResearch Paper ProcessingKnowledge Worker Memory AugmentationCross-Session Workflow ContinuityPersonalized Enterprise AI Companions

Letta (MemGPT) Production Requirements

Memory Storage Backend
Vector database (LanceDB default)
LLM Provider Support
Multi-LLM compatible (OpenAI, etc.)
Context Management
Automatic tiered hierarchy
Agent Persistence
Stateful across sessions
Scalability Pattern
Agent sharding by persona
Observability
Memory operation logging
Deployment Model
Cloud-native framework
API Integration
Function calling interface

Expert Reviews

📝

No reviews yet

Be the first to review Letta (MemGPT)!

Write a Review

Similar Products

Botpress
botpress.com
Rasa
rasa.com