Introducing the Letta Code app
Today we’re launching the Letta Code app, a new way to interact with deeply personalized agents that learn over time and work locally on your machine.
Learning over time and building memory
Letta Code agents can start as a blank slate or with a pre-configured personality. For new agents, run /init to initialize its memory system from existing code, as well as past sessions from Claude Code or Codex.
As you interact with agents, memory subagents will periodically review sessions to rewrite context and refine memory. You can also run /doctor to clean up and reorganize memories as needed.
Port agents, memories, & sessions across models
Letta Code decouples your agent's memory and identity from the underlying model provider. Switch models anytime (even mid-session) and your agent keeps its full context, memory, and personality.
You can bring your own API keys or coding plans from Codex/ChatGPT or Z.ai.
Extend agent capabilities with skills
Letta Code supports skills to extend an agent's capabilities. You can also ask your agent to install skills (just give it a link), or also build and version their own skills.
Getting started
The Letta Code app is available today across MacOS, Windows, and Linux. Get started for free:
- MacOS
- Windows
- Linux
Letta builds agents that learn. Agents with persistent memory, real computer access, and the infrastructure to improve from their own lived experience and work. Letta Code is the runtime that brings these together: git-backed memory, skills, subagents, and deployment that works across every model provider.
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.
Using remote environments, you can message an agent working on your laptop from your phone.
The Conversations API allows you to build agents that can maintain shared memory across parallel experiences with users
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.
Today we are releasing the Context Constitution: a set of principles governing how AI agents manage context to learn from experience.
.png)
We're introducing Context Repositories, a rebuild of how memory works in Letta Code based on programmatic context management and git-based versioning.
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.
