---
title: "Move from Conductor Cloud to your own always-on VM"
description: "Conductor Cloud goes read-only on November 13 and shuts down on November 20. Move your parallel coding agents and worktrees to an always-on exe.dev VM."
url: https://exe.dev/deploy/migrate-conductor-cloud
category: "Migration"
updated: 2026-11-07
---

# Move from Conductor Cloud to your own always-on VM

Conductor Cloud closes Nov 20. Keep your agents running on a VM of your own.

- **Software:** Agents from Conductor Cloud (https://www.conductor.build)
- **Source:** https://github.com/pingdotgg/t3code
- **License:** Proprietary (Conductor); MIT (T3 Code); your code is yours
- **Time:** 20 minutes
- **Example VM name:** `my-agents` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/migrate-conductor-cloud/manifest.json

## What you get

- Claude Code and Codex connected to exe.dev's LLM integration, with no API key on the VM.
- T3 Code running as a background service on port 3773, back after a reboot.
- REPO cloned into `~/<name>` through the GitHub integration and added to T3 Code as a project.
- A `t3.json` in the clone that carries over the repository's Conductor setup script, if it has one, ready to import in T3 Code's Actions menu.
- A setup-check thread in T3 Code that answers `OK`.

Running on the VM:

- **T3 Code**: A web app for parallel agents, one Git worktree per thread, as a systemd user service, port 3773, data in `~/.t3/userdata; worktrees in ~/.t3/worktrees`
- **Claude Code and Codex**: Preinstalled; connected to exe.dev's LLM integration, so no API keys on the VM, data in `~/.claude, ~/.codex`
- **Your repositories**: Cloned through the GitHub integration, with the branches you pushed from Conductor, data in `~/<repo>`

How it is reached:

- https://my-agents.exe.xyz:3773/ (private): T3 Code in your browser or phone, after a one-time pairing link
- https://my-agents.exe.xyz:3000/ (private): A dev server an agent starts, on any port from 3000 to 9999
- ssh my-agents.exe.xyz (private): Your terminal, for pairing links, .env files and upkeep

## Deploy with Shelley

Open https://exe.dev/new?prompt=REPO%3D%3Cfill-this-in%3E%0A%0ASet%20up%20Agents%20from%20Conductor%20Cloud%20on%20this%20VM%20by%20following%20the%20exe.dev%20recipe%20at%20https%3A%2F%2Fexe.dev%2Fdeploy%2Fmigrate-conductor-cloud.md%20from%20top%20to%20bottom.%0A%0AThe%20values%20at%20the%20top%20of%20this%20message%20are%20mine%3A%0A-%20REPO%3A%20a%20GitHub%20repository%20you%20used%20in%20Conductor%20Cloud%2C%20as%20owner%2Fname%3B%20add%20the%20others%20the%20same%20way%20afterwards%0AAsk%20me%20for%20any%20that%20still%20say%20%3Cfill-this-in%3E%20before%20you%20need%20them.%0A%0AThe%20recipe%27s%20example%20VM%20name%20is%20my-agents.%20This%20VM%27s%20name%20is%20the%20output%20of%20%60hostname%60%3A%20use%20it%20wherever%20the%20recipe%20writes%20my-agents.%20Skip%20the%20step%20that%20creates%20the%20VM%3B%20you%20are%20on%20it.%0A%0AYou%20are%20done%20when%20all%20of%20these%20are%20true.%20Check%20each%20one%20yourself%3A%0A-%20Claude%20Code%20and%20Codex%20connected%20to%20exe.dev%27s%20LLM%20integration%2C%20with%20no%20API%20key%20on%20the%20VM.%0A-%20T3%20Code%20running%20as%20a%20background%20service%20on%20port%203773%2C%20back%20after%20a%20reboot.%0A-%20REPO%20cloned%20into%20%60~%2F%3Cname%3E%60%20through%20the%20GitHub%20integration%20and%20added%20to%20T3%20Code%20as%20a%20project.%0A-%20A%20%60t3.json%60%20in%20the%20clone%20that%20carries%20over%20the%20repository%27s%20Conductor%20setup%20script%2C%20if%20it%20has%20one%2C%20ready%20to%20import%20in%20T3%20Code%27s%20Actions%20menu.%0A-%20A%20setup-check%20thread%20in%20T3%20Code%20that%20answers%20%60OK%60.%0A%0ARead%20the%20whole%20recipe%2C%20including%20the%20closed%20details.%20Follow%20%22Set%20up%20by%0Ahand%22%20from%20%22Install%20T3%20Code%22%20to%20the%20end%2C%20as%20exedev%3B%20the%20walkthrough%0Aabove%20it%20is%20for%20the%20owner.%20If%20%60exeuntu%20configure%60%20reports%20an%20existing%0Auser%20config%2C%20leave%20it%20alone.%20Do%20not%20create%20a%20pairing%20link%3A%20they%20expire%0Ain%20five%20minutes%20and%20work%20once.%20Leave%20public%20sharing%20off.%0AREPO%20is%20a%20GitHub%20repository%3B%20turn%20a%20URL%20into%20owner%2Fname.%20Clone%20it%0Athrough%20the%20GitHub%20integration%20into%20~%2FNAME.%20If%20that%20fails%20with%20%22not%0Afound%22%20or%20a%20403%2C%20give%20the%20owner%20the%20integration%20command%20from%20%22Get%20your%0Acode%22%2C%20with%20this%20VM%27s%20name%2C%20and%20wait%20for%20them%3B%20install%20the%20rest%0Ameanwhile.%0ALook%20for%20a%20Conductor%20setup%20script%20in%20.conductor%2Fsettings.toml%20or%0Aconductor.json%20at%20the%20repository%20root.%20If%20there%20is%20one%2C%20write%20t3.json%0Aas%20%22Setup%20and%20run%20scripts%22%20says%2C%20translating%20CONDUCTOR_%20variables%3B%20do%0Anot%20commit%20it%20and%20never%20push.%20If%20the%20owner%27s%20setup%20script%20lives%20only%0Ain%20Conductor%27s%20Cloud%20Computer%20settings%2C%20say%20that%20they%20need%20to%20paste%20it.%0ADon%27t%20copy%20or%20invent%20.env%20files%3A%20the%20owner%20brings%20those.%0AFinish%20by%20giving%20the%20owner%20the%20%60ssh%20...%20t3%20pair%60%20command%20from%20%22Open%20T3%0ACode%22%20with%20this%20VM%27s%20name%2C%20the%20integration%20command%20for%20their%20other%0Arepositories%2C%20and%20the%20list%20in%20%22Before%20November%2013%22%20if%20it%20isn%27t%0ANovember%2013%20yet.%0A%0AFinish%20with%20the%20URLs%20I%20should%20open.%0A to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe.dev/deploy/migrate-conductor-cloud/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

[Conductor is joining Meta](https://www.conductor.build/announcement), and
Conductor Cloud, its hosted workspaces for Claude Code and Codex, is closing.
On **November 13, 2026** it goes read-only, and on **November 20** it shuts
down and Conductor begins deleting Cloud user data. The local Mac app keeps
getting models and critical fixes until early 2027, then winds down too.

The point of Conductor Cloud was that your agents kept working after you
closed the laptop. An exe.dev VM does that, and keeps doing it: it's always
on, its disk persists, it reaches your repositories through the
[GitHub integration](/docs/integrations-github) and your models through the
[LLM integration](/docs/integrations-llm), so no tokens or API keys live on
it. This page gets your work out of Conductor Cloud before the deadline,
then sets up [T3 Code](/deploy/t3code), an open-source workbench that runs
each agent thread in its own Git worktree, the way Conductor did.

## Before November 13

After November 13 you can still read and export, but agents can't run, so
do these while they still can. In Conductor, for every cloud workspace you
want to keep:

1. **Push the branch.** Each workspace is a Git branch. Ask its agent to
   commit everything, including new files, and push the branch to GitHub,
   or do it yourself in the workspace's terminal:
   `git add -A && git commit -m "WIP from Conductor" && git push -u origin HEAD`.
2. **Copy what Git doesn't push.** Files in `.gitignore`, such as `.env`,
   and notes in the workspace's `.context` folder stay behind. Copy any you
   need.
3. **Or transfer it to local.** Right-click the workspace and choose
   **Transfer to local** to move it and its chats to your Mac. Then push
   its branch from there, as above.
4. **Export your data.** In **Settings → Account → Export data**, download
   everything Conductor has for you. Keep the download.
5. **Write down your Cloud Computer settings.** The setup script for each
   repository and the install-software script are in Conductor's
   organization settings: copy their text. Conductor hides environment
   variable and secret values after you save them, so get those from where
   they came from (your password manager, or each service's dashboard).

> [!WARNING]
> Conductor deletes Cloud data from November 20. A branch on GitHub and
> your export are what survive; check that `git ls-remote origin` on your
> computer lists every branch you meant to keep.

Conductor's [Cloud FAQ](https://www.conductor.build/docs/cloud/faq) and
[changelog](https://www.conductor.build/changelog/0.93.0-conductor-is-joining-meta)
have the details, and humans@conductor.build answers questions.

## How the move works

| In Conductor Cloud | On your exe.dev VM |
|---|---|
| A sandbox per workspace, asleep after 20 idle minutes and stopped after 23 hours 50 minutes | One VM, always on, with every repository and worktree on a disk that persists |
| Workspaces from your GitHub repositories | Clones through the [GitHub integration](/docs/integrations-github), with no token on the VM |
| A workspace per branch, as a Git worktree | A T3 Code thread per branch, in its own Git worktree |
| The Cloud Computer's setup script | A T3 Code action that runs on every new worktree |
| Run scripts and forwarded ports | Actions, and any port from 3000 to 9999 at `https://my-agents.exe.xyz:PORT/`, private to you |
| Conductor's model access | Claude Code and Codex through the [LLM integration](/docs/integrations-llm), billed to your exe.dev account |
| The Mac app and the iOS app | T3 Code's web app, in your laptop's and your phone's browser |

Chats don't move: no tool here imports Conductor's history. Your code, your
branches and your setup do.

## Pick a workbench

T3 Code is the default here because it runs entirely on the VM, gives every
thread a worktree, runs setup scripts on new worktrees like Conductor, and
works from any browser, phone included. Several others work on an exe.dev VM
just as well, and each has its own page:

- [**T3 Code**](/deploy/t3code): open source, MIT. A web app served by the
  VM; Claude Code and Codex. Its authors list Conductor among its
  inspirations. Followed below.
- [**Orca**](/deploy/orca): open source, MIT. A desktop app on your Mac,
  Windows or Linux computer, with worktrees on the VM over SSH. It offers
  the `setup` script from a `conductor.json` as its own setup script, and
  shows worktrees made outside Orca. It doesn't read
  `.conductor/settings.toml`.
- [**Paradev**](/deploy/paradev), formerly Superset: a desktop app with the
  VM as a remote host over SSH. It imports existing Conductor worktrees, and
  has its own [guide for Conductor Cloud users](https://docs.paradev.com/migrate-from-conductor-cloud).
  Remote hosts need a paid Paradev plan.
- [**Paseo**](/deploy/paseo): open source. A daemon on the VM with desktop,
  web, iOS and Android apps, for Claude Code, Codex and OpenCode.
- [**Herdr**](/deploy/herdr): one window for all your agents, telling you
  which needs you; the VM joins its sidebar over SSH.

If you only want one agent running remotely and don't need parallel
worktrees, [Codex remote control](/deploy/codex-remote-control) steers Codex
on the VM from the ChatGPT app, and a
[Claude Code self-hosted runner](/deploy/claude-code-runner) runs
claude.ai/code sessions on it. Or skip the workbench:
[Claude Code](/deploy/claude-code) and [Codex](/deploy/codex) run on the VM
in a terminal.

The moving steps below, pushing branches, cloning through the GitHub
integration and carrying over `.env` files, are the same whichever you
pick.

## Get your code

Create the VM, or click Deploy above and skip to the next section. On your
computer:

```bash
ssh exe.dev new --name=my-agents
```

A new VM has 2 CPUs, 8 GB of memory and a 25 GB disk. Conductor Cloud gave
every workspace 8 CPUs and 16 GB; for several agents building at once, grow
the VM as far as your plan allows:

```bash
ssh exe.dev resize my-agents --cpu=8 --memory=16GB --disk=100GB
```

Give the VM each repository you used in Conductor. With your GitHub account
[linked to exe.dev](/integrations), on your computer:

```bash
ssh exe.dev integrations add github --name app --repository you/app --attach vm:my-agents
```

Then clone it on the VM. Every branch you pushed comes with it:

```bash
git clone https://github.int.exe.xyz/you/app.git ~/app
git -C ~/app branch -r
```

Copy the gitignored files you saved, such as `.env`, from your computer:

```bash
scp .env my-agents.exe.xyz:app/.env
```

Agents can push branches and, with `GH_HOST=github.int.exe.xyz`, open pull
requests with `gh`; pushes show up as the exe.dev GitHub App unless you add
the integration with `--act-as-user`. Add `--readonly` if agents should
only read.

## Setup and run scripts

In Conductor, a setup script ran in every new workspace, from
`.conductor/settings.toml`, a legacy `conductor.json`, or, in the cloud,
the Cloud Computer settings. T3 Code calls these **actions**; one marked to
run on worktree creation is the same thing. Put them in a `t3.json` at the
repository's root:

```json
{
  "$schema": "https://t3.codes/schema/t3.json",
  "defaultThreadEnvMode": "worktree",
  "scripts": [
    {
      "name": "Setup",
      "command": "npm install && cp \"$T3CODE_PROJECT_ROOT/.env\" .env",
      "icon": "configure",
      "runOnWorktreeCreate": true,
      "async": false
    },
    {
      "name": "Dev server",
      "command": "npm run dev -- --host 0.0.0.0 --port 3000",
      "icon": "play"
    }
  ]
}
```

`"async": false` makes the agent wait for setup to finish, and
`defaultThreadEnvMode` starts every new thread in a worktree. Translate
Conductor's variables as you go:

| Conductor | T3 Code |
|---|---|
| `CONDUCTOR_ROOT_PATH`, the main checkout | `T3CODE_PROJECT_ROOT` |
| `CONDUCTOR_WORKSPACE_PATH`, the workspace | `T3CODE_WORKTREE_PATH`, also the working directory |
| `CONDUCTOR_PORT` | none: pick a port from 3000 to 9999 |
| Files to copy, `.worktreeinclude` | a `cp` in the setup command |
| An archive script | none: run it as an action by hand |

If your setup script is a file in the repository that reads Conductor's
variables, call it with them set:
`"command": "CONDUCTOR_ROOT_PATH=\"$T3CODE_PROJECT_ROOT\" ./script/setup.sh"`.

T3 Code doesn't apply `t3.json` scripts by itself. Open the project's
**Actions** menu: they're listed under **From t3.json**, and one click on
each imports it. Commit `t3.json` to share it with your team, or leave it
uncommitted; the imported actions stay in T3 Code's settings either way.

A dev server on the VM is at `https://my-agents.exe.xyz:3000/` (or whichever
port it uses, from 3000 to 9999), private to you through exe.dev's
[HTTPS proxy](/docs/proxy). Have it listen on `0.0.0.0`, not `localhost`.

## Open T3 Code

On your computer, make a one-time pairing link, and open it within five
minutes:

```bash
ssh my-agents.exe.xyz 'echo "https://$(hostname).exe.xyz:3773/pair#token=$(~/.local/bin/t3 pair --label laptop | sed -n "s/^Token: //p")"'
```

exe.dev asks you to log in, then T3 Code pairs the browser. To pick up a
Conductor branch, start a new thread, choose **New worktree** under the
message box, and pick the branch, such as `origin/you/login-redirect`, from
the branch menu beside it. T3 Code makes a fresh worktree from that branch,
runs your setup action in it, and only then starts the agent.

T3 Code names the worktree's branch itself, starting with `t3/`. To keep
pushing to your Conductor branch, ask the agent to push with
`git push origin HEAD:you/login-redirect`, or open the pull request from the
new branch.

For your phone, other repositories, backups and updates, follow the
[T3 Code page](/deploy/t3code#add-your-phone): it's the same setup.

## Ask Shelley

Every exe.dev VM also has [Shelley](/docs/shelley/intro), exe.dev's own
coding agent, at `https://my-agents.shelley.exe.xyz/`. Ask it to translate a
Conductor setup script into `t3.json`, clone your other repositories, or
find out why a setup action fails.

## The nuts and bolts

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Set up by hand</summary>

### Create the VM

On your computer, create the VM and give it your first repository, as in
"Get your code", then connect:

```bash
ssh exe.dev new --name=my-agents
ssh exe.dev integrations add github --name app --repository you/app --attach vm:my-agents
ssh my-agents.exe.xyz
```

### Install T3 Code

On the VM, connect Claude Code and Codex to the LLM integration, install
T3 Code with its official installer, and run it as a service on port 3773:

```bash
exeuntu configure claude
exeuntu configure codex
curl -fsSL https://t3.codes/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"
mkdir -p ~/.t3
printf 'T3CODE_HOST=0.0.0.0\nT3CODE_PORT=3773\n' > ~/.t3/service.env
t3 service install
```

### Add your repository

Still on the VM, clone the repository and add it to T3 Code:

```bash
git clone https://github.int.exe.xyz/you/app.git ~/app
t3 project add ~/app
```

If the repository has a Conductor setup script, write `~/app/t3.json` as
"Setup and run scripts" says.

### Check it

The service status says `installed`, port 3773 is listening, and a one-line
task through T3 Code prints `OK`:

```bash
t3 service status
ss -ltn | grep 3773
cd ~/app && t3 thread start --provider claudeAgent --model haiku \
  --title "Setup check" --wait . "Reply with exactly: OK"
```

</details>

<details id="troubleshooting" class="dp-details">
<summary>Something not working?</summary>

**`git clone` says not found or 403.** The VM has no integration for that
repository yet, or it's attached to another VM. Run the `integrations add`
command from "Get your code" with this VM's name.

**A branch from Conductor isn't in the branch menu.** It wasn't pushed. If
the workspace still exists in Conductor, push it, then run `git fetch` in
the clone on the VM.

**The setup action didn't run in a new worktree.** Check that it's imported
(it shows above **From t3.json** in the Actions menu, not under it) and has
`runOnWorktreeCreate` set.

**`.env` is missing in worktrees.** Git doesn't copy ignored files into new
worktrees. Put the file in the main checkout (`~/app/.env`) and copy it in
the setup action, as above.

**T3 Code shows Pair with this environment.** The token got lost on the way
through exe.dev's login. Paste the 12 characters after `token=` into the
box, or make a fresh link. More on the [T3 Code page](/deploy/t3code#troubleshooting).

</details>

## Frequently asked questions

### When exactly does Conductor Cloud stop?

Conductor's [announcement](https://www.conductor.build/announcement) gives three dates. On November 4, 2026, sign-ups and downloads stopped. On November 13, Conductor Cloud goes read-only: you can read old chats and export data, but not send new messages, and active subscribers get a refund. On November 20, Cloud shuts down and Conductor begins deleting Conductor Cloud user data.

### Does the local Conductor app keep working?

For now. Conductor says the Mac app gets new models and critical bug fixes until early 2027 and then winds down, and that all Conductor user data is deleted when it shuts down. Transferring cloud workspaces to local buys you time, not a permanent home.

### Can I bring my Conductor chats over?

Not into T3 Code or the other tools on this page: none of them imports Conductor's chat history. Export your data from Conductor to keep a copy, and transfer workspaces to local if you want to keep reading them in Conductor until it winds down. The code is what moves: every workspace is a Git branch.

### Do I need a separate VM for every workspace?

No. Conductor Cloud gave each workspace its own sandbox; here one VM holds all your repositories, and each thread gets its own Git worktree on it. If you want harder walls, between clients or projects, create a VM for each. Your plan sets how many VMs, CPUs and how much memory you get, and `ssh exe.dev resize` grows a VM.

### Can I use my Claude or ChatGPT subscription instead of the LLM integration?

Yes. On the VM, undo what `exeuntu configure` set up and sign in with `claude auth login` or `codex login`, then restart T3 Code. The [T3 Code page](/deploy/t3code) has the exact steps.

### How much does it cost?

T3 Code is free and MIT-licensed. The VM is part of your exe.dev plan, and model usage through the [LLM integration](/docs/integrations-llm) is billed to your exe.dev account; exe.dev keeps a [list of models and prices](/llm-gateway-models).


## Related

- [Run T3 Code on a remote server](https://exe.dev/deploy/t3code.md): Your coding agents on an always-on VM, steered from your phone.
- [Run Orca's agents on a remote server](https://exe.dev/deploy/orca.md): A big, always-on box for Orca's parallel coding agents.
- [Run Paseo on a remote server](https://exe.dev/deploy/paseo.md): One app for your coding agents, on a VM you steer from your phone.
- [Run Paradev (formerly Superset) agents on a remote host](https://exe.dev/deploy/paradev.md): An always-on remote host for Paradev's parallel coding agents.
- [Run Herdr agents on a remote machine](https://exe.dev/deploy/herdr.md): An always-on SSH machine for Herdr, with agents ready and no API keys.
- [Run Claude Code on a remote server](https://exe.dev/deploy/claude-code.md): A computer for Claude. A breather for your laptop.