Conversations: Shared Agent Memory across Concurrent Experiences
The Letta API is designed for creating stateful agents that are more akin to digital humans rather than LLMs: they have their own sense of identity and experience, through which they form memory and recall the past. Like humans, Letta agents have so far experienced time as a single thread.
With the new conversations API endpoints, agents can now have multiple conversations concurrently while still having their own individual identity and sense of experience. Each conversation is tied to a specific agent, and experiences within a conversation can form memories which transfer across all conversations.
Conversations enable a single agent to serve as an institutional knowledge manager across an organization's Slack or other communication channels. Each Slack thread becomes its own conversation, with hundreds of threads running in parallel and feeding into a single agent's memory. The agent can search across all conversations to recall relevant information - connecting context from engineering discussions, product meetings, and customer feedback through a single unified memory system.
Conversations in the ADE
Now when chatting with a Letta agent in the ADE, you can create independent threads from the main “default” conversation to additional “side” conversations. Each conversation is still with the same agents, so messages are searchable across all conversations and memory is shared.
Concurrent Sessions in Letta Code
Letta Code now defaults to using the Conversations API endpoints under the hood. This means you can have multiple concurrent sessions with the same agent, while retaining memory and experience across all of your concurrent Letta Code sessions.
Designing Agents with Conversations
Conversations make it much simpler to support many end-users without having to create individual agents for every user. If you want agents to accumulate memory across user sessions, you may want to use conversations - if you want memory to be isolated, you should still continue to create separate agents.
Conclusion
To try out conversations, install the latest version of Letta Code or view the documentation.
Traditional LLMs operate in a stateless paradigm—each interaction exists in isolation, with no knowledge carried forward from previous conversations. Agent memory solves this problem.
As AI agents become more sophisticated, understanding how to design and manage their context windows (via context engineering) has become crucial for developers.
Memory blocks offer an elegant abstraction for context window management. By structuring the context into discrete, functional units, we can give LLM agents more consistent, usable memory.
Although RAG provides a way to connect LLMs and agents to more data than what can fit into context, traditional RAG is insufficient for building agent memory.
Introducing “stateful agents”: AI systems that maintain persistent memory and actually learn during deployment, not just during training.
Introducing Letta Code, a memory-first coding agent. Letta Code is the #1 model-agnostic open source agent on the leading AI coding benchmark Terminal-Bench.
The Letta API now supports programmatic tool calling for any LLM model, enabling agents to generate their own workflows.
Introducing Letta Evals: an open-source evaluation framework for systematically testing stateful agents.
Introducing Letta's new agent architecture, optimized for frontier reasoning models.
Letta agents can now take full advantage of Sonnet 4.5’s advanced memory tool capabilities to dynamically manage their own memory blocks.
Today we're announcing Letta Filesystem, which provides an interface for agents to organize and reference content from documents like PDFs, transcripts, documentation, and more.
We've releasing new client SDKs (support for TypeScript and Python) and upgraded developer documentation
Introducing Agent File (.af): An open file format for serializing stateful agents with persistent memory and behavior.
Introducing the Letta Agent Development Environment (ADE): Agents as Context + Tools
Letta v0.6.4 adds Python 3.13 support and an official TypeScript SDK.
Letta v0.5.2 adds tool rules, which allows you to constrain the behavior of your Letta agents similar to graphs.
Letta v0.5.1 adds support for auto-loading entire external tool libraries into your Letta server.
At Letta, we believe that learning in token space is the key to building AI agents that truly improve over time. Our interest in this problem is driven by a simple observation: agents that can carry their memories across model generations will outlast any single foundation model.
Today we’re releasing Skill Learning, a way to dynamically learn skills through experience. With Skill Learning, agents can use their past experience to actually improve, rather than degrade, over time.
Today we're releasing Skill Use, a new evaluation suite inside of Context-Bench that measures how well models discover and load relevant skills from a library to complete tasks.
We are open-sourcing Context-Bench, which evaluates how well language models can chain file operations, trace entity relationships, and manage multi-step information retrieval in long-horizon tasks.
We're excited to announce Recovery-Bench, a benchmark and evaluation method for measuring how well agents can recover from errors and corrupted states.
Letta Filesystem scores 74.0% of the LoCoMo benchmark by simply storing conversational histories in a file, beating out specialized memory tool libraries.
We built the #1 open-source agent for terminal use, achieving 42.5% overall score on Terminal-Bench ranking 4th overall and 2nd among agents using Claude 4 Sonnet.
