본문으로 건너뛰기
TakoAPI
스킬로 돌아가기
—아직 평가 없음
내 평가

요약

Terminal-first, open-source AI agent manager for any CLI agent (agent agnostic), any OS (mac, windows, linux). The Open-Source Agentic Development Environment for running multiple coding agents in parallel. Run locally or self-host Remote Pane to manage agents from desktop or phone. Simplify multi-agent orchestration with the runpane CLI.

설명

<p align="center">
  <img src="frontend/src/assets/pane-logo.png" alt="Pane" width="120" height="120">
</p>

<p align="center">
  <strong>Run any coding agent, on any OS, from desktop <a href="#remote-pane">or phone</a>.</strong><br>
  <em>just terminals. no abstractions.</em>
</p>

<div align="center">

<a href="https://runpane.com" title="Click on this image to see more themes and demo">
  <img src="assets/readme-remote-pane.png" alt="Pane desktop app and Remote Pane mobile browser app" title="Pane desktop app and Remote Pane mobile browser app" width="100%">
</a>

Appearance follows your OS — see [Appearance](docs/APPEARANCE.md).

[![AGPL-3.0 License](https://img.shields.io/badge/License-AGPL--3.0-555555.svg?labelColor=333333&color=666666)](./LICENSE)
[![Downloads](https://img.shields.io/endpoint?url=https://runpane.com/api/badge/downloads&labelColor=333333&color=666666)](https://github.com/greenfield-inc/Pane/releases?utm_source=github)
[![GitHub](https://img.shields.io/badge/GitHub-source-555555?labelColor=333333&color=666666&logo=github&logoColor=white)](https://github.com/greenfield-inc/Pane)
[![Latest Release](https://img.shields.io/badge/Release-latest-555555?labelColor=333333&color=666666)](https://github.com/greenfield-inc/Pane/releases/latest?utm_source=github)
[![Changelog](https://img.shields.io/badge/Changelog-runpane.com-555555?labelColor=333333&color=666666)](https://runpane.com/changelog)
[![Active Users](https://img.shields.io/endpoint?url=https://runpane.com/api/badge/installs&labelColor=333333)](https://runpane.com)
[![Discord](https://img.shields.io/badge/Discord-join-%235462eb?labelColor=%235462eb&logo=discord&logoColor=%23f5f5f5)](https://discord.gg/BdMyubeAZn)

<br />

**Made possible by our amazing contributors**

<a href="https://github.com/greenfield-inc/Pane/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=greenfield-inc/Pane" alt="Pane contributors">
</a>

<sub><a href="./CONTRIBUTING.md">Join them</a> and help make Pane better.</sub>

<br />
<br />

**Quick install (recommended)**

<sub>Mac / Linux</sub><br />
<pre><code>curl -fsSL https://runpane.com/install.sh | sh</code></pre>

<sub>Windows (PowerShell)</sub><br />
<pre><code>irm https://runpane.com/install.ps1 | iex</code></pre>

<sub><em>Bypasses the macOS Gatekeeper / Windows SmartScreen prompts on direct downloads.</em></sub>

<br />
<br />

<sub>or download the installer directly</sub><br />
<br />

<a href="https://runpane.com/api/download?version=latest&amp;platform=mac&amp;arch=arm64&amp;format=dmg&amp;source=gh-readme">
  <img src="https://img.shields.io/badge/Download_for_macOS-000?style=for-the-badge&logo=apple&logoColor=white" height="40" alt="Download for macOS (Apple Silicon)">
</a>
<a href="https://runpane.com/api/download?version=latest&amp;platform=windows&amp;arch=x64&amp;format=exe&amp;source=gh-readme">
  <img src="https://img.shields.io/badge/Download_for_Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white" height="40" alt="Download for Windows (x64)">
</a>
<a href="https://runpane.com/api/download?version=latest&amp;platform=linux&amp;arch=x64&amp;format=appimage&amp;source=gh-readme">
  <img src="https://img.shields.io/badge/Download_for_Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black" height="40" alt="Download for Linux (x64 AppImage)">
</a>
<br />
<sub>Other builds: <a href="https://runpane.com/api/download?version=latest&amp;platform=mac&amp;arch=x64&amp;format=dmg&amp;source=gh-readme">macOS (Intel)</a> · <a href="https://runpane.com/api/download?version=latest&amp;platform=windows&amp;arch=arm64&amp;format=exe&amp;source=gh-readme">Windows (ARM64)</a> · <a href="https://runpane.com/api/download?version=latest&amp;platform=linux&amp;arch=arm64&amp;format=appimage&amp;source=gh-readme">Linux ARM64 AppImage</a> · Linux .deb (<a href="https://runpane.com/api/download?version=latest&amp;platform=linux&amp;arch=x64&amp;format=deb&amp;source=gh-readme">x64</a>, <a href="https://runpane.com/api/download?version=latest&amp;platform=linux&amp;arch=arm64&amp;format=deb&amp;source=gh-readme">ARM64</a>)</sub>

<br />
<br />

<details>
<summary><sub>Other install methods: npx, pnpm, and pipx</sub></summary>
<br />

<pre><code># Guided setup via npm
npx --yes runpane@latest

# pnpm one-shot
pnpm dlx runpane@latest

# Python tools one-shot
pipx run runpane

# Persistent npm install
npm i -g runpane
runpane setup</code></pre>

</details>

<br />
<br />

[Installation](#installation) · [What Flying Feels Like](#what-flying-feels-like) · [Remote Pane](#remote-pane) · [Workspaces](#pane-workspaces) · [Handoff](#hand-off-a-task) · [Pane Chat](#pane-chat) · [Agent-Operable CLI](#agent-operable-cli) · [Keyboard Shortcuts](#keyboard-shortcuts) · [Building from Source](#building-from-source)

</div>

Not an IDE. Not a terminal emulator. **Vim for agent management.**

Pane manages AI coding agents without replacing them. If it runs in a terminal, it runs in Pane — instantly, with zero integration. Claude Code, Codex, Cursor Agent, Aider, Goose, or any CLI tool. No plugins, no SDK, no waiting for support.

---

## Why Pane Exists

AI coding agents are incredible. Claude Code can work autonomously for hours. Codex can ship features end-to-end. Aider can refactor entire modules. The models are not the bottleneck.

**The way you interact with them is.**

Managing AI agents right now feels like air traffic control with a walkie-talkie. You're juggling terminal windows. Copy-pasting between tabs. Losing track of which agent is on which branch. Alt-tabbing between your diff viewer, your terminal, your git client, and your editor. The agents are fast — but your tools make you slow.

And then there's git worktrees. Everyone agrees worktrees are the right way to run parallel agents — isolated branches, no conflicts, clean separation. But actually using them? It's miserable. `git worktree add`, `git worktree remove`, remembering paths, tracking which worktree is on which branch, cleaning up stale ones, rebasing back to main, squashing commits before merging. Even experienced developers fumble the workflow. It's powerful infrastructure with terrible UX.

Pane makes worktrees invisible. You create a session, Pane creates the worktree. You delete a session, Pane cleans it up. You hit a shortcut, Pane rebases from main. You never type `git worktree` again. All the isolation benefits, none of the pain.

---

## What Flying Feels Like

Each of these is a small thing. Together they compound fast.

| Feature | | |
|---|---|---|
| **Pane Chat** | A global orchestrator terminal that starts in the Pane data directory, reads local orchestration instructions, and can coordinate Claude, Codex, Cursor, OpenCode, or Pi across repositories, panes, tabs, worktrees, and review loops. | <a href="#pane-chat">Details</a> |
| **Remote Pane** | Run panes, worktrees, terminals, files, git state, and approval prompts on a self-hosted remote machine while controlling them from desktop Pane or the browser app at [runpane.com/app](https://runpane.com/app/). | <a href="#remote-pane">Setup</a> |
| **Pane Workspaces** | Let an agent on one of your machines read files, run commands, and drive Pane on another over Tailscale. Hand off a task with its branch and a written note; a handoff to the same agent continues your own session there. | [Workspaces](#pane-workspaces) · [Handoff](#hand-off-a-task) |
| **Agent-Operable CLI** | Pane ships with `runpane agent-context`, `runpane repos add`, and `runpane panes create`, so a coding agent can discover Pane's command schema, register a repo, open a Pane for each new issue, and add agent tabs to existing Panes for review and fixes (one Pane per feature). Claude Code, Codex, and Cursor get the same commands as MCP tools, and Claude can also get them, with Pane's skills, from the [Pane Claude plugin](claude-plugin/README.md). | [Contract](docs/RUNPANE_CLI_CONTRACT.md) · [MCP](docs/PANE_MCP.md) |
| **Approvals** | Agents ask you through the `notify` MCP tool instead of waiting in their terminal. Inside Pane, an Approvals row in the sidebar opens everything that waits on you, newest first, or by Session or project, beside that Session's live tabs; over other apps a strip shows the question, and one click sends the answer back as the tool's result. ⌃⇧Space answers the whole queue by keyboard. In a Session, workers relay to their orchestrator, which posts for them. A Pane desktop shows the questions of every machine it has saved, and your phone gets an alert. | [Approvals](docs/PANE_NOTIFY.md) |
| **Pane secrets** | An agent asks you for an API key on a masked card, then runs its command with `runpane secrets exec`; the value never enters chat. Secrets are shared by every agent and synced to every machine you have saved, and Project Settings variables can point at them. | [Pane secrets](docs/PANE_SECRETS.md) |
| **Pane on Even G2 glasses** | See every Notify card from all your computers on Even Realities G2 glasses, answer with the R1 ring or your voice, and open any Pane's live terminal to read it and dictate into it. Pair once from the Pane phone app. | [Even G2 glasses](docs/EVEN_G2_GLASSES.md) |
| **Machine health** | Pane watches free disk, memory pressure and every process it started, on this computer and each one you linked. It removes its own leftovers by itself, asks once before archiving finished Panes or clearing agent temp files, and warns about a likely memory leak. Resources, the gauge beside the machine switcher, shows what each Pane costs and frees it in one click, and lists the other apps on the machine with a stop button for each; agents clean up with `runpane machine cleanup`. | [Machine health](docs/MACHINE_HEALTH.md) |
| **To-dos** | One list of the work you want agents to do. Each to-do you start gets its own Session and orchestrator, carries its plans, PRs and findings as attachments, and asks for your review when it is done. Pane keeps an in-progress to-do moving (it reminds, then restarts, then asks you) and holds new to-do agents while the machine is busy. | [To-dos](docs/TODOS.md) |
| **Profiles** | A profile is one file that defines a team of agents and a fixed workflow (plan, build, review, merge). Pane draws the workflow, launches it on any CLI with each step as a terminal tab, and routes each step's reported outcome to the next one; greenfield and the dcouple agents ship with Pane. Turn it on in Settings › Advanced › Profiles. | [Profiles](docs/PROFILES.md) |
| **Loops** | Run an agent or command on a cron schedule, such as a nightly bug sweep. Each run is a new Pane in a fresh worktree, ready to review. Loops are for large recurring jobs and run at most once an hour. | [Loops](docs/LOOPS.md) |
| **@mention Terminals** | Type `@` in any terminal to pull the last 500 lines from another pane's terminal directly into your context, no copy-paste required. Turn it off in Settings → Terminal. | <img src="images/qol-at-mention.png" alt="Cross-terminal @mention picker" width="420"> |
| **Clipboard Shortcuts** | `Cmd+Option+[key]` on macOS (`Ctrl+Alt+[key]` on Windows and Linux) pastes any saved text snippet instantly, so your most-used prompts are one keystroke away forever. | <img src="images/qol-clipboard.png" alt="Terminal clipboard shortcuts popover" width="280"> |
| **Terminal Popover** | Highlight any text in a terminal and an intelligent popover offers the right action: copy, open in browser, or show in explorer. Right-click offers the same actions, plus Paste and Select All. Prefer copy on select? Turn it on in Settings → Terminal. | <img src="images/qol-terminal-popover.png" alt="Terminal text selection popover" width="420"> |
| **Custom Links** | Turn any pattern in terminal output into a link: an issue key like `PROJ-123` opens your tracker, a build number opens CI. Set a regex and a URL with `$0`–`$9` in Settings → Links, then Ctrl/Cmd+Click. | |
| **Built-in Browser** | Preview any URL in a tab next to your terminals so every pane can see its own running dev server without alt-tabbing. When a Pane's terminal or agent starts a web server, Pane offers to open a live preview of it beside the agent; the preview is that Pane's tab, so it follows the Pane. A new tab, or the address bar's Ports button, lists every port listening on the machine, grouped by the Pane that started it. A tab's page runs on the computer that owns its Pane; another desktop, the web app and the phone app show their own copy, and a live stream of the host's page while an agent acts on it ([how](docs/BROWSER_AGENTS.md#on-another-screen)), and the phone app's Explorer tab browses, edits and previews the worktree's files ([how](docs/SELF_HOSTED_REMOTE_DAEMON.md#files-on-the-phone)). Links in terminals, chats and cards, and links opened by tools like `gh pr view --web`, open in a Pane browser tab beside where you clicked; Settings → Links sends them to your system browser instead ([Links](docs/BROWSER_AGENTS.md#links)). To sign in with your password manager on the computer that runs the tab, use **Open in your browser**, or see which desktop apps may fill the tab ([Passwords in browser tabs](docs/BROWSER_PASSWORDS.md)). | <img src="images/qol-browser.png" alt="Built-in browser tab previewing a local dev server" width="420"> |
| **Status Cues** | Every AI pane reports its state at a glance — a red dot when an agent is blocked waiting on your approval, a blue cue while it works, and a "done" cue when it finishes while you're looking elsewhere. The same rollup colors the project dots and pane tabs, on the desktop and in the phone app, so a whole screen of parallel agents reads in one glance. Any program can also report its own state with the OSC 7501 escape sequence ([Program status](docs/PROGRAM_STATUS.md)). | <img src="images/qol-status-dots.png" alt="Session agent status dots: blocked, working, done" width="280"> |
| **Jump + Refresh** | Jump to top, jump to bottom, or hard-refresh any terminal from the toolbar to unstick a frozen state in one click. | <img src="images/qol-jump-refresh.png" alt="Terminal jump and refresh controls" width="120"> |
| **Auto Secrets Copy** | Every pane automatically mirrors `.env` files and secrets from your root project so your worktree is runnable the moment it's created. | |
| **Isolated Ports** | Each pane runs on its own port range automatically, so you can spin up five dev servers in parallel without a single conflict. | |
| **Terminal Rendering Patches** | Claude Code's scroll-jump bug (long conversations snapping to top when you scroll up) is fixed here, even though it's still broken in Claude Code itself. | |
| **Drag and Drop** | Drop a file of any size into a terminal and it lands exactly where you need it, with progress while it copies. | |

---

## SSH hosts

Pane lists every host in your SSH config (`~/.ssh/config`, or `C:\Users\<you>\.ssh\config` on Windows, plus the files it `Include`s) under **SSH hosts** in the sidebar. Click one and a terminal tab opens with `ssh <host>`, using your own `ssh`, keys and agent. It needs no project, and Pane never reads or copies your keys. Edit the config and the list follows. See [SSH hosts](docs/SSH_HOSTS.md).

---

## Remote Pane

Run agents on a VM, WSL box, home server, desktop, Mac mini, or cloud machine while you keep the Pane UI on your laptop or phone. Remote Pane is self-hosted and open source: the host machine runs the repos, terminals, git state, files, agent credentials, and compute.

### Add a phone or another computer

On the computer, open Pane and choose **Pair a device** on Home, or **Add a device** in Settings › Remote Access. Point your phone's camera at the code and tap the link: it opens the Pane app, or Pane in the phone's browser. The iPhone app is in public beta: [join it in TestFlight](https://testflight.apple.com/join/eKJmnzXF). For another computer, copy a one-time link from **Add a device › Computer** and open it there. It works on any network, with terminals, alerts and dev server previews. Linked computers reach each other for remote mode, ports and `runpane workspace`, and each shows once in Settings › Remote Access › Computers, where Pane reaches it on the nearest route that answers: same network, Tailscale, SSH, a public URL or Pane's relay. Pane's servers pass the encrypted connection along without reading it, or you can [run your own relay](docs/SELF_HOSTED_RELAY.md). See [Add a device](docs/QR_PAIRING.md).

### Connect with a code or Tailscale

The original setup path, with a `pane-remote://...` code over Tailscale or SSH:

1. Install Pane normally on the machine that should host your projects and agents.
2. Open `Settings > Remote Access > Tailscale` on that host machine.
3. Click **Set Up Host** and copy the generated `pane-remote://...` connection code.
4. On another desktop, open Pane, go to `Settings > Remote Access > Tailscale`, paste the code under **Paste a connection code**, and connect.
5. On a phone or tablet, open [runpane.com/app](https://runpane.com/app/), or the Pane iPhone app ([public beta in TestFlight](https://testflight.apple.com/join/eKJmnzXF)), paste the same code, and connect.

A connected desktop reaches the host's dev servers at their usual `localhost` address: terminal links and live reload work as on the host. See [Forwarded ports](docs/SELF_HOSTED_REMOTE_DAEMON.md#forwarded-ports). Every other screen, the phone included, shows its own copy of each browser tab, and a live stream of the host's page while an agent acts on it. See [Browser tools](docs/BROWSER_AGENTS.md#on-another-screen).

For a headless VM or server, run the guided setup in its terminal:

```bash
npx --yes runpane@latest
```

Choose **Set up a remote host**, give it a name, and follow the
Tailscale login prompts. Paste the printed connection code into Pane or
[runpane.com/app](https://runpane.com/app/) on another device signed into the same
Tailscale network.

To skip the menu and run interactive remote setup directly:

```bash
npx --yes runpane@latest install daemon --interactive-tailscale-setup --auto-listen-port
```

pnpm:

```bash
pnpm dlx runpane@latest
```

Python tools:

```bash
pipx run runpane
```

Use SSH instead of Tailscale:

```bash
npx --yes runpane@latest install daemon --label "My Server" --prefer-tunnel ssh
```

The hosted shell installers remain available:

```bash
curl -fsSL https://runpane.com/install-remote.sh | sh -s -- --label "My Server"
```

Windows PowerShell:

```powershell
& ([scriptblock]::Create((irm https://runpane.com/install-remote.ps1))) -Label "My Server"
```

The CLI setup command prints the same connection code and, for SSH mode, the forwarding command. See the [Remote Daemon docs](https://runpane.com/docs/remote-daemon) for the full step-by-step setup, mobile install instructions, API key notes, and security model, or [docs/SELF_HOSTED_REMOTE_DAEMON.md](docs/SELF_HOSTED_REMOTE_DAEMON.md) in this repo.

For agents reaching your own machines from the CLI, see [Pane Workspaces](#pane-workspaces) below.

Integration keys (voice dictation, iPhone notifications) set on one host reach your other hosts through your devices that have them saved. See [Shared integration keys](docs/SHARED_CREDENTIALS.md).

---

## Pane Workspaces

Your agent can work across your Macs, Windows PCs, and Linux machines. Read a file on your desktop, run a command on your build machine, or check the agents running on your laptop — from the same terminal.

On Tailscale, workspaces use your Tailscale login, with no SSH keys or pairing codes. Install and sign in to Tailscale on both machines, enable HTTPS Certificates in the Tailscale admin console (see [setup](docs/RUNPANE_WORKSPACES.md#turning-it-on)), and keep Pane running on the machine you want to reach. Workspaces are on by default for the normal desktop install; `runpane workspace list` shows which machines are answering. Other people's machines on your tailnet appear too, labeled with their owner, and answer when their owner sets Who can connect to Everyone on tailnet. Tagged devices are refused. Computers you linked in Pane appear too, one entry each, and answer with Tailscale off; link one with no screen with `runpane link '<link>'`.

Use the npm CLI (`npm i -g runpane`); the Python wrapper does not run workspace commands. Replace `devbox` with a machine name from the list:

```bash
runpane workspace list
runpane workspace devbox read '~/project/README.md'
runpane workspace devbox exec -- 'git --version'
runpane workspace devbox panes list --json
```

Paths belong to the destination machine. `read` and `write` translate Windows and WSL path forms; `exec` uses that machine's shell. Workspaces give your agents file and command access on your joined machines. Run `runpane workspace disable` on a machine that should stop accepting it.

See [Workspaces setup, trust, and troubleshooting](docs/RUNPANE_WORKSPACES.md) for path examples and startup diagnostics. Remote Pane's [pairing codes](#remote-pane) remain the way to connect a desktop or browser UI.

### Workers on your other machines

A Session on this computer can run workers anywhere in your workspace. From the Session's agent, `runpane workspace devbox panes create --repo "Pane (win)" --tool-command "codex -m <model>" --prompt "..."` starts a worker on that machine (pick a saved WSL repository to run it in WSL), and it joins the Session: its reports, blocked questions and exits reach this computer's `runpane watch`, Approvals and phone, and your answers go back to its tab. The machine must be saved on this computer. See [Workers on another machine](docs/RUNPANE_WORKSPACES.md#workers-on-another-machine-join-your-session).

### Ask another model

`runpane ask --agent codex --model <model> --machine devbox --repo "Pane (win)" --prompt "Why does this fail on Windows?"` asks any agent and model one read-only question, on any of your machines, and prints the answer; nothing is left open. `runpane models --all` lists the models each installed agent offers on each machine. See [Ask another model a question](docs/RUNPANE_WORKSPACES.md#ask-another-model-a-question).

### Hand off a task

“Continue this on my Windows machine with Codex.” `runpane handoff` starts the agent in a new Pane on the other machine (or a new tab in your Pane on this one), using your pushed branch and a note about the task. When the sending tab runs Claude, Codex, Cursor or OpenCode and the receiver is the same agent, it carries the agent's own session: another machine gets a copy of the session's files and resumes it, and this machine resumes a fork of it. The CLI then checks that the receiver continued the conversation, and reports `continued`, `inconclusive` (with a question to ask the receiver), or `not-continued` (the receiver is kept, never replaced). With `--note-only`, a different agent, or no session to carry, a fresh agent starts with the note instead, and the output says so. The note carries the goal, decisions, verified state, and next steps either way. Live processes stay on the original machine.

To move a whole Session instead, right-click it and choose **Move to machine…**. Pane carries every Pane with its worktree and uncommitted work, every tab and its conversation, and the Session folder to another of your machines, starts the agents there, and archives the Session here as "Moved to <machine>" (**Restore here** brings it back). **Hand off with a note…** in the same dialog keeps the agent handoff above, for a single task, another agent or a teammate's machine. See [Move a Session to another machine](docs/SESSIONS.md#move-a-session-to-another-machine).

To hand off a Pane's task, run from the repository you're handing off. On the destination, clone the same GitHub repository if needed and add that checkout to Pane. Install and sign in to the receiving agent there. Keep Pane running there. Use the npm CLI. On the destination, choose a repository outside WSL; WSL receivers are not supported.

From a Bash or Zsh terminal (for example, on your Mac):

```bash
runpane handoff --template > ~/handoff.md
# Fill in every section of the note; use "None" where appropriate.
# Commit and push the task's changes, then check the note and git state:
runpane handoff "codex on devbox" --note-file ~/handoff.md --dry-run
runpane handoff "codex on devbox" --note-file ~/handoff.md
```

You can choose Claude, Codex, or Cursor, with a model and, for Claude or Codex, an effort level. Optional `--push` commits remaining changes except the note as WIP and pushes without forcing, so review your working tree first.

The receiver gets instructions to verify the starting commit, continue the note's next steps, push to your original branch, and report back to your sending panel with `runpane workspace <sender> panels submit`. Stop editing that branch after handing it off; when the session continues on the receiver, the sending agent ends its turn and you can close its tab. Carrying a Cursor chat to another machine is best effort, since Cursor's store is undocumented (on the same machine it isn't carried: a copied Cursor chat still writes to the original), and the destination's agent store is assumed at its default location (`~/.claude`, `~/.codex`, `~/.cursor`). If you sent from outside a Pane panel, the instructions use a PR comment or commit message instead.

See the [handoff guide](main/src/services/paneChatBundle/skills/handoff/SKILL.md) and [CLI options](packages/runpane/README.md#handing-work-to-another-machine).

---

## Pane Chat

Pane Chat is the global orchestrator terminal for a Pane workspace. It is not tied to a repository or worktree. It starts from the Pane data directory, reads a generated local runtime context, and uses the `runpane` CLI to inspect and operate the workspace.

Use it for the work that spans panes:

```text
Add this repo, create three worktree panes for the next features, start Codex in each one, and keep a separate review tab ready for every PR.
```

Already working in other agent tools? Settings → AI & Agents → "Bring sessions into Pane" finds your sessions from Claude Code, Codex, Conductor, Paradev (formerly Superset), Herdr, Emdash, Orca and T3 Code, and brings them in with one click, each in a Pane tab with its own agent's resume. Say "migrate to Pane" and Pane Chat also finds OpenCode and Cursor agent sessions (or anything similar), forks ones still running, and checks that each continues where it left off. On a new install, the first-run screen asks which agent you use and offers to bring your recent sessions in; Yes opens the Onboarding Session, which brings them in, groups them into Sessions, and opens a Start here page. See [Bring your existing sessions into Pane](docs/SESSIONS.md#bring-your-existing-sessions-into-pane).

Pane Chat keeps the human discussion at the orchestrator level, captures work as tickets or briefs, then hands authorized implementation to Claude, Codex, Cursor, OpenCode, or Pi agents in Panes through RunPane.

The prompt stays small because Pane ships its skills and installs them into the Pane data directory at startup, whenever the bundled copy has changed:

- `skills/pane-chat/pane-orchestrator/SKILL.md`: the Pane Chat entry point (also in `.claude/skills/`, `.codex/skills/`, and as `.cursor/rules/pane-orchestrator.mdc`)
- `skills/pane-chat/runtime-context.md`: how to reach this Pane install
- `skills/pane-chat/skills/`: the bundled skills, also installed in `.claude/skills/` and `.codex/skills/`
- `.claude/agents/` and `.codex/agents/`: helper subagents (explorer, cold-reader, qa-and-verify, reviewer)

The bundle lives in `main/src/services/paneChatBundle/`. It is built on Agent Farm's raw profile (`prepare-pr`, `create-ticket`, `tdd`, `quick-verify`, `babysit-pr`, `investigate`, and others), general primitives such as `orchestrate-sessions`, `verify-app`, `options`, and `brief`, and four Pane-specific skills, `runpane`, `pane-orchestration` (the orchestrator guide), `pane-work`, and `migrate-to-pane`. Pane generates the `pane-orchestrator` entry point at install time. Nothing is downloaded at runtime. The skills that come from Agent Farm were last refreshed from its greenfield plugin at `a903f09` (Agent Farm 0.2.33): to refresh them, three-way merge each skill from that commit to the new one (`git merge-file`), keeping Pane's adaptations, and record the new commit here.

Pane Chat and named Sessions support Claude, Codex, Cursor, OpenCode, and Pi. Choose the agent when creating a Session, and set the default in AI & Agents settings. OpenCode reads the generated Session `AGENTS.md`, and OpenCode tabs Pane starts get Pane's tools for that launch through `OPENCODE_CONFIG_CONTENT`; Pane doesn't edit OpenCode's own config or install OpenCode skills.

## Phone simulators

Any agent in a Pane can boot an iOS Simulator or Android emulator, see it, drive it, and build an app to it with the `device_*` tools (or `runpane devices`). The live screen opens in a tab beside the agent, and chat tabs show a live card. On Windows and Linux, iOS runs on a Mac you linked, with no SSH: Pane syncs the worktree there and builds it. Panes share a small pool of simulators that shut down when idle. See [Devices](docs/DEVICES.md).

Agents can also drive the browser tabs of their Pane with the `browser_*` tools (or `runpane browser`): open a page beside the chat, read it as an accessibility tree, click, type, take screenshots and run scripts, signed in as you. You see who is driving and take over by touching the page. See [Browser tools](docs/BROWSER_AGENTS.md).

---

## Agent-Operable CLI

Pane is not just a place where agents run. It exposes a stable `runpane` CLI contract that agents can use to manage the workspace for you.

For example, you can ask an agent to create panes for a set of GitHub issues and start Codex, Claude Code, Cursor, or any terminal command in each one. The agent can inspect the available Pane commands, register the current repository and set its Project Settings if needed, and create panes with initial instructions:

```bash
runpane agent-context
runpane repos list --json
runpane repos add --path /path/to/repo --yes --json
runpane repos update --repo active --build-script "pnpm install" --run-script "pnpm dev" --yes --json
runpane panes create --repo active --name issue-252 --agent codex --prompt "Kick off the discussion skill for issue 252" --yes
```

`runpane agent-context` is token-efficient by default and prints only command names, arguments, and safe usage notes. Agents can lazy-load full details for a specific command with `runpane agent-context --command "panes create" --json`.

Pane also registers a `pane` MCP server with Claude Code, Codex, and Cursor, so agents in every repository can get these commands as tools. Cursor may ask you to approve the server. The default core toolset covers the common jobs in one call each: start an agent on a task, check on it, and send it a follow-up. It also adopts and renames Panes, creates and pins Sessions, opens a page or file beside the agent, reaches your other machines (list them, read and write files, run commands), and has git status, docs search, `pane://` links that open a Pane in the app, loops that run an agent on a schedule, and `notify`, which asks you a question on screen wherever you are and gives the agent your answer. You can turn this off, or register every tool, in Settings → AI & Agents. Other MCP clients (VS Code and any stdio client) can run `npx --yes runpane@latest mcp`. See [Pane MCP Server](docs/PANE_MCP.md).

Pane teaches agents about RunPane without editing your repositories. It installs a small Pane-managed `pane` skill in your home skill folders (`~/.claude/skills/pane`, or under `CLAUDE_CONFIG_DIR`, and `~/.agents/skills/pane`), including saved WSL distros on Windows. The skill is marked `<!-- pane-managed-skill v2 -->`; Pane rewrites a copy an older Pane marked and leaves one a newer Pane marked. It tells agents how to reach Pane when its CLI or MCP tools look missing, including asking you through `runpane notify` when the `pane` MCP tools are not loaded. Pane never overwrites or removes a skill it did not write, and **Settings → AI & Agents → Install Pane skill for agents** removes it again.

Publishing a Pane section into each repository's `AGENTS.md` is still available under **Settings → AI & Agents → Publish Pane instructions to AGENTS.md**, but it is off by default because it edits files in your repositories. Upgrading turns it off once and removes only Pane's marked section; turning it back on afterward sticks.

See [Runpane CLI Contract](docs/RUNPANE_CLI_CONTRACT.md) for the full schema and automation examples.

---

## How It Works

![A saved repository opens into a Pane with a worktree and branch; terminal panels in that Pane share the worktree](docs/assets/pane-workspaces.png)

Two primitives: **panes** and **tabs**. One pane per feature, one worktree each. Inside every pane, everything lives in tabs — agents, diff viewer, file explorer, git tree, logs, multiple terminals. Create a pane, get an isolated workspace. Delete a pane, everything cleans up. Your agents never step on each other, and every tab persists across restarts.

Your agents already talk to Linear, Jira, GitHub, and Slack through MCPs and CLI tools. The terminal is the universal integration layer. Pane doesn't re-integrate what your agents already access — it gives them a place to run.

Pane also lets those agents operate the workspace itself. With the `runpane` CLI, an agent can list saved repositories, register a new repo, create panes, open terminal-backed agent tabs, and seed the first prompt. That means "set up panes for these issues and start the discussion skill" can be one instruction, not a manual UI checklist.

Other tools build custom chat UIs that only work with agents they've explicitly added support for. Pane gives every agent a real terminal. "Future CLI agent support" isn't a roadmap item here — it's the default. You bring the agents, Pane makes them fly.

---

## Keyboard Shortcuts

Pane's keys follow VS Code, and every one can be changed: press `⌘K ⌘S` (`Ctrl+K Ctrl+S`) for **Keyboard Shortcuts**, or pick **Change key…** in a command's Actions (`⌘K`) in Search. Two-step keys such as `⌘K ⌘S` are pressed one after the other; a small hint waits for the second key.

| Shortcut | Action |
|----------|--------|
| `⌘⇧P` / `Ctrl+Shift+P` | Open Search: find any Pane, Session, project or command, and see or change its key |
| `⌘/` / `Ctrl+K Ctrl+/` | Show every key in a searchable sheet, your own keys marked (a writable file editor keeps `⌘/` for comments, and browser pages keep it; `Ctrl+/` stays with terminal programs) |
| `⌘K ⌘S` / `Ctrl+K Ctrl+S` | Change keys (Settings → Shortcuts) |
| `⌘0` / `Ctrl+0` | Focus the sidebar; then `↑` `↓` (or `k` `j`) move (up into the top buttons), `←` `→` collapse or expand, `Enter` opens, `Space` opens and stays, `Esc` goes back |
| `Enter` | With a chat on screen and focus on no field or control, move into its message box |
| `⌘⌥←→↑↓` / `Ctrl+Alt+arrows` | Move focus to the split, panel, approval column or sidebar in that direction; the focused split's active tab carries the accent underline |
| `F6` / `⇧F6` | Next / previous region (sidebar, splits, approval column, right panel, terminal) |
| `⌘K ⌘M` / `Ctrl+K Ctrl+M` | Maximize the focused split, Session tile, sidebar or right panel; again to restore |
| `⌘⇧M` / `Ctrl+Shift+M` | Minimize the focused sidebar, right panel or terminal |
| `⌘B` / `Ctrl+B` | Toggle sidebar |
| `⌘⌥B` / `Ctrl+Alt+B` | Toggle right panel |
| `` ⌃` `` / `` Ctrl+` `` | Toggle terminal |
| `⌘⇧[` `⌘⇧]` / `Ctrl+PgUp` `Ctrl+PgDn` | Previous / next tab in the focused split, or in a Session's approval column while it has focus (`Esc` there goes back to the chat) |
| `⌃⇧Space` | Approvals from any app, and back to exactly where you were (also `Esc`); change it in Settings → Notify |
| `⌘⇧A` / `Ctrl+Shift+A` | Open or close Approvals while Pane is in front; in its list `↑` `↓` move, `Enter` or `→` open, `Esc` goes back, and the tab keys switch Waiting / Done today |
| `⌘⌥A` / `Ctrl+K Ctrl+A` | From a Session chat, open its approval; again (or `Esc`) goes back with your draft kept |
| `↑` `↓` `Space` `Tab` `⌘↩` | In an approval: move and pick within a question, pick the focused option, next question (then the reply box), send from anywhere in it |
| `⌘⌥O` / `Ctrl+Alt+O` | Machine switcher (then `0` for All machines, `1-9` for a machine) |
| `⌃⌘]` `⌃⌘[` / `Ctrl+Alt+Shift+]` `[` | Next / previous machine |
| `⌃⌘0` / `Ctrl+Alt+Shift+0` | All machines ⇄ the last machine |
| `⌘K` / `Ctrl+K` | Clear the focused terminal |
| `⌘F` / `Ctrl+F` | Find in the focused tab (terminal, browser, file preview, Logs, a chat's loaded conversation), an approval and its Summary, or the Approvals screen |
| `⌘G` / `Ctrl+G` | Find next |
| `⌘⇧G` / `Ctrl+Shift+G` | Find previous |
| `⌘N` / `Ctrl+N` | New pane |
| `⌘⇧W` / `Ctrl+Shift+W` | Archive pane |
| `⌘1-9` / `Ctrl+1-9` | Switch pane |
| `⌘,` / `Ctrl+,` | Open settings |
| `⌘⌥<key>` / `Ctrl+Alt+<key>` | Paste a clipboard shortcut into the active terminal |
| `⌘⌥` (hold) / `Ctrl+Alt` (hold) | Show all configured shortcuts as an overlay |

On macOS, Control+letter keys (`⌃A`, `⌃E`, `⌃K`, `⌃W`…) always reach the terminal. View → Actual Size is `⌘⇧0`, since `⌘0` focuses the sidebar.

---

## Installation

### Quick Install

Run the guided setup:

```bash
npx --yes runpane@latest
```

The wizard can install Pane on this machine, configure this machine as a remote
host, update Pane, or run diagnostics. For remote access, choose **Set up a remote
host**, accept or enter a name, and follow the Tailscale login
prompts. Copy the connection code into Pane on your other device or
[runpane.com/app](https://runpane.com/app/). Sign that device into the same
Tailscale network first. No tunnel flags are needed in the wizard.

### Package Manager Commands

Explicit desktop install:

```bash
npx --yes runpane@latest install client
pnpm dlx runpane@latest install client
pipx run runpane install client
```

The shell installers and the other one-shot commands are at the top of this README.

### Direct Download

> **[Download the Latest Release](https://github.com/greenfield-inc/Pane/releases/latest?utm_source=github)**

| Platform | File |
|----------|------|
| Windows (x64) | [`Pane-x.x.x-Windows-x64.exe`](https://runpane.com/api/download?version=latest&platform=windows&arch=x64&format=exe&source=gh-readme) |
| Windows (ARM64) | [`Pane-x.x.x-Windows-arm64.exe`](https://runpane.com/api/download?version=latest&platform=windows&arch=arm64&format=exe&source=gh-readme) |
| macOS (Apple Silicon) | [`Pane-x.x.x-macOS-arm64.dmg`](https://runpane.com/api/download?version=latest&platform=mac&arch=arm64&format=dmg&source=gh-readme) |
| macOS (Intel) | [`Pane-x.x.x-macOS-x64.dmg`](https://runpane.com/api/download?version=latest&platform=mac&arch=x64&format=dmg&source=gh-readme) |
| Linux (x64) | [`Pane-x.x.x-linux-x86_64.AppImage`](https://runpane.com/api/download?version=latest&platform=linux&arch=x64&format=appimage&source=gh-readme) or [`.deb`](https://runpane.com/api/download?version=latest&platform=linux&arch=x64&format=deb&source=gh-readme) |
| Linux (ARM64) | [`Pane-x.x.x-linux-arm64.AppImage`](https://runpane.com/api/download?version=latest&platform=linux&arch=arm64&format=appimage&source=gh-readme) or [`.deb`](https://runpane.com/api/download?version=latest&platform=linux&arch=arm64&format=deb&source=gh-readme) |

### Requirements

- **Git** installed and available in PATH
- At least one AI coding agent CLI installed and signed in:
  - [Claude Code](https://code.claude.com/docs/en/setup) — `curl -fsSL https://claude.ai/install.sh | bash` (on Windows, `npm install -g @anthropic-ai/claude-code`), then `claude auth login`
  - [Codex](https://github.com/openai/codex) — `curl -fsSL https://chatgpt.com/codex/install.sh | sh` (on Windows, `npm install -g @openai/codex`), then `codex login`
  - [Cursor Agent](https://cursor.com/docs/cli/installation) — `curl https://cursor.com/install -fsS | bash` (macOS/Linux, or inside WSL on Windows), then `cursor-agent login`
  - [OpenCode](https://opencode.ai/docs) — `curl -fsSL https://opencode.ai/install | bash` (on Windows, `npm install -g opencode-ai`), then `opencode auth login`
  - [Pi](https://pi.dev) — `npm install -g @earendil-works/pi-coding-agent` (0.76.0 or newer), then `/login` inside `pi`
  - [Aider](https://aider.chat/) — `pip install aider-chat`
  - [Goose](https://github.com/block/goose) — or any other CLI agent

---

## Usage

1. **Open Pane** and create or select a project (any git repository)
2. **Create a pane** — enter a prompt and pick your agent
3. **Add tabs** — launch a Claude, Codex, Cursor, OpenCode, or Pi terminal, diff viewer, file explorer, or any CLI tool
4. **Work in parallel** — create multiple panes for different approaches
5. **Review diffs** — see what changed with the built-in diff viewer
6. **Ship** — commit, rebase, and merge from keyboard shortcuts

OpenCode's native terminal integration starts a new conversation bare, saves the ID OpenCode prints when it exits (`opencode -s <id>`), and resumes that exact ID in project tabs, Pane Chat, and named Sessions. A conversation still running when Pane quits has no saved ID yet, so it starts fresh next time. OpenCode Sessions require supported direct commands, not wrappers or custom-resume templates.

The default `opencode --auto` auto-approves non-denied operations; it is not a sandbox. Closing, archiving, and switching retain existing lifecycle behavior, and PTY exit does not prove that agent work was cancelled.

Pi tabs open with a Pane-chosen `pi --session-id <id>`, so a restarted or reopened tab continues the same conversation. Pi runs tools without asking; in a folder with `.pi` settings or project skills it first asks whether to trust the folder. Pane shows that as blocked, never answers it, and types a starting message only once Pi's input box is on screen. Loops do not run Pi Sessions yet.

Moving to a new computer? **Settings → Import & Export** saves your commands, run scripts, agent defaults, shortcuts, skill and MCP choices and look to a file, and imports it after showing what would change. Keys and tokens stay behind. See [Export and import your Pane setup](docs/SETUP_EXPORT_IMPORT.md).

You can reuse an archived or deleted pane's name. Pane keeps any old worktree
identity and Git branches separate, choosing a free worktree name for the new
pane. Creation errors appear in a dismissible error dialog on desktop and Remote
Pane even if the creation dialog has already closed.

New native archive requests save cleanup intent alongside the archived state. Cleanup
resumes after a restart, keeps Git branches, and never imports historical
archives as deletion requests. The Archive Tasks area retains failure reasons
and offers **Retry cleanup**. Restore waits until cleanup finishes so it cannot
reuse a path that is still being deleted. An interrupted archive script is not
replayed; its retry button explicitly skips that script. Native worktrees are
moved to a private quarantine before files are removed in small batches. Busy
operations retry up to three times; cross-volume renames, locked worktrees,
and identity mismatches preserve the remaining files and show a failure.
Cleanup also waits for known terminal and run-command processes to exit.
If termination fails, the job retains their identities across restart and
**Retry cleanup** retries termination before removing files.
WSL worktrees retain the existing Git cleanup route without restart recovery.
Unsupported native paths fail before archiving. A CLI wait timeout does not
cancel a persisted job. Individual filesystem calls are awaited; batch budgets
bound work between yields, not the time an operating-system call can take.

Agents put scratch files in `$PANE_SCRATCH_DIR`, which archive deletes with the
Pane; on the main checkout, an adopted worktree or in a WSL project it is kept
14 days first.
Archived Session folders are also kept 14 days. Agent logs inside either are
moved to `<pane-dir>/agent-logs/` for Usage & Limits. See
[The scratch folder](docs/SESSIONS.md#the-scratch-folder).

Leaderboard submissions use the selected runtime's last 30 days of agent usage,
matching the Usage page's source. When connected to a remote backend, Pane submits that
backend's totals under the desktop app's existing leaderboard identity. If the
backend is unavailable, the submission fails rather than using desktop totals.

---

## The Windows Problem

The Windows developer experience for AI coding tools is broken across the board:

- **Claude Desktop on Windows** crashes repeatedly. Requires manual Hyper-V and Container feature enablement. Windows App Runtime dependencies aren't auto-installed.
- **Claude Code on Windows** is non-functional when your Windows username contains a period — standard in enterprise Active Directory environments.
- **Conductor** is Mac-only. No Windows version exists. The founder publicly said Windows support is "hopefully soon-ish."
- **Claude Squad** has a hard dependency on tmux, which doesn't exist on Windows.
- **Claude Code Agent Teams** requires tmux or iTerm2 for split panes. Explicitly not supported in VS Code terminal or Windows Terminal.

Windows has roughly 70% of the developer desktop market. Linux has another 5-10%. Mac has about 25%. The entire AI coding tool ecosystem is building for that 25%.

Pane is for the other 75%. And for Mac developers who want to choose their own agents.

---

## Who Pane Is For

- **Developers on any OS**: Mac, Windows, and Linux are all first-class citizens, with no "Mac-first with a Windows waitlist"
- **Multi-agent users** who run Claude Code, Codex, Cursor, Aider, or Goose depending on the task and want one app to manage them all
- **Keyboard-driven developers** who want Superhuman-level speed in their AI-assisted coding workflow
- **Teams** where different engineers use different agents and need a consistent workflow layer
- **Anyone tired of juggling terminal windows**, alt-tabbing between diff viewers and git clients, or waiting for agents one at a time

## What Pane Is Not

Pane is not your editor. Not your terminal. Not your agent.

It replaces the chaos. The twelve terminal windows. The alt-tabbing. The mental overhead of tracking which agent is on which branch. The frustration of tools that don't work on your OS.

Pane replaces the mess with a single, fast, keyboard-driven surface. It's the thing you wish tmux was.

---

## How Pane Is Different

| | Pane | Superset | Conductor | Claude Squad | Cursor/Windsurf |
|---|---|---|---|---|---|
| **Platform** | Win + Mac + Linux | Mac (unofficial Win/Linux) | Mac (Apple Silicon only) | Unix (tmux) | Win + Mac |
| **Agents** | Any CLI | Any CLI | Claude + Codex | Any (tmux) | Built-in only |
| **Diff Viewer** | Built-in, syntax-highlighted | Built-in | Built-in | None | Editor-level |
| **Git Workflow** | Commit, push, rebase, squash, merge — all keyboard | Worktrees + merge | Worktrees + PR | Worktrees only | Editor-level |
| **Keyboard-First** | Every action | Partial | Partial | Terminal only | IDE shortcuts |
| **Open Source** | Yes (AGPL-3.0) | Yes (Apache-2.0) | No | Yes | No |
| **Session Persistence** | Yes | Yes | Yes | No | N/A |

Every tool in the AI coding space either only works on Mac, only works with one agent, is a terminal hack that requires tmux, treats Windows as an afterthought, or wants to be your editor, your terminal, and your agent all at once.

Pane is the only tool that is a real desktop app, agent-agnostic, cross-platform with every OS as a first-class citizen, keyboard-first, and git-native. That combination doesn't exist anywhere else.

---

## FAQ

**"Isn't this just tmux with extra steps?"**
tmux is from 2007. Pane is a modern desktop app with a built-in diff viewer, file explorer, git workflow, Search launcher, browser tab, resource manager, persistent state, cross-terminal context sharing, and (unlike tmux) it works on Windows. tmux is a terminal multiplexer; Pane is a workstation for managing AI coding agents.

**"What if a new AI agent comes out tomorrow?"**
You just run it. Pane doesn't bundle agents or lock you in. If it runs in a terminal, it runs in Pane, instantly. No plugins, no SDK, no waiting for support.

**"Do I have to know how git worktrees work?"**
No. Pane creates and tears down worktrees automatically when you create or delete a pane, so you get all the isolation benefits without ever typing `git worktree`.

**"Can I run multiple agents in parallel without them stepping on each other?"**
Yes. Each pane gets its own worktree, its own port range, and its own copy of your secrets. Five agents, five isolated workspaces, zero conflicts.

**"Why is it called Pane?"**
Because you look through a pane to see what's happening. Each pane is a window into an agent's work.

**"Why Electron?"**
Pane uses xterm.js, the same terminal engine that powers VS Code's integrated terminal. Same rendering, same reliability. Electron also powers VS Code, Slack, Discord, and Figma.

---

## Building from Source

```bash
git clone https://github.com/greenfield-inc/Pane.git
cd Pane
pnpm run setup
PANE_DIR=~/.pane_test pnpm dev
```

You need patched Node 22.23.4+ (22.x), 24.22.1+ (24.x), or 26.12.1+ (26.x), and pnpm 10 (`corepack enable`). `PANE_DIR` keeps
the dev build away from an installed Pane's data in `~/.pane`. It doesn't
isolate Electron's browser profile; see
[Running a dev build safely](CONTRIBUTING.md#running-a-dev-build-safely).

### Production Builds

```bash
pnpm build:win:x64    # Windows (x64)
pnpm build:win:arm64  # Windows (ARM64)
pnpm build:mac        # macOS (Apple Silicon + Intel)
pnpm build:linux:x64  # Linux x64 (run on an x64 Linux host)
pnpm build:linux:arm64 # Linux ARM64 (run on an ARM64 Linux host)
```

### Releasing

Maintainers: see [RUNBOOK.md](RUNBOOK.md).

---

## License

[AGPL-3.0](LICENSE) — Free to use, modify, and distribute. If you deploy a modified version (including as a service), you must open source your changes.

---

<p align="center">
  <sub>Built by <a href="https://dcouple.ai">Dcouple Inc</a></sub>
</p>

설치

https://github.com/greenfield-inc/Pane에서 스킬을 설치해줘

이 스킬은 ClawHub 레지스트리에 게시되지 않았습니다. 프롬프트를 코딩 에이전트(Claude Code, Cursor, Codex)에 붙여넣으면 소스 저장소에서 바로 스킬을 설치합니다.

저장소 열기

링크