# Desktop agent environments compared: Orca, Conductor, Superset, Emdash, Warp and more

URL: https://developertoolkit.ai/en/ecosystem/agent-tools/agent-shells/
Description: Compare desktop apps that run Claude Code, Codex and Cursor's CLI in parallel worktrees: Orca, Conductor, Superset, Emdash, Warp. Licences, platforms, traps.

A desktop agent environment is a GUI app that runs your existing coding agent CLI (Claude Code, Codex, Cursor's CLI and others) in several isolated git worktrees at once, with a diff and review view on top. Orca, Conductor, Superset, Emdash and Warp lead the category in September 2026. Check your agent's built-in parallel features first.

You have three agents working on three issues in three terminals. One finished ten minutes ago, one waits on a question you have not seen, and reviewing the third means `git diff | less` in a directory you have to find first. A desktop agent environment puts all three on one screen with their diffs. Pick the wrong one, though, and you are migrating off it within a year: Crystal, Mux and Vibe Kanban all changed name or status in 2026.

This page is for **developers** choosing a GUI for parallel agents and **tech leads** standardising one for a team. Terminal multiplexers (herdr, tmux, cmux) and board or queue orchestrators (Claude Squad, Vibe Kanban) have their own pages; this one covers desktop apps only.

## What this comparison of desktop agent environments gives you

- A check of what Claude Code, Codex and Cursor already do natively, so you add an app only when it earns its place
- A dated table of ten desktop environments: licence, platforms, isolation, agents and status
- A full best-of-N example in Orca: one prompt to Claude Code and Codex, two diffs, one winner chosen by tests
- A team workflow from ticket to workspace to diff comments to pull request, with three copy-paste prompts
- The evidence each workspace must carry before merge, the install traps, and what breaks

## What counts as a desktop agent environment?

One test decides what belongs here: **the app runs the agent CLI you already use.** When Orca or Emdash starts Claude Code, it starts `claude` with your `CLAUDE.md`, hooks, skills and subscription. If the app disappears, you lose a window and keep everything else.

Three neighbours fail that test or solve a different problem:

| If you want | Go to |
| ----------- | ----- |
| Agents in terminal panes that survive SSH and a closed laptop | [herdr](/en/ecosystem/agent-tools/herdr-agent-multiplexer/) or [tmux for agent fleets](/en/ecosystem/agent-tools/tmux-for-agent-fleets/) |
| A queue or board that assigns many issues to agents (Claude Squad, Vibe Kanban, Worktrunk) | [Parallel agents](/en/ecosystem/agent-tools/parallel-agents/) |
| An IDE whose own agent replaces yours (Kiro, Devin Desktop, Antigravity) | [The coding-agent landscape](/en/comparison/agent-landscape/) |

Editors that speak the **Agent Client Protocol** (ACP) are a fourth option for one agent at a time. ACP "standardizes communication between code editors … and coding agents" (stable protocol version 1, per the ACP repository, read 2026-09-26; still `1` on 2026-10-12, when the repository also carried a `schema-v2.0.0-alpha.8` tag from 2026-10-09). Claude Code reaches ACP editors such as Zed through the `@agentclientprotocol/claude-agent-acp` adapter (npm 0.84.0, checked in late September 2026), built on the Claude Agent SDK. ACP gives you a good single-agent editor, not fan-out.

## What does your agent already do before you add an app?

In 2026 the agents absorbed the bottom of this stack. A third-party app now has to earn its place with mixed agents, a better review board, or remote and mobile access. Check the native path first.

**Claude Code**

    Claude Code 2.1.283 (checked with `claude --help` on 2026-09-26, and again on 2.1.296 on 2026-10-12) runs a session in its own worktree with `claude --worktree <name>` (`-w`), adds a tmux session with `--tmux`, and lists background sessions in agent view with `claude agents` (research preview). `claude --desktop` (v2.1.285, both release channels on 2026-10-12) opens the session in the Claude Desktop app instead of the terminal. The **Code** tab of the Claude desktop app runs parallel worktree sessions with line-level diff review. See [agent view](/en/claude-code/automate/agent-view/) and [Claude Code Desktop](/en/claude-code/build/desktop-app/).

**Codex**

    Codex CLI 0.157.1 (checked again on 0.162.1 on 2026-10-12) runs a session in a managed worktree with `codex --worktree` or `/worktree`, and `codex agents` browses every session on the local app-server daemon. The Codex desktop app (`codex app`) exists for macOS and Windows only. See [Codex worktrees](/en/codex/automate/worktrees/) and [the Codex app](/en/codex/build/app-mastery/).

**Cursor**

    Cursor's Agents Window runs several agents at once, each in a worktree or as a cloud agent: "a unified workspace to build with agents across repos and environments, including local, cloud, remote SSH, and more" (Cursor docs, checked 2026-10-12). If your whole team is on Cursor, start there; a third-party app adds value when you mix Cursor with Claude Code or Codex. See [the Agents Window](/en/cursor-ide/build/agents-window/).

If one vendor's agent covers your team and its app shows diffs well enough, stop here. Read on when you run two or more agents side by side, need Linux or Windows, or want tickets and diff comments in one place.

## Which desktop agent environments are worth a look in September 2026?

Popularity is GitHub stars read on 2026-09-26 through the GitHub API for this site's ecosystem research dossier. Stars measure attention, not fitness, and closed products publish no comparable metric.

| App | Licence | Platforms | Isolation | Agents it runs | Stars (2026-09-26) | Status |
| --- | ------- | --------- | --------- | -------------- | ------------------ | ------ |
| **Orca** | MIT | macOS, Windows, Linux; iOS and Android companion | Worktree per task, local or SSH | Any CLI agent: Claude Code, Codex, Cursor, OpenCode, Pi and more | 78,410 | Active |
| **Warp** | Client AGPL-3.0 (UI crates MIT) | macOS, Windows, Linux | None of its own; tabs and panes | Its own agent, or Claude Code, Codex, Gemini CLI | 65,162 | Active |
| **AionUi** | Apache-2.0 | macOS, Windows, Linux; WebUI | Per session | Claude Code, Codex, Cursor Agent, Gemini CLI and others, over ACP | 33,131 | Active |
| **opcode** | AGPL-3.0 | Build from source | None | Claude Code only | 22,405 | No release binaries |
| **Superset** | Elastic License 2.0 | macOS; Linux AppImage experimental; no Windows | Worktree per task, per-worktree ports | Claude Code, Codex, any CLI agent | 14,649 | Active |
| **Emdash** | Apache-2.0 | macOS, Windows, Linux (x64 and ARM64) | Worktree per task, local or SSH | Claude Code, Codex, Cursor, OpenCode, Amp, Copilot and others | 5,841 | Active |
| **Xum** (formerly Mux) | AGPL-3.0 | macOS, Linux | Local, worktree or SSH runtime | Its own agent loop over several model providers | 2,036 | Renamed |
| **Nimbalyst** (formerly Crystal) | MIT | macOS, Windows, Linux; iOS app | Optional worktree per session | Claude Code, Codex; OpenCode and Copilot in alpha | 1,777 | Active |
| **Sculptor** (Imbue) | MIT | macOS (Apple Silicon), Linux | Worktree by default; containers experimental | Claude Code, Pi; any terminal agent | 232 | Research preview |
| **Conductor** | Closed | macOS only | Worktree per workspace | Claude Code, Codex | none published | Active |

What each one is for, in a sentence:

- **Orca** is the default pick for a free, cross-platform app. Its README describes fanning "one prompt across five agents, each in its own isolated git worktree" to "compare the results and merge the winner", with diff annotation, GitHub and Linear tasks, SSH worktrees and an `orca` CLI.
- **Conductor** is the most-cited Mac app. It is closed source; check current pricing on conductor.build. Conductor now documents `.conductor/settings.toml` in place of the legacy `conductor.json`; the `conductor.json` in the Next.js repository remains a real-world example of a per-worktree setup script.
- **Superset** suits Mac teams that want agents to create workspaces themselves through its CLI, TypeScript SDK or MCP server. Its README warns that worktrees "do not sandbox processes or prevent merge conflicts".
- **Emdash** suits cross-platform teams that start work from tickets: it pulls issues from Linear, GitHub, Jira, GitLab and others into a worktree task.
- **Warp** is a terminal first. Choose it for agent-aware tabs and notifications without a worktree manager. Warp's product menu lists Warp Factories, Warp Terminal and Warp Agent CLI, and its pricing page lists Free, Build at $18 a month and Max at $180 a month (both billed annually, with $20 and $200 of agent usage) and Business at $45 per user a month (annual, up to 25 seats) (warp.dev, checked 2026-10-12).
- **Nimbalyst** suits teams whose agents produce specs, mockups and diagrams as well as code.
- **Sculptor** ships workflow skills such as `/sculptor-workflow:fix-bug`; treat it as a preview.
- **Xum** runs its own agent loop rather than your CLI, so it fails this page's test; choose it only if one app driving several model providers is the goal.
- **opcode** is a personal Claude Code GUI with no release binaries, not a team standard.
- **AionUi** gives one GUI, a WebUI and chat-app channels over many agents; check what the WebUI exposes before you open it beyond your LAN.

**Vibe Kanban is sunsetting**

Vibe Kanban's README opens with "Vibe Kanban is sunsetting." The company closed and local workspaces continue as a community project. Do not standardise a team on it now. If you depend on it, compare replacements on the [parallel agents](/en/ecosystem/agent-tools/parallel-agents/) page.

## Which desktop agent environment fits your constraint?

| Your constraint | Choose |
| --------------- | ------ |
| One vendor's agent for the whole team | That vendor's app: Claude Code Desktop, the Codex app or Cursor's Agents Window |
| Claude Code and Codex side by side, free, any OS | Orca |
| Work starts from Linear, Jira or GitHub issues; permissive licence required | Emdash |
| Mac-only team, polish over openness, closed source acceptable | Conductor |
| Agents must create their own workspaces through an API | Superset (check the Elastic License 2.0 with legal) |
| A GUI terminal, not a worktree manager | Warp |
| Linux-only desk, no GUI wanted | Not a desktop app: [herdr](/en/ecosystem/agent-tools/herdr-agent-multiplexer/) |
| Legal reviews every licence | MIT or Apache-2.0: Orca, Emdash, Nimbalyst, Sculptor, AionUi. AGPL-3.0: Warp client, Xum, opcode |

Do not choose from the table alone. Run two candidates on the same four real tasks with the [bake-off protocol in the agent landscape](/en/comparison/agent-landscape/#how-do-you-run-a-coding-agent-bake-off), with the same agents and prompts, and change only the app. Commit to a two-week trial, not a two-year standard.

## Run best-of-N in Orca: one prompt to Claude Code and Codex

Best-of-N sends the same task to two agents in two worktrees and keeps the better result. It pays off on tasks with more than one reasonable design, such as a tricky bug fix or an API shape. The winner is chosen by tests you wrote first, not by which diff looks nicer.

Install the agent CLIs Orca will drive, and sign in to each once in a terminal:

**Claude Code**

    ```bash
    curl -fsSL https://claude.ai/install.sh | bash
    claude auth login
    ```

**Codex**

    ```bash
    npm install -g @openai/codex
    codex login
    ```

**Cursor**

    Orca's README lists Cursor's CLI among its supported agents. Install Cursor's CLI with `curl https://cursor.com/install -fsS | bash` (macOS, Linux, WSL; Cursor CLI installation page, checked 2026-10-12), confirm it with `agent --version`, and sign in once.

Then install Orca (commands from Orca's README, read in late September 2026):

```bash
# macOS
brew install --cask stablyai/orca/orca

# Arch Linux (AUR)
yay -S stably-orca-bin
```

On Windows and other Linux systems, download the app from [onorca.dev/download](https://onorca.dev/download).

1. **Write the acceptance test first**, on `main`, in your own terminal. For example, a failing test for the bug. Commit it so both worktrees start from it.

2. **Create the task in Orca** and pick Claude Code and Codex for the same prompt. Orca creates one worktree per agent. The exact UI labels change often; the README's "Parallel Worktrees" section links the current docs.

3. **Paste the same prompt into both agents** (below). Identical prompts make the diffs comparable.

4. **Wait for both to report.** Orca's notifications show when an agent finishes or needs attention.

5. **Judge by evidence, not by reading.** Run the judge prompt (below) in a third, read-only session, or run the full test suite in each worktree yourself. Merge the winner's branch through a normal pull request and delete the other worktree.

**Copy-paste prompt: best-of-N task for both agents**

```text
Fix the bug covered by the failing test tests/billing/proration.test.ts.
Rules:
- Do not edit that test file or any other existing test.
- Keep the change inside src/billing/ unless the root cause is elsewhere;
  if it is, stop and explain before editing outside src/billing/.
- Run the type check, the linter and the full test suite in this worktree
  before you finish, and paste the exact commands and their final lines.
- End with a 5-line summary: root cause, the fix, files changed, tests run,
  anything you are unsure about.
Commit on this worktree's branch. Do not push.
```

**Copy-paste prompt: judge two best-of-N branches**

```text
Two agents solved the same task on branches <branch-a> and <branch-b>, both
started from main. Do not edit files. For each branch:
1. Check out its worktree and run the type check, linter and full test suite.
   Report pass/fail with the command and last lines of output.
2. Confirm no existing test was modified (git diff main -- tests/).
3. List files changed and flag changes to config, migrations, lockfiles or
   public API.
Then recommend one branch in 3 sentences, ranked by: all gates green, smaller
blast radius, fewer unexplained changes. If both fail a gate, say so and
recommend neither.
```

What you should see: two branches, a table of gate results, and one recommendation you can confirm by re-running a single command. When both branches pass, the smaller diff usually wins.

## Run a GUI review board for a team: ticket to pull request

A desktop environment helps a team most when every task follows the same path: **ticket → workspace → diff comments → pull request**. Emdash (ticket import) and Orca (GitHub and Linear tasks, diff annotation) both support this shape; Conductor and Superset support the workspace and review steps.

1. **Make the repository survive parallel checkouts.** Worktrees isolate files only. Before anyone starts, run the readiness audit prompt below and commit the setup script it produces. Wire that script into the app's per-worktree setup hook (in Conductor, that is the setup script in `.conductor/settings.toml`, which replaces the legacy `conductor.json`).

2. **Write the ticket as a task card.** Each ticket names the acceptance criteria, the files expected to change, and the command that proves it. An agent cannot meet criteria nobody wrote down.

3. **Open one workspace per ticket.** Import the ticket (Emdash) or open a worktree from the task (Orca). One ticket, one branch, one agent.

4. **Review in the app with diff comments.** Leave comments on diff lines and send them back to the agent, instead of fixing by hand. The agent's reply is another commit you can check.

5. **Open the pull request and let CI decide.** The same gates run on every branch. Review bots take the first pass; see [AI code review bots](/en/ecosystem/observability/ai-code-review-bots/).

6. **Clean up.** Delete merged worktrees from inside the app so its state and `git worktree list` agree.

**Copy-paste prompt: audit this repo for parallel worktrees**

```text
Audit this repo for whether 4 agents can work in parallel git worktrees
without interfering. Check: hardcoded ports in scripts and docker-compose;
.env files that a fresh worktree would lack; install cost per worktree
(node_modules, venv, target/); shared mutable state (one dev database,
local Redis, fixed Docker container or network names); git hooks or
absolute paths that assume one checkout.
Report blockers as a ranked list first. Then write scripts/worktree-setup.sh
that copies the needed env files from the main checkout, installs
dependencies, and exports a PORT offset derived from the worktree name.
Do not change any existing script's behaviour on the main checkout.
```

## How do you verify work from a desktop agent environment without reading every diff?

The app shows you diffs; it does not prove them. Require the same evidence from every workspace, whichever app produced it.

| Evidence | Produced by | Checked by |
| -------- | ----------- | ---------- |
| A test that fails without the change and passes with it | The agent, in its own worktree | A second model: `/code-review` in Claude Code, or `codex review --base main` in Codex |
| Type check, lint and full test suite run on this worktree's own port | The agent, pasted in its summary | CI on the pull request |
| No edits to existing tests, config, migrations or lockfiles unless the ticket asked | The agent's file list | Review agent, then a CODEOWNERS rule on sensitive paths |
| Green CI on the branch rebased onto the latest `main` | The merge queue | Required status check |

The developer who opened the workspace signs off each merge. The tech lead owns the rules: which app, the setup script, which paths always need a human, and the numbers to watch (pull requests merged, time in review, reverts within a week). A rising revert count means the tasks are too large or the criteria too thin, not that the app is wrong.

**Context cost.** A desktop app adds no tokens by itself, because it starts your CLI with your config. Apps that install hooks, skills or an MCP server (Emdash's lifecycle hooks, Sculptor's workflow skills, Superset's MCP server) do add to it. Run `/context` in Claude Code inside one workspace before and after you adopt the app.

## Install traps for desktop agent environments

**Traps checked on 2026-09-26**

- `npm i conductor` installs an unrelated JavaScript library. Conductor is a Mac app download.
- Sculptor no longer runs each agent in its own Docker container by default; its docs make a git worktree the default workspace.
- Mux (`coder/mux`) is now **Xum** (`coder/xum`, npm `@coder/xum`). Xum is not Manaflow's cmux, and neither is tmux.
- Crystal is deprecated (February 2026); its successor is Nimbalyst.
- Superset is Elastic License 2.0: source-available, not open source, and not resellable as a service.
- The Warp client is open source under AGPL-3.0; it is not closed source, and AGPL still needs legal review before you embed it.
- opcode publishes no release binaries; you build it with Rust and Bun.

## What breaks with desktop agent environments, and how to recover?

**Two dev servers fight over one port.** Worktrees share the host's ports, so the second agent's server moves to the next free port and tests run against the wrong one. Recovery: stop every server, give each worktree a fixed port from the setup script, and re-run the tests of every open branch.

**A fresh worktree is missing `.env` or dependencies.** The agent writes placeholder values or tests fail on configuration. Recovery: add the copy and install steps to the app's setup hook, then restart the agent in that workspace.

**The app says "working" while the agent waits on a prompt.** Status comes from hooks or screen patterns and misses new prompts. Recovery: open every workspace that has been quiet for several minutes; install the lifecycle hooks the app offers for your agent.

**Rate limits arrive together.** Every workspace runs on your plan; Anthropic's agent view docs say ten parallel sessions use quota "roughly ten times as fast" as one (read 2026-09-26). Most apps show this as an agent that stopped, not as a quota error. Recovery: check the agent's own usage view, cap the number of workspaces, and see [cost optimization](/en/workflows/context/cost-per-context/).

**The app's state and git disagree.** You deleted a worktree in the terminal and the app still lists it, or the reverse. Recovery: `git worktree list`, then `git worktree prune`; remove workspaces from inside the app from then on. Commit and push before you delete anything, because removing a worktree discards uncommitted work.

**The tool is archived or renamed.** This happened to Crystal, Mux and Vibe Kanban in 2026. Recovery is cheap if the app only wrapped your CLI and kept state in git branches: install the next app and open the same branches. Prefer apps that keep task state in git over apps that keep it in their own database, and record the licence of whatever you adopt in your [vendor risk register](/en/cto-scorecard-guide/vendor-risk-management/).

## Where to go next with desktop agent environments

- [Agent tools overview](/en/ecosystem/agent-tools/) — Shells, multiplexers, orchestrators, sandboxes and bots, and which kind you need
- [Parallel agents](/en/ecosystem/agent-tools/parallel-agents/) — Boards, queues, Worktrunk and the merge train for ten agents at once
- [Run parallel agents in isolated worktrees](/en/developer-scorecard-guide/git-worktrees/) — The isolation contract every desktop app relies on
- [The coding-agent landscape](/en/comparison/agent-landscape/) — Agent-first IDEs, and the bake-off protocol for choosing between tools
- [Driving agents from your phone](/en/ecosystem/agent-tools/remote-mobile/) — Remote Control, Happy, CloudCLI and Orca's mobile companion
- [Agent sandboxes](/en/ecosystem/agent-tools/sandboxes/) — When a worktree is not enough isolation: containers and microVMs
