Persistent memory is the reason to choose it
Letta Code treats memory as editable agent state rather than a transcript you reopen. An agent can rewrite memory blocks, learn skills, revise prompts, and alter the harness through mods. MemFS tracks that context with Git, and you can point it at your own GitHub repository. The practical appeal is continuity: the agent you used yesterday can resume with its identity and working knowledge instead of rebuilding context from a folder and a chat log.
That power changes the review burden. A tool that may update its own instructions needs tighter inspection than a stateless command runner. Letta includes permission modes, hooks, /doctor, and a Memory Palace view, but those controls do not decide which learned behavior your team should accept. Treat memory changes like code changes: inspect the diff, keep the repository recoverable, and decide which actions still require a person.
One agent can appear in five places
The same agent can run through the CLI, desktop app, browser, Slack, Telegram, or Discord. Letta Cloud stores memory, identity, and conversations, then lets a laptop, cloud VM, managed sandbox, or remote computer pick the work up. That is more than a cosmetic front end. It makes a long-running agent reachable where a team already talks and allows a headless message to target a named computer.
There is a real configuration bill behind that reach. Cloud is the first-launch default and requires a Letta account. A local backend skips that account, yet the agent still needs an OpenAI, Anthropic, Z.ai, or another supported model connection. Remote computers and managed secrets require sign-in. Each messaging channel brings its own bot credentials and access decisions. The README makes these routes discoverable, though a one-command npm install is only the start.
What happened when we ran it
Our sandbox installed commit 44b154e in 43 seconds. Bun pulled 600 packages, and the installed tree occupied 539 MB. The checkout itself contained 2,380 files, roughly 561,968 lines of source, and used 53 MB. This was a fresh unprivileged Debian container with 3 CPUs, 8 GB of RAM, Node 22, and no secrets.
The build completed successfully in 20 seconds. We found 17 CI workflow files, which shows that the repository has automation around it. We did not find a Dockerfile or a tests directory. More importantly, the measured commit exposed no test script or target, so the test step was skipped. That result says nothing about whether hidden or upstream checks pass. It says a fresh source user had no declared suite to run.
Those numbers make the source path reasonable for a project of this size, but they also set the floor. The 539 MB dependency tree arrives before model use, cloud state, channel setup, or a remote computer enters the picture. Our run proves that installation and compilation worked at the measured commit. It does not measure agent accuracy, model cost, memory quality, or the safety of learned instructions.
Local mode still depends on a model provider
Running letta --backend local keeps the agent backend on your machine, while /connect configures the model account. The distinction matters because local mode can sound like an included offline model. The README describes provider keys for OpenAI, Anthropic, Z.ai, and others. It does not promise a bundled model. Your data path and bill depend on the provider you select.
Letta Cloud adds useful portability. It also manages older bundled system prompts after resume unless LETTA_CODE_PRESERVE_CLOUD_SYSTEM_PROMPT=1 is set. Custom prompts stay explicit. Teams that audit prompt changes should make that choice deliberately, especially when one identity moves across 2 or more computers. AgentFile is no longer a fallback: .af export and import, /export, /download, --import, and --from-af have been removed.
A scheduler bug can lose promised local work
Open issue 4911, filed against version 0.34.2, describes a concrete failure in a two-process local setup. When an App Server process wins the scheduler lease while another process owns Slack or Telegram channels, due crons and one-shot Wakes can be recorded as fired and queued without adding a turn to the target conversation. The report says one recurring job skipped about 9 hours of runs before anyone noticed.
The issue includes a workaround: start the channel process first and monitor which PID owns the scheduler lease. That is useful, but a promised notification that looks successful and never arrives is a serious boundary for an always-on agent. If schedules matter, test the exact multi-process topology and alert on missing conversation turns. Do not treat a queued run record as proof of delivery.
Native Windows has another documented boundary. Automatic client-side dreaming stays disabled by default even when saved /sleeptime settings enable it. You can opt in with LETTA_ENABLE_WINDOWS_AUTO_REFLECTION=1, while manual /dream and /reflect remain available. macOS, Linux, WSL, and server-side dreaming do not share that default.
October activity is high, and the queue is large
GitHub showed 3,508 stars and 488 combined open issues and pull requests on October 4, 2026. The repository's last push was October 3, and v0.34.2 shipped on October 2. That release fixed memory Git configuration churn, channel behavior, secret handling, and tool internals while adding opt-in automatic reply relay. The dates show active maintenance, while the combined queue warns that activity is not the same as calm.
Choose Letta Code for its specific bet: an agent becomes more useful when its state, skills, and identity can survive a session and travel between interfaces. The 43-second install is the easy part. The lasting work is deciding what the agent may remember, rewrite, schedule, and send on your behalf.