Letta

Letta now supports R1 through the DeepSeek AI API! 🐋 Checkout the latest 0.6.28 release and the ADE (Agent Development Environment) to build stateful agents that combine advanced reasoning generated by R1, memory, and tool calling! Reasoner models aren't the most practical LLMs for most agent usecases (the reasoning per-step is extremely long and often redundant), but it can be pretty entertaining to watch. More on our DeepSeek integration here: https://lnkd.in/geZb43XV

Had a great time chatting with the MLOps Community about Letta and stateful agents. Covered topics like: - what are stateful agents - the #1 challenge with agents (context management) - Letta framework & ADE - Case study with Letta (forming memories about user preferences from transactions) #StatefulAgents #Agents #AIAgents #Letta #MemGPT

Confused about the difference between RAG (retrieval augmented generation) and long-term memory in agents? RAG provides a way to connect LLMs and agents to more data than what can fit into context, but it doesn’t come without its limitations and risks. RAG often places irrelevant data into the context window, resulting in context pollution and degraded performance (especially for newer reasoning models). Although RAG is an important tool in the agents stack, it is far from a complete solution. Letta agents have the ability to perform multi-step reasoning with tools, which enables “agentic RAG” - part of the underlying foundation of the original MemGPT research paper which enables LLMs to perform memory management via specialized tools. Letta’s design takes all the work that’s gone into developing the search and document retrieval tools we use today and embeds those tools into LLMs, preparing the context window by summarizing and organizing its “memory”. With agentic RAG, LLMs can paginate through multiple pages of results, potentially even traversing an entire dataset, while also maintaining state. An AI agent equipped with read/write memory tools isn’t just doing a top-K match and dump. It’s already distilled important data it’s received in the past (a customer’s favorite movie or favorite color) and organized it in such a way that the model can proactively relate it to the user’s prompt and curate a response. Read our full blog post on RAG vs agentic memory for more details: https://lnkd.in/gGFQWfpz

The future of AI is “stateful agents” - agents that can learn from experience. Large language models possess vast knowledge, but they're trapped in an eternal present moment. While they can draw from the collected wisdom of the internet, they can't form new memories or learn from experience: beyond their weights, they are completely stateless. Every interaction starts anew, bound by the static knowledge captured in their weights. As a result, most “agents” are more akin to LLM-based workflows, rather than agents in the traditional sense. The next major advancement in AI won't come from larger models or more training data, but from LLM-driven agents that can actually learn from experience. At Letta, we are calling these systems “stateful agents”: AI systems that maintain persistent memory and actually learn during deployment, not just during training. Most LLM APIs and agentic frameworks that are built around the assumption of statelessness. State is assumed to be limited to the duration of ephemeral sessions and threads, baking in the assumption that agents are and always be stateless. A stateful agent has an inherent concept of experience. Its state represents the accumulation of all past interactions, processed into meaningful memories that persist and evolve over time. This goes far beyond just having access to a message history or a knowledge base via RAG. Key characteristics include: - A persistent identity providing continuity across interactions - Active formation and updating of memories based on experiences - Learning via accumulating state that influences future behavior The next generation of AI applications won't just access static knowledge - they'll learn continuously, form meaningful memories, and develop deeper understanding through experience. This represents a fundamental shift from treating LLMs as a component of a stateless workflow, to building agentic systems that truly learn from experience. The term "agent" has strong roots in reinforcement learning (RL) but recently has started to lose all meaning - "stateful agents" adds an important qualifier to the term to clearly distinguish it from an "LLM-driven workflow". Next time someone tells you about the agent they're building, try asking them if it's a stateful agent - if not, why? Full blog post on stateful agents in comments. 👾

Letta version 0.6.17 introduces native multi-agent support! 👾 💜 👾 All agents in Letta are *stateful* agents - every agent has their own independent core memory, persona, tools, and message history. You can now easily connect these independent agents to each other with multi-agent tools. Letta now provides built-in tools for supporting cross-agent communication to build multi-agent systems. 0.6.17 introduces three new built-in tools, which you can use directly or customize further! > 🔨 Tool 1: Messaging another agent (async / no wait) This tool is asynchronous: instead of waiting for a response from the target agent, the agent will get a “delivered receipt” once the message has been delivered, similar to how many message platforms for humans (e.g. iMessage, Messenger) work. > 🔧 Tool 2: Messaging another agent (wait for reply) Use this tool if you want the agent to wait for a response from the target agent before proceeding. The response of the target agent is returned in the tool output. > 🛠️ Tool 3: Messaging a group of agents (supervisor-worker pattern) This allows one agent to send a message a larger group of agents in a “supervisor-worker” pattern. For example, a supervisor agent can use this tool to send a message asking all workers in a group to begin a task. Read our new documentation on multi-agent here: https://lnkd.in/gMpEp7q6 Letta's multi-agent tools allow you to create systems where each individual agent is truly an independent "agent", as opposed to a disposable piece of a workflow. We're excited to see what you build! 🎏

