Move from Conductor Cloud to your own always-on VM

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 and changelog have the details, and humans@conductor.build answers questions.

How the move works#

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: open source, MIT. A web app served by the VM; Claude Code and Codex. Its authors list Conductor among its inspirations. Followed below.
• 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, 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. Remote hosts need a paid Paradev plan.
• Paseo: open source. A daemon on the VM with desktop, web, iOS and Android apps, for Claude Code, Codex and OpenCode.
• OpenChamber: open source, MIT. A web and phone workspace for OpenCode, served by the VM, with worktrees and multi-run.
• 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 steers Codex on the VM from the ChatGPT app, and a Claude Code self-hosted runner runs claude.ai/code sessions on it. Or skip the workbench: Claude Code and 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:

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:

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, on your computer:

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:

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:

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:

{
  "$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:

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. 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:

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: it's the same setup.

Ask Shelley#

Every exe.dev VM also has Shelley, 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#

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

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

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

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