Pane is a desktop agent manager for developers running persistent AI agents. Run multiple Letta Code subagents in parallel — each in its own worktree, each accumulating memory independently — with a workspace that survives restarts without losing either the Pane session layout or the Letta agent state.
Windows SmartScreen warningDirect downloads can show a SmartScreen warning while Pane is unsigned. Pane is fully open source, so you can audit the code and build from source yourself.1. Click More info2. Click Run anyway3. Continue the installerThe PowerShell install downloads the official release directly and avoids most browser download friction.npm global install
Letta Code is a coding agent from the Letta AI team, the researchers behind MemGPT. Its defining characteristic is persistent memory: agent context survives across sessions and restarts, stored in a Letta server or local persistent store. On Terminal-Bench (v1) it scored 42.5%, which the Letta team highlights as the top result among open-source model-agnostic agents — see the announcement post for methodology.
Letta Code is the right choice when memory persistence is an architectural requirement rather than a nice-to-have — for long-running subagent workflows where context must carry across restarts. The team published an announcement post covering the MemGPT lineage and design decisions.
I run Letta Code in Pane for tasks where the agent needs to remember decisions made in a previous session — one subagent per pane, each accumulating its own memory on its own branch.
two persistence layers, not one
Letta Code persists agent memory in a Letta server or local database. Pane persists session layout and worktree assignments in its own state. The two layers are independent — a Pane restart restores the workspace structure, a Letta restart restores the agent memory. Neither overwrites the other. When you come back after closing both, you restore to where you left off at both levels.
subagents per pane, isolated by worktree
Each Letta subagent runs in its own terminal on its own branch. Pane manages the worktree isolation so agents do not read each other's dirty state. Memory accumulates per-agent without cross-contamination. When an agent finishes a task, the diff is ready to review without leaving the Pane workspace.
what pane does
- starts each Letta agent in an isolated worktree
- keeps session output, diff review, and git actions in one workspace
- lets Letta run alongside Claude Code, Goose, or any other CLI agent
- works natively on Windows, Mac, and Linux
when one letta agent is enough
If you run one Letta Code agent at a time on one branch, a single terminal is sufficient. Pane adds value when you want multiple Letta subagents running concurrently on separate branches, or when you want to combine Letta Code with other terminal agents and keep each session isolated.
Last verified against Letta Code's current release. Written by Parsa Khazaeepoul, co-founder of Pane.
frequently asked questions
Yes, and the two persistence layers are independent. Letta Code stores agent memory in its own backend (a Letta server or local persistent store). Pane stores session layout and worktree assignments. When you restart Pane, Pane restores the session workspace; when you restart Letta Code, Letta restores agent memory. Neither depends on the other.
Yes. Start one Letta Code agent process per pane, each pointed at its own worktree. Pane manages the terminal isolation — Letta manages the agent memory. Each subagent accumulates its own memory without cross-contamination.
Pane organizes the workspace: named sessions, worktree isolation per branch, diff review without leaving the terminal environment, and git actions alongside the agent output. With multiple Letta subagents running in parallel, that workspace organization becomes the bottleneck. Pane removes it.
Pane keeps each session's output visible and navigable while the agent runs. A Letta task that runs for several minutes produces output that stays in the session scroll buffer. You can review what the agent wrote, check the diff, and move to another session without losing the context.
No. Pane is a terminal host — it does not wrap or intercept the Letta CLI. Configure Letta Code as you normally would (server URL, model provider, agent ID) and start it inside a Pane terminal.
Claude Code with memory extensions adds recall to a coding agent. Letta Code is built around persistent memory at the architecture level — it is the MemGPT lineage applied to software development. If memory persistence across restarts is a requirement, not a feature, Letta Code is the more purpose-built option.
Yes. Letta Code is model-agnostic — it supports Anthropic, OpenAI, Azure, and local models. Pane does not touch the model configuration. Whatever model Letta is configured to use, it uses inside a Pane terminal exactly as it would anywhere else.
If you are running multiple terminal-based agent evaluations in parallel — each on a separate branch, each needing its own session output visible — Pane provides the workspace structure. It does not automate the evaluation loop itself, but it makes running many concurrent sessions manageable.
If one agent and one branch covers your current work, a single terminal is sufficient. Pane is useful when you want multiple Letta subagents running concurrently on separate branches, or when you want to mix Letta Code with other terminal agents and need isolation between them.
Yes. Pane is a native Windows desktop app. Letta Code runs in a Pane terminal on Windows the same way it runs on Mac or Linux.
