Frequently Asked Questions

Compiled from common questions and discussions on the Letta Developer Forum.

General

What is the difference between MemGPT and Letta?

MemGPT refers to the original research paper and agent design pattern (empowering LLMs with self-editing memory tools). Letta is the company and framework built on top of the MemGPT research. The PyPI package has been renamed from memgpt to letta, and Docker images are now under letta/letta-server.

What models does Letta support?

Letta is model-agnostic. It works with OpenAI (GPT-4o, GPT-5), Anthropic (Claude Sonnet 4.5, Claude 4), Google (Gemini), and open-weight models via Ollama, Together.AI, Fireworks, and other providers. You can switch models mid-session without losing agent state.

Does Letta work with local models via Ollama?

Yes. Set the appropriate environment variables and Letta will list available Ollama models. Some features like inner thoughts may require the put_inner_thoughts_in_kwargs setting for certain models. Vision model support through Ollama is available but may require specific configuration.

Is Letta open source?

Yes. The core framework is open source under the Apache 2.0 license. Letta also offers a hosted cloud service for managed deployments.

Memory and State

How does Letta manage memory?

Letta uses a hierarchical memory system:

1. Core Memory -- Editable, in-context memory blocks (always in the LLM's context window)
2. Recall Memory -- Searchable conversation history persisted to disk
3. Archival Memory -- External storage (vector database) for large knowledge bases
4. Filesystem -- Git-backed file storage for documents and skills (via Context Repositories)

What is sleep-time compute?

Sleep-time compute is a feature where a secondary "sleep-time agent" processes and reorganizes memory during idle periods. This shifts computational load from user-facing interactions to background processing, improving both response times and memory quality.

How do I share memory between agents?

Memory blocks can be shared across multiple agents. When one agent updates a shared block, other agents see the change. The Conversations API also enables multiple concurrent conversations feeding into a single agent's shared memory.

What is the difference between RAG and Letta's memory?

Traditional RAG is a single-step retrieve-and-generate pattern. Letta's agentic memory is multi-step -- agents iteratively search, reason about results, and proactively synthesize information. Agents can also update and organize their own memory, which RAG cannot do.

Tools and Skills

What are skills in Letta?

Skills are mountable packages of specialized knowledge stored as directories containing markdown files and resources. Agents dynamically discover and load relevant skills during task execution. You can create custom skills or use built-in ones.

How do tool rules work?

Tool rules constrain agent behavior by defining execution order:

• TerminalToolRule -- Ends agent execution when called (works with all models)
• InitToolRule -- Must be called first (requires structured outputs support)
• ToolRule -- Defines which tools must follow a given tool

Can I use MCP tools with Letta?

Yes. Letta supports MCP (Model Context Protocol) tools through the run_code_with_tools feature, allowing agents to invoke tools from external MCP servers.

How do I schedule agents?

Letta supports scheduled agent execution. See the Scheduling documentation for details on configuring periodic agent runs, including sleep-time agents that process memory on a schedule.

Deployment

How do I self-host Letta?

Run letta server to start a local Letta server. For production deployments, use Docker with letta/letta-server. Be sure to sandbox code execution and set a server password.

Can I use Letta with remote environments?

Yes. Running letta server on any machine establishes a WebSocket connection, allowing you to interact with agents via chat.letta.com while they execute on your local machine or server.

How does Letta handle database migrations?

Automated database migrations via alembic are included since v0.5.0, enabling schema changes without manual intervention.

Benchmarks and Evaluation

What is Context-Bench?

An open-source benchmark evaluating how well LLMs perform agentic context engineering -- multi-step information retrieval using file operations. Live leaderboard at leaderboard.letta.com.

What is Terminal-Bench?

A benchmark featuring 100+ terminal tasks (kernel compilation, ML training, server configuration). Letta Code achieved the #1 open-source score.

How do I evaluate my agents?

Use Letta Evals, an open-source framework with datasets (JSONL), targets (Agent Files), graders (string match to LLM-as-judge), and gates (pass/fail thresholds). Integrates with CI/CD via GitHub workflows.