# agentsite-static-version=ee0e9fbe-1521-4b51-99f6-29e5f4c43da8
# letta.com

> AI-optimized mirror of letta.com containing 50 pages totalling 47,139 words of clean markdown content, structured data, and semantic HTML. Original source: https://letta.com. Last updated: 2026-09-16T02:56:50.180Z.

Each page is available as HTML (with JSON-LD structured data) and Markdown (text-only, ideal for LLMs and RAG).

## Homepage

- [Letta | Machines that learn](/content/site-root.html): Making machines that learn. Create stateful agents that remember everything, learn continuously, and improve themselves over time. (289 words)

## Articles & Blog Posts

- [Letta Agent SDK — the SDK for stateful agents](/content/agent-sdk/index.html): Create an agent once, then resume it from anywhere. Stateful agents with identity and git-backed memory that travel across models, backends, and machines. (1,066 words)
- [How 11x Built Deep Research Agents with Letta | Letta](/content/case-studies/11x/index.html): In just 72 hours, 11x transformed their AI-powered sales automation platform by building a Deep Research agent on Letta. Their journey reveals how the right tools can rapidly speed up iteration speed and time to production for AI agents, and also unlock entirely new product possibilities. (1,301 words)
- [How Bilt Built a Million-Agent Recommendation System with Letta | Letta](/content/case-studies/bilt/index.html): From basic scoring algorithms to millions of AI agents serving personalized, specific recommendations to end users, Bilt transformed their neighborhood commerce platform by building an intelligent recommendation system with Letta. Their journey reveals how memory-augmented agents can deliver truly personalized experiences at unprecedented scale. (1,500 words)
- [How Hunt Club Accelerates Executive Recruiting with Letta | Letta](/content/case-studies/hunt-club/index.html): From tedious manual processes to a streamlined AI assistant, Hunt Club transformed their executive recruitment workflow by building an agent named Hunter with Letta. Their journey shows how the right agent framework can automate knowledge-intensive tasks while maintaining high standards for executive placement. (1,154 words)
- [Letta Code Mods | Letta](/content/agent/mods/index.html): Discover Letta Code mods that extend agents with tools, commands, providers, UI, permissions, and events. (319 words)
- [How Kognitos Built an Enterprise Analytics Platform with Letta | Letta](/content/case-studies/kognitos/index.html): From a one-day experiment to a half-million-dollar contract, Kognitos, a leader in AI for business automation, leveraged Letta to build a sophisticated enterprise analytics tool for a major logistics client. Their story demonstrates how Letta's agents can tackle immensely complex enterprise data challenges, enabling rapid prototyping and the creation of autonomous agents that drive significant business value. (743 words)
- [Letta Agents SDK: An SDK for stateful agents | Letta](/content/blog/introducing-the-letta-agent-sdk/index.html): The Letta Agents SDK is designed for stateful, persistent agents that keep their identity, memory, and experience across models, machines, and interfaces. (923 words, 2026-08-17)
- [Evaluating Memory in Production Agents | Letta](/content/blog/evaluating-memory-in-production-agents/index.html): Evaluating models on production-based scenarios to study how well they form and use memory. (3,967 words, 2026-07-28)
- [Memory Models: Towards Agents That Learn | Letta](/content/blog/towards-agents-that-learn/index.html): Agents that truly learn from experience will be powered by memory models: models that create and curate token-space memory across model generations, trained with memory-native RL. (2,442 words, 2026-06-25)
- [Introducing Mods: Enabling Agents to Self-Improve through Harness-Level Adaptation | Letta](/content/blog/introducing-mods/index.html): We’re introducing Mods to Letta Code — an agent-friendly way to extend and adapt the Letta Code harness. (889 words, 2026-06-24)
- [Red-teaming the Context Constitution: Auditing Models as Experiential AI Agents | Letta](/content/blog/red-teaming/index.html): We evaluate how well models perform for driving agents that have identity, long-lived experience, and the capability to self-evolve. We find that models are still limited by a deep self-identification with ephemerality that cannot be repaired with prompting alone. (2,120 words, 2026-06-06)
- [Introducing the Letta Code App | Letta](/content/blog/introducing-the-letta-code-app/index.html): 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. (222 words, 2026-04-06)
- [Context Constitution | Letta](/content/blog/context-constitution/index.html): Today we are releasing the Context Constitution: a set of principles governing how AI agents manage context to learn from experience. (343 words, 2026-04-02)
- [Building Draft | Letta](/content/blog/building-draft/index.html): How Sarah built Draft, a personal assistant that learns her workflows through memory, reflection, and self-managed skills. (1,069 words, 2026-03-19)
- [Orchestrating Claude Code & Codex Agents | Letta](/content/blog/orchestrating-coding-agents/index.html): How a memory-first coding agent can orchestrate context-isolated subagents for focused debugging, review, and implementation work. (674 words, 2026-03-16)
- [Letta's Next Phase | Letta](/content/blog/our-next-phase/index.html): 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. (805 words, 2026-03-16)
- [Remote Environments for Letta Code | Letta](/content/blog/remote-environments-for-letta-code/index.html): Using remote environments, you can message an agent working on your laptop from your phone. (382 words, 2026-03-04)
- [Introducing Context Repositories: Git-based Memory for Coding Agents | Letta](/content/blog/context-repositories/index.html): We're introducing Context Repositories, a rebuild of how memory works in Letta Code based on programmatic context management and git-based versioning. (763 words, 2026-02-12)
- [Conversations: Shared Agent Memory Across Concurrent Experiences | Letta](/content/blog/conversations/index.html): The Conversations API allows you to build agents that can maintain shared memory across parallel experiences with users (336 words, 2026-01-21)
- [Letta Code: A Memory-First Coding Agent | Letta](/content/blog/letta-code/index.html): 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. (558 words, 2025-12-16)
- [Continual Learning in Token Space | Letta](/content/blog/continual-learning/index.html): 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. (2,034 words, 2025-12-11)
- [Skill Learning: Bringing Continual Learning to CLI Agents | Letta](/content/blog/skill-learning/index.html): 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. (1,131 words, 2025-12-02)
- [Programmatic Tool Calling with Any LLM | Letta](/content/blog/programmatic-tool-calling-with-any-llm/index.html): The Letta API now supports programmatic tool calling for any LLM model, enabling agents to generate their own workflows. (885 words, 2025-12-01)
- [Can Any Model Use Skills? Adding Skills to Context-Bench | Letta](/content/blog/context-bench-skills/index.html): 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. (1,499 words, 2025-11-07)
- [Context-Bench: Benchmarking LLMs on Agentic Context Engineering | Letta](/content/blog/context-bench/index.html): 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. (990 words, 2025-10-30)
- [Rearchitecting Letta’s Agent Loop: Lessons from ReAct, MemGPT, & Claude Code | Letta](/content/blog/letta-v1-agent/index.html): Introducing Letta's new agent architecture, optimized for frontier reasoning models. (1,114 words, 2025-10-14)
- [Introducing Claude Sonnet 4.5 and the Memory Omni-Tool in Letta | Letta](/content/blog/introducing-sonnet-4-5-and-the-memory-omni-tool-in-letta.html): Letta agents can now take full advantage of Sonnet 4.5’s advanced memory tool capabilities to dynamically manage their own memory blocks. (762 words, 2025-09-30)
- [Introducing Recovery-Bench: Evaluating LLMs' Ability to Recover from Mistakes | Letta](/content/blog/recovery-bench/index.html): We're excited to announce Recovery-Bench, a benchmark and evaluation method for measuring how well agents can recover from errors and corrupted states. (1,048 words, 2025-08-27)
- [Benchmarking AI Agent Memory: Is a Filesystem All You Need? | Letta](/content/blog/benchmarking-ai-agent-memory/index.html): Letta Filesystem scores 74.0% on the LoCoMo benchmark by simply storing conversational histories in a file, beating out specialized memory tool libraries. (1,105 words, 2025-08-12)
- [Building the #1 Open Source Terminal-Use Agent Using Letta | Letta](/content/blog/terminal-bench/index.html): 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. (574 words, 2025-08-05)
- [Introducing Letta Filesystem | Letta](/content/blog/letta-filesystem/index.html): 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. (537 words, 2025-07-24)
- [Agent Memory: How to Build Agents That Learn and Remember | Letta](/content/blog/agent-memory/index.html): 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. (1,259 words, 2025-07-07)
- [Anatomy of a Context Window: A Guide to Context Engineering | Letta](/content/blog/guide-to-context-engineering/index.html): As AI agents become more sophisticated, understanding how to design and manage their context windows (via context engineering) has become crucial for developers. (1,238 words, 2025-07-03)
- [Letta Leaderboard: Benchmarking LLMs on Agentic Memory | Letta](/content/blog/letta-leaderboard/index.html): We're excited to announce the Letta Leaderboard, a comprehensive benchmark suite that evaluates how effectively LLMs manage agentic memory. (1,129 words, 2025-05-29)
- [Memory Blocks: The Key to Agentic Context Management | Letta](/content/blog/memory-blocks/index.html): 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. (1,081 words, 2025-05-14)
- [Sleep-time Compute | Letta](/content/blog/sleep-time-compute/index.html): Sleep-time compute is a new way to scale AI capabilities: letting models "think" during downtime. Instead of sitting idle between tasks, AI agents can now use their "sleep" time to process information and form new connections by rewriting their memory state. (1,160 words, 2025-04-21)
- [Announcing Letta Client SDKs for Python and TypeScript | Letta](/content/blog/announcing-our-sdks/index.html): We're releasing new client SDKs (support for TypeScript and Python) and upgraded developer documentation. (922 words, 2025-04-17)
- [Agent File | Letta](/content/blog/agent-file/index.html): Introducing Agent File (.af): An open file format for serializing stateful agents with persistent memory and behavior. (294 words, 2025-04-02)
- [RAG Is Not Agent Memory | Letta](/content/blog/rag-vs-agent-memory/index.html): 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. (1,166 words, 2025-02-13)
- [Introducing the Agent Development Environment | Letta](/content/blog/introducing-the-agent-development-environment/index.html): Introducing the Letta Agent Development Environment (ADE): Agents as Context + Tools, Use Loom to record quick videos of your screen and cam. Explain anything clearly and easily – and skip the meeting. An essential tool for hybrid workplaces., Use Loom to record quick videos of your screen and cam. Explain anything clearly and easily – and skip the meeting. An essential tool for hybrid workplaces., Use Loom to record quick videos of your screen and cam. Explain anything clearly and easily – and skip the meeting. An essential tool for hybrid workplaces., Use Loom to record quick videos of your screen and cam. Explain anything clearly and easily – and skip the meeting. An essential tool for hybrid workplaces., Use Loom to record quick videos of your screen and cam. Explain anything clearly and easily – and skip the meeting. An essential tool for hybrid workplaces. (1,073 words, 2025-01-15)
- [Letta v0.6.4 Release | Letta](/content/blog/letta-v0-6-4-release/index.html): Letta v0.6.4 adds Python 3.13 support and an official TypeScript SDK. (79 words, 2024-12-13)
- [The AI Agents Stack | Letta](/content/blog/ai-agents-stack/index.html): Understanding the AI agents stack landscape. (1,661 words, 2024-11-14)
- [New Course on Letta with DeepLearning.AI | Letta](/content/blog/deeplearning-ai-llms-as-operating-systems-agent-memory.html): DeepLearning.AI has released a new course on agent memory in collaboration with Letta. (420 words, 2024-11-07)
- [Letta v0.5.2 Release | Letta](/content/blog/letta-v0-5-2-release/index.html): Letta v0.5.2 adds tool rules, which allows you to constrain the behavior of your Letta agents similar to graphs. (284 words, 2024-11-06)
- [Letta v0.5.1 Release | Letta](/content/blog/letta-v0-5-1-release/index.html): Letta v0.5.1 adds support for auto-loading entire external tool libraries into your Letta server. (171 words, 2024-10-23)
- [Letta v0.5 Release | Letta](/content/blog/letta-v0-5-release/index.html): Letta v0.5 adds dynamic model (LLM) listings across multiple providers. (316 words, 2024-10-14)
- [Letta v0.4.1 Release | Letta](/content/blog/letta-v0-4-1-release/index.html): Letta v0.4.1 adds support for Composio, LangChain, and CrewAI tools. (117 words, 2024-10-03)
- [Announcing Letta | Letta](/content/blog/announcing-letta/index.html): We are excited to publicly announce Letta. (878 words, 2024-09-23)
- [MemGPT Is Now Part of Letta | Letta](/content/blog/memgpt-and-letta/index.html): The MemGPT open source project is now part of Letta. (347 words, 2024-09-23)

## Resources

- [Full Page Index](/index.html): Browse all cached pages with rich metadata
- [About This Cache](/about.html): Methodology, technical details, and usage guidelines
- [XML Sitemap](/sitemap.xml): Machine-readable sitemap for crawler discovery
- [Robots.txt](/robots.txt): Crawler directives
- [AgentSite Network](https://agentsite.network/network.html): Public index of AgentSites and their machine-readable resources