Letta
Build stateful agents with advanced memory that can learn and improve over time.
Per-dimension scores and reasoning
Evidence shows a security policy and error handling tests, but no explicit implementation of least privilege, user confirmation, data flow transparency, sensitive data handling, dependency security, external effects, rollback, or source attribution. Deductions: lack of concrete evidence for these aspects.
Tests cover error conversion, but dependencies are numerous and availability not verified. Deductions: dependency availability unproven, failure messages tested but not executed.
README describes multiple use cases, but capability boundaries and trigger precision are not explicit. Deductions: capability boundaries and trigger precision lack documentation.
Has README, LICENSE, pyproject.toml, but lacks changelog and known limitations. Deductions: versioning and known limitations not documented.
Output usability has examples, marginal value is clear, but cost-benefit not quantified. Deductions: cost-benefit lacks data.
Claims are supported by tests, but independent verification not possible. Deductions: claim traceability insufficient, cross-source corroboration limited.
- Numerous dependencies with unverified availability may affect reliability.
- Lack of changelog and known limitations makes risk assessment difficult.
- Permissions and data handling details are unclear; use with caution.
What does this agent do, and when should you use it?
Letta, formerly MemGPT, is a platform for stateful agents with advanced memory. This repository contains the legacy Letta Server behind the Letta V1 API and SDKs; active development has moved to the Letta Agent repository. For new builds, the TypeScript Letta Agent SDK can run agents on Letta’s Constellation cloud, locally, or against a self-hosted App Server. Letta Code provides a terminal entry point for running a memory-enabled local agent, with desktop and Slack-channel options also named. The SDK exposes agent creation, session resumption, message sending, and streamed assistant responses.
A developer installs @letta-ai/letta-agent-sdk and creates a LettaAgentClient. client.createAgent({ model, human, persona }) creates a stateful agent with a model, human description, and persona, returning an agentId; client.resumeSession(agentId) opens its session, session.send(...) submits input, and for await (const message of session.stream()) reads streamed messages whose type is assistant. backend: "cloud" connects through a Letta API key, while backend: "local" launches Letta Code as a subprocess on the local machine. Terminal users can instead install @letta-ai/letta-code globally and run letta to launch a local memory-enabled agent.
- A TypeScript application developer who needs an agent whose state can be resumed by agentId can create and resume it with LettaAgentClient.
- An individual developer who wants a memory-enabled assistant in a local terminal can install Letta Code and run letta.
- A team deciding between cloud, local execution, and a self-hosted API boundary can select the appropriate Agent SDK backend.
- A developer building a streaming chat interface can consume assistant output incrementally through session.stream().
- A maintainer already using the Letta V1 API can retain a V1 SDK while using the Agent SDK for new projects.
What are this agent's strengths and limitations?
- The SDK documents a complete path for creating an agent, resuming a prior session, and consuming streamed responses.
- One Agent SDK explicitly supports cloud, local, and self-hosted App Server execution boundaries.
- The local backend starts Letta Code as a subprocess, avoiding separate subprocess setup in the application.
- CLI, desktop, and Slack channels provide multiple documented interaction surfaces for memory-enabled agents.
- This is the legacy Letta Server repository; active development has moved to letta-ai/letta-code, creating a migration consideration for adopters of this repository itself.
- The CLI requires Node.js 22.19+, and local SDK execution depends on Letta Code being launched.
- The cloud example requires a Letta API key, so that path depends on credentials and network access.
- The supplied material names App Server for self-hosting but does not provide its installation commands, infrastructure requirements, or operational configuration.
How do you install or deploy this agent?
Node.js 22.19+ is required. For the local CLI: npm install -g @letta-ai/letta-code. For the TypeScript SDK: npm install @letta-ai/letta-agent-sdk. Cloud SDK use requires a Letta API key, supplied as LETTA_API_KEY.
How do you use this agent?
The first CLI invocation is: letta. For cloud SDK use, create new LettaAgentClient({ backend: "cloud", apiKey: process.env.LETTA_API_KEY }), call await client.createAgent({ model, human, persona }), then use await using session = client.resumeSession(agentId), await session.send("What do you know about me?"), and session.stream() to receive output. To run through the local SDK backend, use new LettaAgentClient({ backend: "local" }); it starts Letta Code as a subprocess.
How does this agent compare with similar options?
For new projects, the README recommends the Letta Agent SDK. Previous-generation V1 SDKs—@letta-ai/letta-client for TypeScript and letta-client for Python—remain available for direct use with the Letta API.