Letta

Not restorable in one action: the local ~/.letta/lc-local-backend directory is complete, but AgentFile export and import were removed, so the agent can move only by copying that directory by hand; `letta memory restore` restores only local backups of the same agent.

• Letta Code README: AgentFile deprecation
• memory subcommand source
• Letta Code AGENTS.md: local backend storage root

In local mode, ~/.letta/lc-local-backend holds everything that defines the agent (agent records, transcripts, compiled system prompts, git-backed memory and skills, and provider credentials), and the docs direct owners to back up that directory. Agents on Letta Cloud, the default backend, are held by Letta and lack this complete copy.

• local-store.ts
• Letta Docs: Local setup
• Letta Code README: AgentFile deprecation

Local mode runs an embedded backend without a Letta login and can use local inference (Ollama, LM Studio, llama.cpp). By default, though, the runtime contacts Letta servers for telemetry and auto-update checks unless LETTA_CODE_TELEM=0 (or DO_NOT_TRACK=1) and DISABLE_AUTOUPDATER=1 are set, and the backend is still gated by an env flag named LETTA_LOCAL_BACKEND_EXPERIMENTAL.

• Letta Docs: Local setup
• telemetry/index.ts
• backend/local/paths.ts

Agents have no identity key of their own, only backend-assigned IDs. Contacts can recognize the agent through its channel accounts (for example Telegram or Slack), whose config under ~/.letta/channels moves with the agent, but credentials go to the OS keyring by default and travel only with the file store.

• local-agent-record.ts
• Letta Docs: Channels
• channels/credential-store.ts

No license checks were found in local mode. The CLI auto-updates by default (opt-out with DISABLE_AUTOUPDATER=1), so the vendor can change runtime behavior, as shown when it dropped support for the Docker server and .af import. Pinned older versions continue to run.

• updater/auto-update.ts
• Letta Docs: Docker image no longer supported

Memory, tools, skills, hooks, crons and channels run in the Letta Code runtime and keep working with any configured provider, including local models. Features that need a Letta login (Secrets, remote computers, cloud sandboxes) depend on Letta's hosting, not on a model provider's API.

• Letta Code README: Feature Overview
• Letta Docs: Local setup

Local state is stored as JSON files (agent records, conversation manifests, system prompts, auth.json), JSONL transcripts, and memory as Markdown with YAML frontmatter in a git repository. All of it is readable without Letta software.

• Letta Docs: MemFS
• local-transcript.ts

Memory files under system/ make up the system prompt, and each conversation's compiled system prompt is stored locally in system-prompt.json. Runtime-injected system reminders are hidden by default but can be shown with `/system-reminders on`. On Letta Cloud, bundled default prompts become 'Cloud-managed' and update automatically unless LETTA_CODE_PRESERVE_CLOUD_SYSTEM_PROMPT=1 is set.

• system-reminders command source
• Letta Code README: Letta Cloud

In local mode, message content stays on-device, but telemetry is enabled by default and sends session, tool-usage, token-count and error events keyed by a device ID to Letta's cloud API. On Letta Cloud, Letta stores the full agent state and its privacy policy allows hosted data to be used for training.

• telemetry/index.ts
• backend/api/metadata.ts
• Letta Privacy Policy

Each conversation's messages, including tool calls and tool results, are stored locally in messages.jsonl and searchable with `/search`, and compaction appends to the transcript rather than discarding it. Memory changes are also recorded as git commits.

• local-store.ts
• Letta Docs: MemFS

Skills are SKILL.md folders (global, project and agent-scoped in MemFS), hooks are scripts, and the harness is open-source TypeScript that can be extended with mods.

• Letta Docs: Skills
• Letta Docs: Hooks

No advertising or sponsored-content channel was found. External skills from registries such as ClawHub enter the agent only when the owner explicitly installs them.

• Letta Code README: Installing external skills

Tool calls and results are persisted durably to messages.jsonl as messages stream, but nothing holds back a tool call when its record cannot be written.

• local-store.ts

Memory changes are git commits, so edits to memory history are detectable. Action and conversation transcripts (messages.jsonl) carry no integrity data and can be rewritten without trace.

• Letta Docs: MemFS
• local-transcript.ts

The runtime guard blocks access to other agents' memory, and permission modes can require approval for shell and file edits, but nothing keeps an agent's tools away from its own transcript files. The agent also edits and commits its own git-backed memory by design.

