# Conductor alternatives after the Meta acquisition

> Conductor alternatives compared: Orca, Paradev, Paseo, T3 Code, Emdash, boxes.dev, Grok Bot and the agent apps from Anthropic, OpenAI and Cursor, with prices and how to move your workspaces.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-11-05 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/conductor-alternatives/

Meta bought [Conductor](https://conductor.build/) on November 4, 2026, and the team is joining Meta Superintelligence Labs. New sign-ups and downloads stopped the same day. **Conductor Cloud goes read-only on November 13 and shuts down on November 20**, when Conductor starts deleting cloud data. The local Mac app keeps getting new models and critical fixes until early 2027, then winds down.

So if you use Conductor Cloud, you have about two weeks. If you use the local app, you have a few months, but no reason to wait.

My short answer:

- For a local Conductor replacement, try **Orca**. It's free, open source, runs Claude Code, Codex and other CLI agents in worktrees, and has a guide for opening your existing Conductor workspaces in place.
- If you want the closest thing to Conductor Cloud, with your own Claude or Codex subscription and teammates watching the same sessions, look at **boxes.dev**, or **Paradev** on its Team plan.
- If you want your agents on a machine you control and reachable from your phone, use **Paseo** or **T3 Code**.

I've used T3 Code, Herdr and cmux for my own agents, and I tried Conductor on a playground repository. The other tools I describe from their docs and sites.

![The Conductor announcement timeline: no new sign-ups on November 4, Cloud read-only on November 13, Cloud shut down on November 20, local app updates until early 2027](https://flaviocopes.com/images/conductor-alternatives/conductor-timeline.webp)

## What people are asking for

The day after the announcement, my timeline filled up with people looking for a replacement.

Manuel Castro's team [has 9 days left](https://x.com/manny4c/status/2118051955646030027) on Conductor Cloud. He listed three requirements: it uses their Codex and Claude subscriptions, it runs in the cloud with a local bridge, and it supports team multiplayer, so they can hand off and query each other's threads. Jared Rhizor [asked for alternatives that are cloud-first](https://x.com/jaredrhizor/status/2118067487975911791).

And Josh Pigford [was 4 alternatives in](https://x.com/Shpigford/status/2118096646856704454) and found every one of them broken in some way. That's a good reason to try two or three on a real repository now, before your deadline, instead of switching on November 19.

Those three posts cover the questions to ask about each tool:

- Does it run the agent CLIs you already pay for, or does it bill you for tokens?
- Where do the agents run: your Mac, a server you own, or someone else's cloud?
- Can a teammate see and continue your threads?

## What happens to your Conductor workspaces

A local Conductor workspace is a plain Git worktree. That's good news, because every tool below can open it.

I tried Conductor in June on a repository called `conductor-playground`. Conductor keeps the main checkout in `~/conductor/repos` and creates each workspace in `~/conductor/workspaces`, named after a city:

```bash
cd ~/conductor/repos/conductor-playground
git worktree list
```

```text
/Users/flaviocopes/conductor/repos/conductor-playground                 f376b26 [main]
/Users/flaviocopes/conductor/workspaces/conductor-playground/brasilia   f376b26 [flaviocopes/brasilia]
/Users/flaviocopes/conductor/workspaces/conductor-playground/edinburgh  f376b26 [flaviocopes/website-backend-saas]
```

The branches are normal Git branches, so your code is safe as long as you don't archive the workspace in Conductor. **Archiving deletes the folder.** Quit Conductor instead, and archive the worktree later from the new tool.

To find the checkout a workspace belongs to, run this from inside the workspace:

```bash
cd ~/conductor/workspaces/conductor-playground/brasilia
git rev-parse --path-format=absolute --git-common-dir
```

```text
/Users/flaviocopes/conductor/repos/conductor-playground/.git
```

That's the folder you add as a project in Orca, Paradev or any other tool, so it sees the existing worktrees instead of cloning the repository again.

The chats are a different story. Conductor stores them in a SQLite database at `~/Library/Application Support/com.conductor.app/conductor.db`, in tables like `workspaces`, `sessions` and `session_messages`. My playground has 15 sessions in there. No alternative imports that database. Orca's docs say Conductor's export can't be imported, and the same is true for the others.

What you can resume is the agent session itself. Conductor runs the real Claude Code and Codex, so `claude --resume` inside the worktree lists the Claude Code conversations for that folder. Claude Code deletes sessions older than 30 days by default.

## Before November 13, if you use Conductor Cloud

Cloud workspaces can't be imported anywhere. You have to bring them back to your Mac or push them to your Git host.

1. Push every branch. Gitignored files like `.env` aren't pushed, so copy them separately.
2. Right-click each cloud workspace and choose **Transfer to local**. This moves the workspace and its chats to your Mac.
3. Download everything from **Settings → Account → Export data**.

Do this before November 13. After that date the workspaces are read-only, and Conductor hasn't said whether the transfer still works.

## Is Orca a good Conductor alternative?

Yes, it's the closest match to the local app. [Orca](https://onorca.dev/) is a free, MIT-licensed desktop app that runs Claude Code, Codex, Cursor, Gemini, Copilot, OpenCode, Amp and other CLI agents side by side, each in its own Git worktree. You get terminals, diffs, a browser and a CLI in one window. It runs on macOS (Apple Silicon and Intel), Windows and Linux, with companion apps for iOS and Android.

![The Orca website: run Claude Code, Codex, and any other coding agent in parallel, each in its own worktree](https://flaviocopes.com/images/conductor-alternatives/orca.webp)

Orca has a [Migrate from Conductor](https://www.onorca.dev/docs/migrate-from-conductor) guide. You add the checkout Conductor used, then open the project menu, choose **Show hidden worktrees**, and show each Conductor workspace. Orca opens them in place and doesn't rerun your setup script.

Conductor's `conductor.json` scripts move to an `orca.yaml` file at the root of the repository, which the whole team can share. The environment variables change name:

| Conductor | Orca |
| --- | --- |
| `setup` script | `scripts.setup` in `orca.yaml` |
| `archive` script | `scripts.archive` in `orca.yaml` |
| Run button | Quick Commands |
| `CONDUCTOR_ROOT_PATH` | still set by Orca |
| `CONDUCTOR_WORKSPACE_PATH` | `ORCA_WORKTREE_PATH` |
| `CONDUCTOR_WORKSPACE_NAME` | `ORCA_WORKSPACE_NAME` |
| `CONDUCTOR_PORT` | none, Orca doesn't assign ports |

For a Conductor-style chat view instead of terminals, set **Settings → Agents → Open agents as → Chat**.

Orca has no hosted cloud. For remote work it uses SSH worktrees: agents run on a server you own, with file editing, Git, terminals and port forwarding.

## Paradev (formerly Superset)

[Paradev](https://paradev.com/) is the new name of Superset, which raised an $11.5M seed round. The `superset` command still works. Like Conductor, every agent gets its own worktree and branch, and it works with Claude Code, Codex, OpenCode, Gemini, Cursor Agent and any other CLI agent. Its site says it's MIT licensed, and it doesn't proxy model calls, so you use your own subscriptions and keys.

![The Paradev website: the open-source workspace for Claude Code, Codex, and any coding agent](https://flaviocopes.com/images/conductor-alternatives/paradev.webp)

On November 5 Paradev merged an onboarding step that [imports worktrees left by other tools](https://github.com/ParadevAI/Paradev/pull/9362). It scans `~/conductor/workspaces` and the default folders of T3 Code, Orca, Emdash, Herdr, Paseo, Cursor and Claude Squad, and converts `conductor.json` to its own config. Check that the version you download includes it.

Paradev is the option to look at if you paid for Conductor Cloud. Cloud workspaces are in beta on the Team plan, at $60 per user per month ($54 billed yearly) with 150 hours per seat. The Pro plan, $20 per user per month, adds the iPhone and iPad app. The free plan covers one user. You can also add your own machines as hosts, so workspaces keep running while your laptop sleeps.

The catch is the platform: the desktop app is for macOS, the Linux build is experimental, and there's no Windows version.

## Paseo

[Paseo](https://paseo.sh/) is free and open source (Apache 2.0), with no account required. A daemon runs your agents on whatever machine you choose: your laptop, a VM, a Docker container. Then you connect from the desktop app, the web app, the terminal, or the native iOS and Android apps.

![The Paseo website: run many coding agents at once, on any machine, from your desk and from your phone](https://flaviocopes.com/images/conductor-alternatives/paseo.webp)

This is the "cloud with a local bridge" shape done with your own server. Clients reach the daemon over an optional end-to-end encrypted relay, your local network, or a tunnel like Tailscale or Cloudflare Tunnel.

Paseo uses the Claude Code, Codex, OpenCode or other agents you already have installed, with your own credentials, so your subscriptions keep working. Worktrees are optional, and it also works in folders that aren't Git repositories.

## T3 Code

[T3 Code](https://flaviocopes.com/t3-code/) is the one I've used the most from this list. It's an MIT-licensed control surface for the agent CLIs you already pay for: Codex, Claude Code, Cursor, Grok, OpenCode and more. A local server starts them and turns their output into threads you follow from a desktop app, a web app or the phone apps.

Each thread runs in the current checkout or in a new Git worktree. You approve commands, review the diff of each turn and open pull requests from the same window. I wrote about the [review workflow I use for T3 Code threads](https://flaviocopes.com/t3-code-after-alpha/).

It runs on macOS, Windows and Linux. Like Paseo, it runs on your machine, and you reach it remotely through T3 Connect, Tailscale or SSH, so a laptop that's asleep can't work for you. Put it on a machine that stays on.

## Emdash

[Emdash](https://emdash.com/) is a free, open source app from General Action (YC W26) for macOS, Windows and Linux. It runs 25+ coding agents, including Claude Code, Codex, Cursor and Amp, each in its own worktree, with a built-in browser for previewing the app.

What sets it apart is the issue trackers. It pulls tasks from Linear, Jira, GitHub, Notion and Asana, and it can schedule recurring work. For remote work it connects over SSH to a dev server, a cloud VM or a GPU box, and setup and teardown scripts prepare the environment for each task.

## boxes.dev

[boxes.dev](https://boxes.dev/) is cloud-first, the answer to Jared's question. Every agent gets its own Linux machine, a devbox with 4 vCPUs, 8 GB of RAM and 100 GB of disk in the standard size. You bring your Codex or Claude Code subscription, and boxes.dev doesn't resell tokens.

![The boxes.dev website: give every agent its own cloud computer and bring your Codex or Claude subscription](https://flaviocopes.com/images/conductor-alternatives/boxes.webp)

Its setup flow uses your local coding agent to recreate your environment in the cloud, including environment variables and dependencies it finds on your machine. Then you steer the agents from the Mac app, the iOS and Android apps, the web, a CLI, Slack or Linear. Teammates can watch live shared sessions and open the devbox preview URLs, which is the closest thing to the multiplayer Manuel asked for. Idle boxes sleep and don't count against your hours.

It only supports Claude Code and Codex. The trial is free with 20 compute hours. Starter is $19 per user per month for 50 hours, Pro is $99 for 300 hours, and Max is $249 for 750 hours. Teams get custom pricing with SSO, audit logs and your own cloud or VPC.

## What about Claude Code, Codex and Cursor?

If you only use one agent, the app from its maker might be enough now. All three cover parallel work in worktrees, and all three have a cloud option.

- The **Claude desktop app** runs Claude Code sessions locally or in Anthropic's cloud, and Remote Control reaches a session on your Mac from your phone.
- The **Codex app**, inside the ChatGPT desktop app, creates managed worktrees, can hand a chat between a worktree and your checkout, and sends tasks to [Codex Cloud](https://flaviocopes.com/codex-cloud/). I cover the worktree settings in my [Codex guide](https://flaviocopes.com/codex/).
- **Cursor** has the Agents Window and Cloud Agents. The Agents Window is how I mainly use Cursor, and my [Cursor guide](https://flaviocopes.com/cursor/) covers it.

You give up the reason many people picked Conductor: running Claude Code and Codex side by side, in one window.

## Is Grok Bot a Conductor alternative?

Partly, if what you liked was Conductor Cloud. [Grok Bot](https://flaviocopes.com/grok-bot/) gives you a persistent cloud computer that keeps working after you close the app or your laptop. It has desktop apps for macOS, Windows and Linux, and iPhone, iPad and Android apps.

It isn't a coding agent manager, though. For code, the Bot gathers context, turns it into a task and hands it to a Cursor Cloud Agent, which writes the change. I explain when I give a job to which one in [Grok Bot vs Cursor Projects](https://flaviocopes.com/grok-bot-vs-cursor-projects/).

For teams, Shared Bots are in public beta on Teams and Enterprise plans. You share a Bot like a doc, as Collaborator or Manager, and teammates chat with the same Bot. That's close to the handoff Manuel asked for, but you share a Bot, not a coding thread.

The limits are what matter here:

- **One computer for all your Bots.** Every Bot you own runs on the same cloud computer, with no isolation between them. The [FAQ](https://docs.x.ai/grok-bot/faq) says not to use separate Bots as a security boundary, and the computer wasn't designed as a coding environment.
- **No Claude Code or Codex.** It doesn't run the agents you pay Anthropic or OpenAI for, so your Claude and ChatGPT subscriptions don't help. The coding happens in Cursor.
- **A weekly usage pool.** Grok Bot comes with the Premium, Super and Ultra tiers of The X Subscription, and with paid Cursor plans. Plus and Free don't include it. It draws from the same weekly pool as Cursor and the Grok apps, and once that runs out you pay for extra usage from prepaid credit. Several people hit the limit quickly after launch.
- **Scheduled runs cost usage.** A routine that runs every 15 minutes runs 96 times a day, and each run counts against the pool even when it finds nothing.
- **It's a beta.** Plans and access rules have changed several times since the August launch.

## Herdr and cmux, if you prefer terminals

Conductor wraps agents in a chat interface. If you'd rather see the real terminal of each agent, use [Herdr](https://flaviocopes.com/herdr/), a terminal workspace manager that shows which agent is working, blocked or done, and keeps everything running on a server you detach from. On a Mac, [cmux](https://flaviocopes.com/cmux/) is a native terminal app with a sidebar of workspaces, notifications and a browser pane. I compared them, and a few more, in [Herdr alternatives](https://flaviocopes.com/herdr-alternatives/).

## How do the Conductor alternatives compare?

Here's everything side by side:

| Tool | Desktop | Agents | Where agents run | Phone | Team features | Price | License |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Conductor | macOS | Claude Code, Codex, Cursor, OpenCode | Mac, Cloud until Nov 20 | Pro plan | Pro plan | Closed to new users | Proprietary |
| Orca | macOS, Windows, Linux | 27, plus any CLI agent | Mac, SSH servers | iOS, Android | Shared `orca.yaml` | Free | MIT |
| Paradev | macOS, Linux (experimental) | Any CLI agent | Mac, your hosts, cloud (beta) | iPhone, iPad (Pro) | Team plan | Free, $20, $60, $200 per user | MIT |
| Paseo | macOS, Windows, Linux, web | 7 built in, 33 more via ACP | Any machine running its daemon | iOS, Android | Not listed | Free | Apache 2.0 |
| T3 Code | macOS, Windows, Linux, web | Codex, Claude Code, Cursor, Grok, OpenCode and more | Machine running its server | iOS, Android | Not listed | Free | MIT |
| Emdash | macOS, Windows, Linux | 25+ | Mac, SSH servers | Not listed | Not listed | Free | Open source |
| boxes.dev | macOS, web, CLI | Claude Code, Codex | Its cloud devboxes | iOS, Android | Shared live sessions | Free trial, then $19 to $249 per user | Proprietary |
| Claude desktop | macOS, Windows | Claude Code | Mac, Anthropic cloud | Claude app | Claude plans | Your Claude plan | Proprietary |
| Codex app | macOS, Windows, Linux | Codex | Mac, Codex Cloud | ChatGPT app | ChatGPT plans | Your ChatGPT plan | Proprietary |
| Cursor | macOS, Windows, Linux | Cursor | Mac, Cloud Agents | iOS app, web | Cursor plans | Your Cursor plan | Proprietary |
| Grok Bot | macOS, Windows, Linux | Grok, code handed to Cursor Cloud Agents | One cloud computer per user | iOS, Android | Shared Bots (beta) | X Subscription Premium and up, weekly pool | Proprietary |

Here's how I'd narrow it down:

```mermaid
flowchart TD
  accTitle: Choosing a Conductor alternative
  accDescr: The first question is whether agents must keep running with the laptop closed. Hosted cloud points to boxes.dev or Paradev Team, your own server points to Paseo or T3 Code, and local work points to Orca, Emdash or Paradev, or to a vendor app if you use one agent.
  A{Agents must run with the laptop closed?} -->|Yes| B{Hosted or your own server?}
  B -->|Hosted| C[boxes.dev or Paradev Team]
  B -->|Own server| D[Paseo or T3 Code]
  A -->|No| E{More than one agent CLI?}
  E -->|Yes| F[Orca, Emdash or Paradev]
  E -->|No| G[Claude, Codex or Cursor app]
```

## Which one should you pick?

If you used the local Conductor app with Claude Code and Codex, install Orca, point it at your `~/conductor/repos` checkouts, and show the hidden worktrees. Your branches come along, and the free price matches what Conductor cost you. Keep Conductor installed until you've moved every workspace, since it works until early 2027.

If you used Conductor Cloud, transfer your workspaces to local before November 13. Then pick between a hosted service (boxes.dev, or Paradev's Team plan with cloud workspaces still in beta) and a server of your own running Paseo or T3 Code. The hosted options are faster to set up. The server costs you an afternoon, and nobody can shut it down on you with two weeks' notice.

Whatever you pick, test it on the repository you work on every day, with your setup script, before the deadline.