Thrilled to share what we've been building at Letta - the Agent Development Environment (ADE) is now in public beta! As someone who's spent years architecting AI systems (literally — earned a PhD doing it), I've always been frustrated by how systems for AI agents are so black box with hiding LLM context windows and reasoning steps). We've been flying blind, hoping our agents would behave as intended without really understanding what's happening under the hood. On top of that, iterating on agent design is so cumbersome because you're expected to refine your tools, prompts, and memory systems separately to later combine into an agent. Really all these components should all be designed together with minimal iteration speed. Letta’s ADE is our answer to these challenges: a development environment for agents that gives you complete, real-time control over: * Context window optimization * Memory management (both in-context and external) * Tool integration (7k+ tools from Composio + custom tools) * Reasoning transparency Whether you're debugging your agent's reasoning process, optimizing context window usage, or developing new tools, everything is visible and controllable. My personal favorite part about the ADE is how you can live edit anything directly in the UI (even the source code of tools) which makes iteration speed so much faster. Huge thanks to Charles Packer and our phenomenal engineering team who've helped bring this vision to life. We're especially eager to hear feedback from fellow developers and researchers! #AIEngineering #DevTools #AgentDevelopment #AI #AIAgents #CompoundSystems

I'm incredibly excited to launch Letta’s Agent Development Environment (ADE) to public beta. 👾 🚀 Working with language models over the years, I've observed a fascinating paradox: as LLMs have grown more powerful, building reliable agents on top of them has remained surprisingly difficult. The core issue isn't the models themselves, but our inability to truly understand how our agents think, plan, and make decisions. We're launching the ADE to solve this. The ADE brings unprecedented transparency to agent development by exposing the fundamental building blocks of agent behavior: context windows, memory systems, and tool interactions. Think of it as lifting the hood on your agent's mind. Every decision, every piece of context, every tool interaction becomes visible and controllable. This isn't just a development environment - it's a new way of thinking about agents (thinking) entirely. We're launching in public beta (link in comments). As a researcher turned founder, nothing would make me happier than seeing this help developers push the boundaries of what's possible with AI agents. Special thanks to my brilliant co-founder Sarah Wooders and our incredible team at Letta who has helped transform this vision from theoretical scratch drawings on a whiteboard at UC Berkeley to practical reality.

Really awesome to see MemGPT in Shawn swyx W / Latent Space Podcast's "2025 AI Engineer Reading List", where MemGPT is in the top 5 "required reads" on agents, side-by-side with one of my favorite LLM papers: ReAct. ReAct (Shunyu Yao et al) is *the* most influential paper in the current wave of real-world LLM agents (LLMs being presented observations, reasoning then taking actions in a loop). Pick any LLM agents framework off of GitHub today - chances are the core agentic loop they're using is basically ReAct. MemGPT was our vision at Berkeley (Sarah Wooders, Kevin Lin, Joseph Gonzalez, Ion Stoica, et al., now at Letta) for the next big thing in LLM agents *after* ReAct. LLM agents break down into two components: (1) the LLM under the hood which goes from tokens to tokens, and (2) the closed system around that LLM that prepares the input tokens and parses the output tokens. The most important question in an LLM agent is *how* do you place tokens in the context window of the LLM? This determines what your agent knows and how it behaves. The reason LLM agents today "suck" is because this problem (assembling the context window) is an incredibly difficult open research question. MemGPT predicts a future where the context window of an LLM agent is assembled dynamically by an intelligent process (you could call this another agent, or the "LLM OS"). Today, the work of context compilation is largely done by hand. Tomorrow, it'll be done by LLMs.

Excited to see Letta in TechCrunch's most disruptive startups of 2024 list 👀 Memory is the most important problem in AI today. LLMs are the new building block for AI systems, but LLMs are inherently stateless compute units - we need fundamental advancements in memory systems to get to anything resembling AGI. 👾 If you're interested in advancing the frontier of memory for AI, reach out! We're hiring across product, infra, and research! (link in comments) Note: our office is in SF, not Berkeley ;)

The AI agents stack in late 2024, organized into three key layers: agent hosting/serving, agent frameworks, and LLM models & storage. Read more at https://lnkd.in/dP7JAzFr