# Tools for running several Claude Code and Codex sessions at once, compared

There are now more than a dozen tools for running several AI agents in parallel, and they differ most in where they run, what they cost and what they add around the agent. On a Mac you have the widest choice. On Windows and Linux, the desktop apps that run natively are LlamaTree, Herdr, Orca, Paseo, T3 Code, Emdash and Nimbalyst, along with Anthropic's and OpenAI's own desktop apps.

We make LlamaTree, so read this knowing that. Every fact about another tool was checked against its own website, repository and licence on **21 November 2026**, and where its own pages don't say something, the table says so. This field changes weekly: if something here is out of date, [tell us](https://github.com/LlamachantTechnology/LlamaTree/issues) and we'll fix it.

## At a glance

These all run the command-line agents you already have, with your own sign-in and plan, and most keep parallel work apart with a Git worktree per task.

| Tool | What it is | Windows | macOS | Linux | Licence | Price |
|---|---|---|---|---|---|---|
| [LlamaTree](https://llamatree.dev/) | Desktop app | Yes | From source for now | Yes | Apache 2.0 | Free, no account |
| [Herdr](https://herdr.dev) | Terminal multiplexer, and a desktop and phone app | Yes | Yes | Yes | Apache 2.0 | Free |
| [Orca](https://orca.dev) | Desktop app, with a phone companion | Yes | Yes | Yes | MIT | Free |
| [Paseo](https://paseo.sh) | Desktop, phone, web and command-line clients for a local daemon | Yes | Yes | Yes | Apache 2.0 | Free, no forced login |
| [T3 Code](https://github.com/pingdotgg/t3code) | Desktop, web and phone apps | Yes | Yes | Yes | MIT | No paid tier listed |
| [Emdash Classic](https://github.com/generalaction/emdash) | Desktop app | Yes | Yes | Yes | Apache 2.0 | No price listed |
| [Nimbalyst](https://nimbalyst.com) (was Crystal) | Desktop app, with a phone companion | Yes | Yes | Yes | MIT | Free for individuals |
| [Paradev](https://paradev.com) (was Superset) | Desktop app | Not yet | Yes | Experimental | MIT | Free app; paid plans from $20 a user a month |
| [Conductor](https://www.conductor.build) | Desktop app | No | Yes | No | Not stated | Not listed |
| [cmux](https://cmux.com) | Terminal app | No | Yes | No | GPL 3.0 or later | Free app; paid cloud plans |
| [Claude Squad](https://github.com/smtg-ai/claude-squad) | Terminal app on top of tmux | Not in its instructions | Yes | Yes | AGPL 3.0 | Free |
| [Vibe Kanban](https://github.com/BloopAI/vibe-kanban) | Local web app, started with `npx` | Yes | Yes | Yes | Apache 2.0 | Free |

And the two that come from the agents' own makers, each of which runs only its maker's agent:

| Tool | Windows | macOS | Linux | Needs |
|---|---|---|---|---|
| [Claude Desktop](https://code.claude.com/docs/en/desktop) (the Code tab) | Yes | Yes | Beta, for Ubuntu and Debian | A paid Claude plan |
| [ChatGPT desktop app](https://learn.chatgpt.com/docs/app) (Codex) | Yes | Yes | Preview | A ChatGPT account; limits depend on the plan |

## Features compared

What each tool's own documentation, changelog and repository describe, read on 21 November 2026. A tick means its pages describe the feature. A half-filled circle means partly: something narrower, explained under the table. A cross means no. A plus in a dashed circle, in LlamaTree's column, means it isn't built in but a plugin could add it ([more below](#filling-llamatrees-gaps-with-a-plugin)). A dash means its pages don't describe it, which isn't the same as not having it: we didn't install and test every tool, and these projects move fast.

First, the tools that run natively on both Windows and Linux:

| | LlamaTree | Herdr | Orca | Paseo | T3 Code | Emdash Classic | Nimbalyst |
|---|---|---|---|---|---|---|---|
| **Seeing what's going on** | | | | | | | |
| Status on every session: working, needs your answer, finished unseen | Yes | Yes | Yes | Yes | Partly | Partly | Yes |
| Context meter on each session | Yes | – | Partly | Yes | Yes | – | Yes |
| Conversation view that jumps to each prompt | Yes | – | Yes | Yes | Partly | Partly | Yes |
| Several live sessions side by side | Yes | Yes | Yes | Yes | Partly | Partly | – |
| **Running the agent** | | | | | | | |
| The agent's own terminal interface, unchanged | Yes | Yes | Yes | Partly | – | Yes | Partly |
| Any command-line program as a session | Yes | Yes | Yes | Yes | Partly | Partly | Partly |
| Sessions keep running when the window closes | Yes | Yes | Yes | Yes | Partly | Partly | – |
| After a restart, each session reopens its own conversation | Yes | Partly | Partly | Partly | Partly | – | Partly |
| Sessions on your own servers over SSH, beside local ones | Yes | Yes | Yes | Partly | Yes | Yes | – |
| **Git** | | | | | | | |
| Stage files, commit and push inside the tool | Yes | Partly | Yes | Partly | Partly | Yes | Yes |
| Side-by-side diffs that refresh as the agent edits | Yes | Partly | Partly | Partly | Partly | Yes | Partly |
| A new worktree per task from the window | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
| One table of every worktree: session, changes, ahead and behind, pull request | Yes | Partly | Partly | Partly | – | – | – |
| Warns when two worktrees change the same file | Yes | – | – | – | – | – | – |
| **Agents working together** | | | | | | | |
| Sessions can message each other | Yes | Partly | Yes | Yes | Yes | – | Partly |
| An agent can start helper sessions | Yes | Yes | Yes | Yes | Yes | – | Yes |
| Asks you before a session messages or starts another | Yes | – | Partly | Partly | – | – | – |
| Agents can show you panels, lists or pages | Yes | Partly | Partly | Partly | Yes | – | Yes |
| **The app** | | | | | | | |
| Plugins and themes | Yes | Yes | Yes | Yes | Partly | Partly | Yes |
| No account, and no usage reporting unless you say yes | Yes | Partly | Partly | Yes | Partly | Partly | Partly |
| **What LlamaTree doesn't have** | | | | | | | |
| Phone app | No | Yes | Yes | Yes | Yes | – | Yes |
| Start agents from an issue tracker or chat | Plugin | – | Yes | Yes | Partly | Yes | Partly |
| Built-in browser | No | – | Yes | Yes | Yes | Yes | Yes |

What the half-filled circles stand for:

- **Herdr** is two products, a terminal multiplexer and a desktop app, and they differ. The app commits everything at once, with no staging of single files and no push, and shows inline diffs; the multiplexer has no Git panel. The multiplexer reopens each agent's conversation after a restart; the app starts fresh shells. Agents reach each other by prompting and reading one another's panes. The sidebar shows each worktree's ahead and behind counts. The app reports usage unless you turn that off.
- **Orca** shows context use and the prompt-by-prompt view in its chat screen, not for terminal sessions. Its diff viewer has a refresh button. After a restart you resume an agent yourself. Its sidebar shows pull requests and failing checks. Messaging between agents is an experimental setting that you turn on. Agents can draw charts and mock-ups in the chat. Usage reporting can be turned off.
- **Paseo** drives the agent through its own chat screen (you can also run an agent in a plain terminal). It commits and pushes; staging single files isn't described. For SSH it connects to a Paseo service you've already set up on the server. Resuming after a restart is a setting. Agents' tools for messaging and starting each other are off until you turn them on. Panels come from installed plugins.
- **T3 Code** drives agents through its own chat screen, with a terminal for other commands. A mark for finished-but-unseen threads isn't described. Sessions stop when the last window closes, unless you install it as a service. An interrupted turn has a Resume button. It commits and pushes; staging single files isn't described. It has custom themes; a plugin interface isn't described. It reports usage unless you turn that off.
- **Emdash Classic** keeps sessions running with tmux, which its docs say isn't used for local Windows sessions. Splits are within one task. The prompt-by-prompt view is in its chat screen. Themes are light and dark. It reports usage unless you turn that off.
- **Nimbalyst** drives Claude through its own chat screen, with Claude Code's own interface as an option you turn on. Sessions can queue messages for each other. Diffs are inline. It lists conversations to pick up again after a restart. It reports usage unless you turn that off.

Plugins could fill some of the other tools' dashes too: Herdr, Orca, Paseo and Nimbalyst have plugins too, and Herdr's gallery lists community add-ons for Git, issue trackers and more, which we haven't counted as built in.

### Filling LlamaTree's gaps with a plugin

A LlamaTree [plugin](https://llamatree.dev/docs/customize.html#plugins) is a web page of your own in a tab or the side panel, which can run in the background. With your permission it can see each session's status and what it's doing, and send messages to agent sessions; it can also reach websites. It can't type into a session, start one, or read your files. Going by that, for the three things LlamaTree doesn't have:

- **Starting agents from an issue tracker or chat: a plugin could do it.** It could list your issues from GitHub, Linear or Jira and hand one to a session as a message, and that session's agent can start a helper on a new branch for it, with your OK. Nobody has written this plugin yet. Today, without a plugin, an agent can already show your tasks in a panel through your tracker's own MCP server, with a button on each that fills in the prompt.
- **A phone app: not with a plugin.** A plugin lives inside the desktop window. One could, though, send a notification to your phone through a web service when a session needs your answer.
- **A built-in browser: not as things stand.** A plugin's tab shows only the plugin's own page.

And the Mac-first tools and the two makers' own apps, on the points where they differ most:

| | LlamaTree | Paradev | Conductor | cmux | Claude Desktop | ChatGPT app (Codex) |
|---|---|---|---|---|---|---|
| Runs on Windows | Yes | No | No | No | Yes | Yes |
| Different makers' agents together | Yes | Yes | Yes | Yes | No | – |
| The agent's own terminal interface, unchanged | Yes | Yes | Partly | Yes | – | – |
| Stage files, commit and push inside the tool | Yes | Yes | Partly | – | Partly | Yes |
| One table of every worktree: session, changes, ahead and behind, pull request | Yes | Yes | Partly | – | – | Partly |
| Warns when two worktrees change the same file | Yes | – | – | – | – | – |
| Context meter on each session | Yes | – | Yes | – | Yes | – |
| Sessions can message each other | Yes | Partly | Yes | Partly | Yes | Partly |
| Asks you before a session messages or starts another | Yes | – | – | – | Partly | – |
| Sessions on your own servers over SSH | Yes | Partly | – | Yes | Yes | Yes |
| Local sessions keep running when the window closes | Yes | Yes | No | Partly | – | – |

- **Paradev**'s remote machines go through its own relay, on a paid plan. Agents reach each other by reading and writing one another's terminals.
- **Conductor** runs agents in its own chat screen, with an experimental terminal mode. Its Git panel shows changes and creates the pull request. Its own docs say local sessions end when the app closes; its cloud ones carry on.
- **cmux** says it won't build in worktrees, by choice. Keeping local sessions alive is an option you turn on.
- **Claude Desktop** and the **ChatGPT app** each run their maker's agent in their own chat screen. Claude Desktop creates the pull request for you rather than offering staging and commit buttons, and has a setting for whether sessions accept each other's messages. The ChatGPT app's agents message each other within one conversation.

### What only LlamaTree documents

Across all fourteen tools, two things in the tables are described by LlamaTree alone:

- **A warning when two worktrees change the same file.** The Project view marks both rows and names the file, before the two agents' work collides in a merge.
- **Being asked before agents act on each other.** The first time one session wants to message another, or to start a helper, LlamaTree shows you what it's about to do and you allow it once or as a rule. Helpers are held to the folder you allowed, there's a limit on how many one agent can run, and one switch pauses all of it. Others that offer agent-to-agent work describe a setting that turns it on or off, not a question at the moment it happens.

The rest is a matter of combination. Plenty of tools here have a status mark, or a Git panel, or SSH sessions. What LlamaTree puts together is all of them around the agent's own unchanged terminal, for any command-line program, as a native app on Windows and Linux, with no account and nothing reported unless you say yes.

## Which to choose

**You're on Windows or Linux.** Among the tools that run natively on both:

- **LlamaTree** if you want to see at a glance which session needs you, review and commit each agent's changes in a full Git panel, and keep an eye on how full each conversation is. More on it [below](#what-llamatree-does-and-doesnt-do).
- **Herdr** if you'd rather stay in the terminal you already use: its multiplexer is one program with no window of its own, it marks every pane as working, blocked or idle, and it has phone and tablet apps.
- **Orca** if you want agents started from Slack, Linear or GitHub that come back with a pull request, a built-in browser, or a worktree on its own cloud machine.
- **Paseo** or **T3 Code** if you want to carry on from your phone: both have full phone apps and reach your machine remotely.
- **Emdash Classic** if your work starts in an issue tracker: it sends issues from Linear, GitHub, Jira, GitLab or Asana to an agent. Its makers say new development has moved to a cloud product, Emdash 2.0, and that Classic still gets fixes.
- **Nimbalyst** if you want to edit what agents produce visually (documents, mock-ups, diagrams) and track tasks beside them.

**You're on a Mac.** Everything in the first table runs on the Mac, though LlamaTree only when built from source, until its signed app ships. Conductor, cmux and Paradev were made for the Mac first: Conductor is a polished app with shared workspaces, cmux is a fast native terminal that lights up the pane whose agent needs you, and Paradev is an open-source app in Conductor's style.

**You use only Claude Code, or only Codex.** Their makers' own desktop apps are the simplest start, and each has things only it can do, such as sessions that carry on in the maker's cloud. Claude Code also has an agent view in the terminal (`claude agents`), in research preview, that lists your background sessions and which need you. Neither app runs the other's agent, so if you use both, you need one of the tools in the first table.

**You live in a terminal, over SSH.** Claude Squad (on macOS and Linux, with tmux) and Herdr both work without a desktop. So does plain tmux, which is free and everywhere on Unix, though it knows nothing about agents: it won't tell you which one is waiting or what each one changed. tmux lists no Windows version.

**You plan work on a board.** Vibe Kanban ties a kanban board to agent runs and supports the longest list of agents. The company behind it closed in April 2026; the project carries on as open source, maintained by its community, and still publishes releases.

## A different approach: Devin

[Devin](https://devin.ai), from Cognition, isn't a window around agents you already have. It's an agent of its own, which Cognition describes as an autonomous AI software engineer, and you hand it a whole task rather than sit with it.

- **Where it runs:** in Cognition's cloud, where each session gets a virtual machine with your repositories cloned into it, or on your own machine through its command-line agent and Devin Desktop (the new name for the Windsurf editor).
- **How you reach it:** a web app, Slack or Teams, a comment on a GitHub pull request, a Jira ticket, or its API.
- **In parallel:** it can split a large task among "managed Devins", each in its own virtual machine.
- **Price:** a free plan with a light quota, then Pro at $20 a month, Max at $200 a month, Teams at $80 a month, and Enterprise by arrangement. It needs an account, and it's proprietary.

Choose Devin if you want to delegate work and come back to a pull request, with nothing running on your computer: migrations, upgrades and backlogs of tickets are what its makers say it's for. Choose a tool from the tables above if you want to use the Claude Code or Codex plan you already pay for, keep your code on your own machines, and watch and steer each agent as it works. The two aren't exclusive.

## What LlamaTree does, and doesn't do

What it's built around:

- **Status you can see.** Every session has a dot that tells apart *working*, *needs your answer* (it's blocked on a permission or a question) and *finished while you weren't watching*. [How to tell when Claude Code is waiting for you](https://llamatree.dev/guides/know-when-claude-code-is-waiting.html)
- **Git for each session,** laid out like Visual Studio: stage, commit, undo, fetch, pull, push, branches, history and side-by-side diffs that refresh as the agent edits, plus a table of every worktree of a repository that warns when two change the same file.
- **A context meter** on every session, with one click to compact.
- **Agents that work together, with your permission:** sessions can message each other, an agent can start helper sessions of its own, and agents can show you panels beside the terminal.
- **Your servers:** sessions on a Linux server or another Windows PC over SSH, beside your local ones.
- **Any command-line program** runs in a session, and on Windows nothing needs WSL.
- **Nothing to sign up for.** No account, no paid tier, and signed installers.

What it doesn't have, where others on this page do:

- **No phone app.** Herdr, Orca, Paseo, T3 Code and Nimbalyst have one.
- **No signed Mac app yet.** On macOS it runs from source.
- **No starting agents from an issue tracker or chat.** Orca and Emdash do that. LlamaTree shows a branch's pull request, your agents can use your own MCP servers, and [a plugin could add it](#filling-llamatrees-gaps-with-a-plugin).
- **No cloud machines of its own.** It runs agents on your computer and on servers you already have. Orca, Conductor and Devin offer cloud machines.
- **No built-in browser.**

## Conductor and Meta

Conductor's own announcement says the company is joining Meta. The same page says development of Conductor continues and that the app keeps working as normal, apart from Conductor Cloud, which it says will shut down. Reports elsewhere that the app itself is closing aren't what its site says today.

Conductor runs on the Mac only. If you're looking for something like it on Windows or Linux, the first seven rows of the table are where to look.

## How this was checked

Each tool's own website, documentation, repository, licence file and download page, read on 21 November 2026. A tick under a platform means there's an installer or build for it to download. "Not stated", "not listed" and "no price listed" mean the tool's own pages don't say, not that the answer is no. Prices are as listed that day.

The feature tables come from each tool's documentation, changelog and repository, not from installing and testing each one, so a dash there means "not described", and a feature added last week may be missing. LlamaTree's column is from its own [docs](https://llamatree.dev/docs/) for version 1.4.0.

## Related

- [How to run several Claude Code sessions in parallel](https://llamatree.dev/guides/run-multiple-claude-code-sessions.html): the worktree-per-task approach all of these build on.
- [AI agents](https://llamatree.dev/docs/agents.html): the agents LlamaTree works with and what each gets.