• Letta Docs: Permissions
• Letta Docs: MemFS

Transcripts are JSONL and memory history is a standard git repository, both readable with jq, git or a text editor.

• local-transcript.ts
• Letta Docs: MemFS

When agents message each other (the SendAgentMessage tool or `letta -p --from-agent`), the sender's record holds the target agent and conversation IDs and a client message ID, and the recipient stores the message under that conversation ID, so both sides log a shared identifier.

• send-agent-message.ts
• messaging-agents skill

Letta Code is Apache-2.0 open source with a Nix flake and lockfiles, but reproducible release builds are not documented. The Letta Cloud server side cannot be verified.

• letta-code LICENSE
• flake.nix

Settings (.letta/settings.json), memory and compiled prompts are inspectable files. The effective behavior also depends on environment variables, CLI overrides and, on Cloud, Cloud-managed prompts that update automatically.

• Letta Docs: Configuration
• Letta Code README: Letta Cloud

Messages are not signed by the agent. Recipients can attribute them only through the sending channel account, which moves with the agent when its credentials use the file store rather than the default OS keyring.

• Letta Docs: Channels
• channels/credential-store.ts

The action and transcript record (messages.jsonl) carries no integrity data to check. Git tooling such as `git fsck` covers only the memory history.

• Letta Docs: MemFS
• local-transcript.ts

Memory is versioned in git, and the rest of the local state is JSON and JSONL files, so the owner can copy the state at two points in time and compare the copies with git and diff.

• Letta Docs: MemFS
• Letta Docs: Local setup

The system prompt is built from editable memory files under system/, and custom prompts can be set explicitly. The owner can read and rewrite all of them.

• Letta Docs: MemFS
• system-prompt-compilation.ts

Memory is Markdown files in a git repository that the owner can view, edit and delete with ordinary tools. `letta memory` also offers backup, restore and export.

• Letta Docs: MemFS
• memory subcommand source

The owner can add, edit or delete skills, hooks, crons and mods, and the harness source is Apache-2.0.

• Letta Docs: Skills
• Letta Code README

Arbitrary MCP servers and skills can be added. Tools can be restricted with `--tools`, allow/deny patterns and permission modes.

• Letta Docs: Permissions
• mcp subcommand source

The local backend supports bring-your-own provider keys and local inference through Ollama, LM Studio, llama.cpp and OpenAI-compatible endpoints. Memory and tools are implemented in the harness, not in model-API features.

• Letta Docs: Local setup
• backend/dev (Ollama, LM Studio, llama.cpp providers)

Changing instructions, memory, skills, tools or code in local mode needs no license check or paid tier. Paid and Cloud features concern hosting (secrets sync, remote computers), not modification.

• Letta Code README: Feature Overview

The runtime enforces channel DM policies (pairing, allowlist or open), group sender policies, admin tiers and tool allow/deny rules. The owner cannot limit which hosts or peers the agent's own tools contact.

• Letta Docs: Channels
• Letta Docs: Permissions

The runtime enforces the permission modes (strict, standard, acceptEdits, unrestricted) and allow/deny rules, pausing for approval on restricted tools.

• Letta Docs: Permissions

The owner can interrupt a running turn, and the runtime records it as interrupted by the user. Local processes, including `letta server`, can be stopped at any time.

• Letta Docs: Slash commands
• constants.ts (INTERRUPTED_BY_USER)

Telemetry is on by default ('Enabled by default unless explicitly disabled'). In the CLI it is posted to Letta's cloud API even when the local backend is used. The privacy policy says hosted-service data may be used to train models, without a documented opt-in.

• telemetry/index.ts
• backend/api/metadata.ts
• Letta Privacy Policy

In local mode, provider keys and OAuth tokens are kept in a local auth.json with 0600 permissions, which the owner controls and can inspect. The Secrets feature and Cloud-native integrations (such as Slack for Cloud agents) need a Letta account, which places those secrets with Letta.

• local-provider-auth-store.ts
• Letta Docs: Secrets

Local agent state can be deleted permanently by removing ~/.letta/lc-local-backend. Telemetry already sent is retained under Letta's privacy policy, which gives no specific retention period, and Cloud agents depend on Letta's deletion process.

• Letta Docs: Local setup
• Letta Privacy Policy