Letta
Self-improving AI agents with persistent memory and continual learning
Letta is the most ambitious memory-first agent platform we've seen, backed by serious research, but it's early-stage and demands hands-on engineering. If you need agents that genuinely learn and remember, it's worth the effort; for plug-and-play deployments, look elsewhere.
Verified 23h ago · liveness 78/100 · cite: rightaichoice.com/tools/letta
- Long-running AI agents needing persistent memory and continual learning
- Researchers and developers experimenting with continual learning
- Customer support bots that remember every interaction and improve
- Personal AI assistants that adapt to user behavior
- Simple one-shot chatbot use cases
- Teams needing plug-and-play agent with no engineering overhead
- Production deployments requiring mature ecosystem and extensive integrations
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Letta if you need a plug-and-play agent with minimal engineering, require real-time inference without offline learning, or want a mature ecosystem with extensive integrations.
Using Letta Auto beyond the included weekly/monthly quota incurs pay-as-you-go rates, which can add hundreds of dollars for power users (e.g., $200+/mo for heavy coding or long sessions).
Letta's freemium model suits individual developers and researchers exploring memory-first agents, with BYOK keeping costs low. Pro at $20/mo is competitive, but heavy usage can exceed $200/mo, so team plans or external coding plans may be cheaper. Compared to AutoGPT (free, open-source) or LangChain (free, but you pay for models), Letta's managed tiers add convenience but not necessarily value for pure orchestration needs.
In short
Letta — Self-improving AI agents with persistent memory and continual learning. Best for Long-running AI agents needing persistent memory and continual learning, Researchers and developers experimenting with continual learning, Customer support bots that remember every interaction and improve. Free to start; paid plans from $20/mo.
What's new in Letta
Checked 12 days agoAcross the latest 4 updates: 3 feature updates and 1 launch.
Letta Agents SDK: An SDK for stateful agents
The Letta Agents SDK lets developers build stateful, persistent agents that keep identity, memory, and experience across models, machines, and interfaces.
Introducing Mods: Enabling Agents to Self-Improve through Harness-Level Adaptation
Letta Code now supports Mods, an agent-friendly way to extend and adapt the Letta Code harness for self-improvement.
Introducing the Letta Code App
The Letta Code app offers a local interface for deeply personalized agents that learn over time on your machine.
Remote Environments for Letta Code
Remote environments let you message an agent working on your laptop from your phone, enhancing accessibility.
Viability Score
How well maintained and how widely used is Letta? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: September 2026
How we score →Key Features
- Persistent memory with git-based versioning (Context Repositories)
- Sleep-time compute for offline learning and reflection
- Context Constitution for governing agent context management
- Continual learning in token space
- Mods extension system for agent self-improvement
- Conversations API for shared memory across concurrent experiences
- Multi-channel support: Slack, Telegram, Discord, WhatsApp, Signal
- Schedules and cron jobs for automation
- Remote environments for always-on access to Letta Code agents
- BYOK (bring your own API keys) for all plans
- Letta Auto model selection (Auto, Auto Chat, Auto Fast)
- npm installable agent package (Letta Code CLI)
- Desktop app for macOS/Windows/Linux (Letta Code)
- Web interface at chat.letta.com
- Local interface for personalized agents (Letta Code app)
About Letta
Letta is a San Francisco AI research lab building machines that learn, producing the Letta Agent—a stateful, self-improving AI agent designed to remember everything, learn continuously, and evolve its identity over time. Founded by the creators of MemGPT from UC Berkeley's Sky Computing Lab, Letta translates cutting-edge research into production-ready software, including the Letta Code CLI (npm package), a desktop app for macOS, Windows, and Linux, and a web interface at chat.letta.com. What sets Letta apart is its memory architecture. Context Repositories provide git-based versioning for agent memory, letting you track, branch, and revert changes like code. Sleep-time compute enables offline reflection during idle time, so agents learn without slowing down inference. Mods, introduced in 2026, are harness-level adaptations that let agents self-improve by extending the Letta Code harness. The Context Constitution governs how agents manage context, and continual learning in token space means agents improve with every interaction. The Conversations API enables shared memory across concurrent experiences, making Letta ideal for long-running, memory-intensive tasks like personal assistants, coding agents, and customer support bots that remember every exchange. Multi-channel support includes Slack, Telegram, Discord, WhatsApp, and Signal, plus schedules and cron jobs for automation. Remote environments let you message an agent working on your laptop from your phone. Letta is freemium with a free tier limited to 3 stateful agents, a Pro plan at $20/month, and developer and team plans for scaling. Compared to orchestration frameworks like AutoGPT or LangChain, Letta prioritizes persistent memory and continual learning over prompt chaining—it's for teams that need agents to truly learn and adapt over long horizons.
Behind the Verdict
Letta is not a tool for the faint of heart. It's a research-grade platform that expects you to wrangle memory systems, git-based versioning, and occasional rough edges. The payoff is an agent that actually improves over time, which is rare. If your use case involves long-running assistants, customer support bots that recall every interaction, or coding agents that learn your codebase, Letta's memory-first design is a genuine edge. The sleep-time compute and Mods system are unique—they let agents reflect and adapt without slowing down real-time interactions. Where it bites: the free plan limits you to 3 agents, and power users on Pro will quickly find Letta Auto's quota insufficient for heavy coding. The docs suggest casual coding users spend ~$100/month and power users over $200, so factor that in. The ecosystem is small, and you'll likely need to write custom code to fit Letta into production stacks. There's no mature marketplace of prebuilt integration, so you'll rely on your own engineering. Compared to AutoGPT or LangChain, which focus on orchestration and prompt chaining, Letta's edge is memory and continual learning. But if you need a framework that just works out of the box with broad community support, those are safer bets. For coding-focused memory agents, Claude Code or Codex offer smoother onboarding, though they don't provide Letta's persistent memory across sessions. In practice, we'd reach for Letta when the core problem is remembering and learning over long horizons—not for building a simple chatbot or a quick prototype. It's a bet on a future where agents evolve, and if you're willing to invest in that vision, Letta is the most focused implementation we've seen.
Researching Letta? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Letta actually fits — and what changes day-one when you adopt it.
Install Letta Code CLI, create a stateful agent with your OpenAI API key, and configure memory settings using Context Repositories.
Outcome: Within a day, you have an assistant that remembers your preferences, project details, and past conversations, improving over time via sleep-time compute.
Sign up for Teams Pro, connect Slack and Telegram channels, and use GitHub integration to feed the bot with your product docs.
Outcome: In a week, the bot handles repeat customers with context, learns from resolutions, and reduces support tickets by 30%.
Use the Letta API (API Plan) to spawn multiple agents with different memory configurations and run a benchmark on long-conversation tasks.
Outcome: You can compare memory approaches and publish findings, with usage billed predictably at $0.10 per active agent per month.
Use Cases
- Build a coaching agent that remembers user goals, progress, and preferences across months.
- Ship a customer-service agent that recognizes repeat customers and previous conversations.
- Research how main-plus-external context compares to pure RAG on long-conversation benchmarks.
- Prototype a companion app with an agent that accumulates real relationship history.
- Create a coding agent that learns your project conventions over time via Letta Code.
- Run a persistent research assistant that builds knowledge from ongoing queries.
- Automate business workflows with scheduled agents that learn from each run.
- Develop a personal AI assistant that adapts to your behavior and preferences.
Models Under the Hood
as of 2026-08-31
Limitations
- Letta is an AI research lab building self-improving AI agents with persistent memory and continuous learning.
- Free plans are limited to 3 stateful agents, and Pro plans offer remote sandboxes and usage quota for Letta Auto.
- Developer plans are usage-based for building on the Letta API.
- The platform supports Bring Your Own API keys and the research is grounded in the MemGPT project from UC Berkeley.
as of 2026-08-28
Verification history
We have re-verified Letta 18 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 18 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Letta tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
$0/month
Ideal for
Solo developers and researchers exploring Letta with their own API keys, needing up to 3 stateful agents for experimentation.
What this tier adds
Starting tier: limited to 3 stateful agents, limited Letta Auto usage, and requires BYOK.
Pro
$20/month
Ideal for
Individual power users who want remote sandboxes, more agents (up to 20), and included Letta Auto quota for personal projects.
What this tier adds
Adds up to 20 agents, Letta Auto weekly + monthly quota, pay-as-you-go overage, and remote sandboxes.
API Plan
$20/month
Ideal for
Developers and teams building on the Letta API with automated workloads, needing unlimited agents and usage-based pricing.
What this tier adds
Switches to API key authentication with $0.10 per active agent/month and $0.00015 per second of tool execution, instead of personal quotas.
Teams Pro
$20/seat/month
Ideal for
Teams wanting to share agents and collaborate, with per-seat pricing and access control.
What this tier adds
Adds team collaboration features: member invitations, shared agents, and access control, on top of all Pro features.
Enterprise
Custom
Ideal for
High-volume enterprises needing custom quotas, SSO, and dedicated support.
What this tier adds
Adds volume-based pricing, increased quotas, role-based access control, SAML/OIDC SSO, and dedicated support.
Where the pricing makes sense
The company stage and team size where Letta's pricing actually pencils out — and where peers do it cheaper.
Letta's freemium model suits individual developers and researchers exploring memory-first agents, with BYOK keeping costs low. Pro at $20/mo is competitive, but heavy usage can exceed $200/mo, so team plans or external coding plans may be cheaper. Compared to AutoGPT (free, open-source) or LangChain (free, but you pay for models), Letta's managed tiers add convenience but not necessarily value for pure orchestration needs.
Setup time & first value
How long it actually takes to get something useful out of Letta — broken out by persona, not the marketing-page minute.
For a solo developer: 15 minutes to install the CLI and create your first agent with BYOK. For a team: half a day to set up Teams Pro, invite members, and connect channels. For API developers: <1 hour to get a basic agent running, but fine-tuning memory settings may take a few days.
Switching to or from Letta
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From AutoGPT: Import your agent's goal descriptions and use Letta's git-based memory to version your state, then rebuild workflows with Letta's explicit memory API.
- →From LangChain: Port your chain logic into Letta's agent harness, using MemFS to manage context instead of manual prompt engineering.
- →From a basic chatbot (e.g., a RAG pipeline): Encode your documents as context repositories, and add sleep-time compute to enable continuous learning.
- ↗To AutoGPT: Export your agent's memory as a context dump and load it into AutoGPT's own memory system, though you'll lose git versioning.
- ↗To LangChain: Reimplement your agent's tools and memory using LangChain's memory modules, but note you'll need to manually manage context.
- ↗To a custom solution: Use Letta's API to extract conversation logs and memory states, then transition to your own infrastructure.
Integrations
Resources & Guides
- Resourceletta.com
Letta
Making machines that learn. Create stateful agents that remember everything, learn continuously, and improve themselves over time.
- Resourceletta.com
Pricing
Try Letta Code for free
- Resourceletta.com
Blog
Helpful link from letta.com
- Resourcedocs.letta.com
Letta Code
The memory-first coding agent that remembers and learns
Tutorials & Learning
YouTube returned 6 videos for “Letta”, and we withheld 6: 6 could not be judged, because “Letta” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Letta.
Official links
Frequently Asked Questions
Categories
Used Letta? Help shape our editorial sentiment research.