Letta treats context management as the central job of an agent framework, deciding what information reaches the language model and how it is compacted.
2
Letta agents persist message histories, use in-context and external memory, and can learn user preferences from offline data before making recommendations.
3
Letta runs agents as services with APIs, custom tools, sandboxed tool execution, local deployment through Letta Desktop, and cloud deployment through Letta Cloud.
Summary
Sarah Wooders presents Letta as an open source framework and platform for stateful agents. Its main responsibility is context management: collecting agent state, memories, tools, and runtime information, then packing the most useful material into the language model's context window. Letta automatically persists message histories, compacts information, summarizes or evicts older messages, and helps avoid context overflow. The agent can also write to in-context memory and an external vector store. Wooders describes applications such as personalized email and recommendations based on offline processing of transaction histories, user data, and company guidelines. Letta agents run as API services rather than remaining inside notebooks. The platform supports custom tools, authentication through Compos, sandboxing for insecure tools, local execution through Letta Desktop, and managed deployment through Letta Cloud. Wooders is direct that the language model itself chooses what to store, although developers can prompt or replace the memory tools when they need a different structure.
Letta puts context management at the centre of an agent framework
Sarah Wooders says the main engineering problem is deciding what data to feed the language model and how to feed it. She calls this context management. The framework should compile the context and interface with the model so developers can get better performance from agents that call tools and retain memory. She also treats deployment as part of the framework. Agents that begin as Python scripts or notebooks need to become services that can run autonomously and expose an API. Letta therefore combines context handling with agent hosting rather than leaving both tasks to the application developer.
Wooders describes the model context window as the main input developers can control. Adding more information does not always improve an agent. With too much data, a language model can become distracted, lose track of what matters, or summarize details too generally. With too little data, it lacks relevant information and is more likely to make something up. Applications such as recommendation systems may contain product offerings, company policies, transaction histories, and user data. Letta's job is to select and organize this material instead of placing everything in the context window.
The Letta service stores state and compiles it into model context
The Letta stack places a service between an application and the language model. Applications connect through REST APIs or SDKs, while the Letta service manages memory, agent state, tool execution, and additional data sources. It can process state with another language-model call to make the context more concise, then pass that compiled context to the model. When the model produces a tool call, Letta translates it into an update to the agent's state. The state is stored in a model-agnostic way, so an existing agent with its history and memories can change model providers.
Letta supports personalization through persistent memory and offline processing
Wooders gives an example of an agent that reviews interactions and other user data to build a personalized memory for writing emails. In another example, a payments platform has transaction histories, user data, and marketing guidelines that cannot fit into a single context window. Letta processes the data offline and repeatedly updates learned user preferences and historical trends. The resulting memories can then support real-time offer recommendations. This approach is presented as a way for agents to learn from large collections of data rather than relying only on a retrieval step at request time.
Letta treats every agent as an agent service, so developers do not need a separate deployment step to turn a notebook experiment into an API. Its API can create agents and send messages, while also providing granular access to memory, conversation history, and step history. Developers can modify agent state through the API. Wooders says Letta provides autogenerated Python and TypeScript SDKs. The agent development environment gives developers a place to inspect what enters the context window and iterate on prompts, tools, and model settings.
Memory combines message history, external storage, and in-context information
In response to a question from Demetrios Brinkmann, Wooders explains that Letta automatically persists message histories and lets the agent read and write to an external vector store. It also allocates part of the context window for in-context memory. The agent uses tools to write to both forms of memory, while the language model orchestrates how memory changes over time. The design follows the approach described in the MemGPT paper, with the model helping decide what information should remain available.
Developers can override how the model writes memories
Wooders says Letta memories are written by the language model through tools such as core memory replace and core memory append. Prompting can influence what the model stores. Developers can also replace Letta's memory tools with custom tools when memories need a specific structure or format. She argues that text is a practical memory representation because language models work with text directly. She also describes a newer multi-agent approach, where one agent specializes in managing another agent's memory and can revise the full memory over time instead of making only incremental changes.
Tool security and deployment can be handled inside standard infrastructure
Letta integrates with Compos for tool connectors and authentication scopes. Wooders says insecure tools run in a sandbox automatically, which helps prevent dangerous tools from running directly in the server. Teams with stricter requirements can deploy the Letta server themselves as a Docker image. She says it can also run on Kubernetes, allowing the service to fit into existing infrastructure. Letta's deployment options include an open source server, Letta Desktop for fully local agents, and Letta Cloud for building, testing, versioning, and deploying agents without managing infrastructure.
