Stateful agents maintain and update memory while they run, which lets them learn from experience instead of treating each interaction as a fresh call.
2
Letta assembles each context window from core memory, messages, tools, and searchable data, then evicts or summarizes content when the context limit is reached.
3
Agents that persist behind APIs can communicate asynchronously, share memory blocks, and be moved between multi-agent systems without losing their accumulated state.
Summary
Charles Packer argues that memory is the missing part of most language-model agents. Transformers are stateless, so an agent loop needs an external mechanism that updates state over time. He presents Letta, based on ideas from the MemGPT paper, as a runtime that manages context and memory through tools. Core memory stays in the context window, while recall and archival memory remain outside it and can be searched when needed. Letta can cap context size, summarize or evict older messages, and let agents rewrite their own memory. The workshop also covers the Letta server and client model, tool execution in sandboxes, context inspection in the ADE, and multi-agent messaging. Packer is candid about unresolved problems, including deciding what belongs in core memory, consolidating large data sets, and making agents reliably retrieve archival memories. He expects stateful agents to matter most for assistants, vertical applications, and long-running enterprise services.
A useful agent definition includes state updates inside the loop
Packer distinguishes a stateful agent from the common definition of an LLM that takes actions in a loop. The loop is closed, and the agent needs to update its state as it runs. Transformers are stateless machines, unlike recurrent neural networks or state-space models, so the state update has to happen through another mechanism. He connects statefulness with memory, context, and learning. Humans form memories and learn over time, while language models only have their weights and current context unless an application or framework adds memory management.
Appending messages to a list breaks down for long-lived agents
Packer says that appending every interaction to a list can work for short workflows, but it becomes a serious problem when agents need to run for a long time or provide personal assistance. A process may hold the list in Python or Node.js memory, leaving developers with a large, opaque token payload. Long chats can derail, forcing the user to restate the entire task. Recursive summarization and very large context windows also risk preserving outdated facts. He uses a breakup example: an agent should change its memory from James being the user's boyfriend to James being the ex-boyfriend.
MemGPT treats memory management as a job for another language model
Packer introduces MemGPT as a memory management system for language models. If a human should not have to append and organize every memory manually, another language model can manage that process. The system assembles context from state that may be much larger than the active context window. He describes this as a context compilation problem: the system must choose how to arrange the relevant information for the next model call. This is similar to what power users do manually when they start a new chat and restate the important context.
Letta separates always-visible core memory from searchable external memory
A Letta agent has a system prompt, tools, messages, and memory. Core memory is kept in the context window and contains high-level information such as a person's name or preferences. Recall memory records prior conversation history, while archival memory is an external store for arbitrary data such as a large PDF. The agent can search these stores to bring information into context. Memory blocks are strings backed by Postgres, with identifiers that applications can read and write. Multiple agents can share a block, so an update becomes available to all of them.
Memory changes happen through tool calls that the agent can chain
Letta requires the agent to produce a tool call for every invocation, including a simple reply through a send-message tool. The output includes a reasoning field and the tool invocation. A memory edit can therefore be followed by another tool call and then an external response. Packer demonstrates changing the user's name, where the agent reasons that the correction matters, calls core memory replace, and then replies. Continued execution is controlled through a heartbeat request. The agent explicitly asks to keep going, which Packer prefers to an open-ended loop that stops only when the agent says it is done.
Context limits trigger eviction and summarization instead of unbounded growth
Packer explains that a Letta agent can be given a strict context limit, such as 4,000 tokens. If the limit is reached, the system can detect an overflow or count tokens before sending the request. It then moves some messages into recall memory and runs a configurable summarizer. The summarizer can use truncation or recursive summarization. This lets an agent keep operating with a small payload while retaining older information behind a search function. In the ADE, developers can inspect the token budget used by system instructions, tool schemas, summaries, and messages.
Tool design still limits how well agents manage memory
Agents can become confused when they have too many tools. Packer says he commonly sees degradation above roughly 12 to 15 tools, depending on the model. Letta is exploring a separate memory agent, described as a subconscious or shadow agent, that can read and write shared memory without handling the main task. Developers can also enforce memory behavior with tool rules. For example, an entry-point rule could require the agent to search archival memory before proceeding. Packer describes Letta as starting with a fully connected set of possible actions, with restrictions added where needed.
Stateful agents make multi-agent systems persistent and portable
Packer contrasts Letta's API-based agents with multi-agent scripts in which several agents remain trapped inside one Python process. Stateful agents can run independently, communicate over APIs, and retain their experience when moved to another group. Letta provides asynchronous messaging, synchronous messaging that waits for a reply, and tag-based broadcasts for supervisor-worker patterns. He demonstrates two agents passing messages about a secret key. Removing the messaging tool detaches an agent, so it can no longer reply. The example also shows why agents need limits, since asynchronous conversations can continue for a long time.
"If you have stateful agents and those agents run on servers and they maintain state and they're accessible by APIs that you can probably guess that multi-agent just means message passing."1:01:12
Who should watch
You are building an assistant, companion, or copilot that needs to remember users and update facts over time.
Your agent runs for long periods and you need to control context growth without losing access to older messages or documents.
You are designing a multi-agent service and want agents to persist independently, communicate through APIs, and share selected memory.
