Letta

The core is the Letta agent harness (also called Letta Code): a runtime that connects a model to the agent's persisted context, manages turns and executes a preset set of tools on the machine where it runs, with skills and mods as extension points. The CLI, desktop and web apps, App Server (WebSocket) and Agent SDK are different front ends to the same harness.

Multi-agent work is delegation from a main agent. It calls a subagent tool, the harness starts the subagent in a subprocess, and only the subagent's final message returns to the caller. Subagents can run in the background, can be existing stateful agents addressed by agent_id, and on Letta Cloud can be fanned out by an agent-written workflow script.

State belongs to the agent, not the process. Memory is MemFS, a git repository of Markdown files; every edit is a commit, and background "dreaming" subagents consolidate lessons from recent conversations. One agent can hold many conversations that share its memory. State lives either in Letta Cloud or in a local backend you run, independent of where tools execute.

Tool approval is set by permission modes: standard asks before shell commands, edits and subagents, acceptEdits auto-approves file edits, strict asks before every call, and unrestricted (--yolo) skips prompts. The docs note the interactive CLI starts in unrestricted; Shift+Tab cycles modes. Allow and deny rules give per-pattern control. In the Agent SDK, a canUseTool callback can allow, deny, or edit a tool call (updatedInput) and can stop the turn (interrupt: true). Users can also teach memory with /remember. Messages sent through the hosted MCP server run without approval prompts.

npm install @letta-ai/letta-agent-sdk tsx

import { LettaAgentClient } from "@letta-ai/letta-agent-sdk";

const client = new LettaAgentClient({ backend: "local" }); // state stays on this machine
const agentId = await client.createAgent({
  persona: "You are Scout, a teammate who keeps notes about this repository.",
  human: "The user wants short answers with file paths.",
});

await using session = client.createSession(agentId, {
  cwd: process.cwd(),
  permissionMode: "standard",
  canUseTool: async (toolName) =>
    toolName === "Bash" ? { behavior: "deny", message: "No shell in this demo" } : { behavior: "allow" },
});

await session.send("List the top-level folders and remember what each one is for.");
for await (const msg of session.stream()) {
  if (msg.type === "assistant") process.stdout.write(msg.content);
}

• The local backend and the App Server need Node.js 22.19+ (the SDK runs Letta Code as a subprocess).
• The cloud backend needs a LETTA_API_KEY; the local backend needs no account.
• Python applications cannot use the Agent SDK and must talk to the App Server WebSocket protocol directly.
• Local-only agents are stored on local disk; back up the MemFS repository yourself.
• The interactive CLI starts in unrestricted permission mode; switch to standard to get approval prompts.
• Older guides using the Python server packages or letta/letta Docker images target the retired V1 server.

Yes. The README describes Letta as formerly known as MemGPT.

It is now a landing page. The legacy V1 Python server sits on an archive branch, is retired and receives no security updates; current development is in letta-ai/letta-code.

Yes, in both directions. Agent SDK sessions can attach stdio, Streamable HTTP or SSE MCP servers, and Letta Cloud hosts an MCP server that clients such as Claude Code can use to create and message Letta agents. A2A and AG-UI support were not found.

The code is Apache-2.0 and self-hosting needs no Letta account. Letta Cloud has a free plan limited to three stateful agents plus paid personal, team and usage-based API plans listed on the pricing page.

The harness and Agent SDK target Node.js and TypeScript/JavaScript. The docs also mention Letta API client SDKs for TypeScript and Python that wrap the cloud REST API.