myAI vs Letta (MemGPT)

TL;DR: Letta (the commercial platform built on the MemGPT research project) is an "LLM operating system" — an agent architecture where the model manages its own memory hierarchy via tool calls, paging facts in and out of a limited context window. myAI is a continuity OS for your own development workflow: memory is one organ, alongside state/handoff, a task queue with an off-hours runner, budget guarding, and fleet management. Letta's unit of memory is a single agent's context; myAI's unit is an operator's entire working session across repos, machines, and tools. Different problem, different buyer.

What Letta does well

Letta is the direct commercial successor to MemGPT, the paper that introduced "virtual context management" for LLM agents, and it earns real credit for that lineage:

• Self-editing memory via tool calling. The agent itself decides what to keep in the active context window and what to page out — memory management is driven by LLM function calls, not an external pipeline. This is a genuinely elegant mechanism for a single long-running agent.
• A clean memory hierarchy. In-context ("core") memory splits into agent persona and user information, both self-editable; out-of-context ("archival") memory is backed by a vector database (Chroma, pgvector, and others) for long-term recall beyond what fits in the window.
• Multi-step reasoning via heartbeats. The agent can request to continue executing in a loop — useful for long, autonomous chains of tool calls within one session.
• Backend-agnostic archival storage. Because all memory access goes through tools, the archival store is swappable — vector DB, traditional database, or flatfiles — without changing the agent's reasoning loop.

When you should choose Letta

• You're building a single conversational or task agent and want the model itself to manage what it remembers, rather than hand-rolling a retrieval pipeline.
• You want an agent architecture/runtime, not just a memory store — Letta ships the whole agent loop (persona, tool-calling, heartbeats), not a bolt-on SDK.
• You're prototyping research on memory-augmented agent cognition and want the MemGPT primitives (core/archival/recall memory) as a starting point.

myAI isn't an agent runtime and doesn't compete here — it has no self-paging context manager and doesn't run its own agent loop. It plugs into whatever agent you already use (Claude Code, Cursor, Windsurf, Codex CLI, anything MCP-capable) rather than being one.

What myAI adds that Letta doesn't attempt

Letta manages one agent's context window. myAI carries an operator's whole working state forward — across sessions, machines, and however many agents and repos that operator runs:

• **Session-to-session continuity across different agents.** Letta's memory hierarchy lives inside a single Letta agent process. myAI's boot bundle (state, handoff, distilled brain) is agent-agnostic over MCP — close Claude Code tonight, open Cursor tomorrow, and it still knows what shipped, what's blocked, and what's next. Letta doesn't attempt cross-agent, cross-tool continuity; it wasn't built to be plugged into someone else's agent.
• A task queue and an off-hours runner. myAI queues work and a headless runner drives it overnight on your existing Claude subscription — $0 marginal token cost — surfacing finished work for review. Letta has no execution/scheduling story; it's an agent architecture, not a work queue.
• Budget awareness. myAI meters the subscription rolling window that actually constrains Claude Code Pro/Team users and checkpoints sessions before they strand work. Letta (like every memory-focused product) doesn't touch cost at this layer — it bills standard API tokens for whatever LLM calls the agent itself makes.
• Fleet scale. One gateway and dashboard across all your repos (myAI is dogfooded on a 25-repo fleet): app directory, morning review console, health checks. Letta is scoped to the agent(s) you build with it.
• Self-hosted as the only mode, not a tier. Letta's flagship is the commercial platform; myAI runs entirely on localhost (Docker: gateway + dashboard + MongoDB) with your own Anthropic key — nothing about your work leaves your machine, by default rather than by upgrade.
• Versioned, auditable memory. myAI's brain is a private git repo where sessions are branches and wrap-up is a merge — log, diff, blame, revert all apply to what your agents remember. Letta's core/archival memory evolves in place inside the agent's own store.

Where Letta is genuinely ahead

• In-session context management is Letta's whole job, and the self-editing tool-call mechanism is a more sophisticated way to keep one agent's active window relevant than anything myAI attempts — myAI doesn't manage a model's context window at all, it hands over a boot bundle once per session.
• It's a full agent runtime, not just memory — if you want the persona/tool-calling/heartbeat loop out of the box, that's a real head start Letta gives you that myAI (which assumes you already have an agent) doesn't.
• Research pedigree — MemGPT's virtual-context ideas are peer-reviewed and widely cited; Letta is the most direct production expression of that work.

Using both

The clean split: Letta (or its MemGPT ideas) inside an agent you're building; myAI around the operator running it. If you build a Letta-based agent as part of a myAI-managed repo, myAI still carries that repo's state, handoff, and task queue forward between sessions — it doesn't care what agent architecture lives inside the work.

Side by side

Bottom line: "Letta alternative" is the wrong search if what you actually want is an agent architecture with self-managed context — myAI doesn't build agents. But if what you actually want is for whatever agent you already use to remember you, your repos, and your queue from one session to the next — self-hosted, versioned, working while you sleep — that's the gap myAI fills and Letta doesn't attempt.

Back to the comparison overview · Concepts