aq.dev / guides / migrate-from-conductor-to-aq

How to Move Your Conductor Workspaces to AQ

Conductor is not shutting down. On November 12, 2026, Conductor struck through the wind-down plan in its announcement, including the plan to shut down Conductor Cloud, and wrote "Plans have changed! We'll still be developing Conductor." Its FAQ answers "Will I have to stop using Conductor?" with "Nope! Conductor will keep working as normal." Co-founder Charlie Holtz said in a post on X the same day that development continues and regularly scheduled updates resume next week. You do not have to move. This guide is for people who want to run their Conductor work in AQ, or keep a copy of it outside Conductor.

AQ runs agent CLIs like Claude Code and Codex in isolated git worktrees on your own Mac or on a cloud machine your team controls or AQ manages, and the importer brings your Conductor workspaces over with one command pasted in Terminal on your Mac. Every workspace becomes an AQ work item on the same branch, its Claude Code and Codex chats continue where they left off, and your .conductor/settings.toml scripts run unchanged, with $CONDUCTOR_PORT and the other Conductor variables set. It works on the Free plan. Import your Conductor workspaces, or see Conductor alternatives if you are still comparing tools.

What Conductor said on November 12, 2026

These facts come from Conductor's announcement and its FAQ, checked on November 12, 2026:

  • Development continues. The announcement, which still says Conductor is joining Meta, strikes through its earlier wind-down paragraph and says "Plans have changed! We'll still be developing Conductor."
  • Conductor keeps working. The FAQ says "Nope! Conductor will keep working as normal."
  • Your data. The FAQ says "We have never sold or trained on Conductor user data, and we still won't."
  • Export stays available. Right-click a cloud workspace and choose Transfer to local, or download an archive from Settings → Account → Export data.

The announcement does not give new dates or new plans for Conductor Cloud. For anything about your account, Conductor's support address is [email protected].

Optional: keep a copy of your Conductor work

Before any move, or simply as a backup, these steps keep your work outside Conductor:

  1. Bring cloud workspaces to your Mac if you want them local. In Conductor, right-click a cloud workspace and choose Transfer to local. Conductor says this moves the workspace and its chats.
  2. Export everything. Go to Settings > Account > Export data and keep the archive somewhere outside Conductor.
  3. Commit what you want to keep. Conductor workspaces are git worktrees, usually under ~/conductor/workspaces/<repo>/<workspace> (Conductor docs). The importer below pushes branches for you (it asks first, and uses your own git login), but it never commits on your behalf, so commit the changes you want to carry. If you would rather push by hand, push each one:
    git -C ~/conductor/workspaces/<repo>/<workspace> push -u origin HEAD
    To push all of a repository's worktrees at once, run this from the repository's main checkout:
    git worktree list --porcelain | awk '/^worktree /{print $2}' | while read -r wt; do
      git -C "$wt" push -u origin HEAD || echo "not pushed: $wt"
    done
    A worktree with a detached HEAD or uncommitted changes needs a branch and a commit first, so read the "not pushed" lines.
  4. Save your gitignored files. Files such as .env and .env.local are not in git, so pushing does not carry them. Copy the ones you need somewhere safe; you will import them into AQ as secrets.
  5. Copy your script settings. Keep a copy of .conductor/settings.toml (or the older conductor.json) and any .conductor/settings.local.toml on your machine. If the shared file is committed, it is already in the repository.

Uncommitted changes and gitignored files do not move to AQ. Everything else below starts from what is committed in your workspaces.

How to move your Conductor workspaces to AQ: one command

  1. Sign in and connect your accounts. Sign in at aq.dev; on the Free plan download the AQ Mac app and sign in with the same Google account, so agents run on your own Mac. Connect GitHub when AQ asks, and in Settings, Connections sign in to Claude Code, Codex, Cursor or the other CLIs you used in Conductor. Each person uses their own accounts, and AQ does not mark up usage on them.
  2. Open aq.dev/import/conductor and copy the command. Sign in (new to AQ? the same link signs you up) and the importer opens. It creates an API key for the import and shows one command with it filled in. Click Copy command.
  3. Paste it in Terminal on the Mac where Conductor runs. It needs Node 18 or later. The importer lists every workspace it found, on disk and in Conductor's own list (when the conductor command is signed in on that Mac, archived and Cloud workspaces included), asks once whether to push the branches that are not on GitHub yet (with your own git login), creates the work items and waits until AQ has checked each branch out. If a repository is not connected to AQ yet, the importer connects it from your GitHub. The dialog in AQ shows each workspace arriving, with a link to open it.
  4. Apply your scripts. Each repository's .conductor/settings.toml (or conductor.json) appears in Repository settings as Use your Conductor scripts: the setup command and one service per run action, with the default action first. An admin applies it with one click; on the Free plan that is you. The mapping table below says what each line becomes.
  5. Work. Open a work item: its Claude Code and Codex tabs show the conversation from Conductor and continue it on the next message. Type a task into the composer, or open a terminal tab and run the CLI yourself. The preview button starts your first service, and the Changes panel shows the diff, takes line comments and opens the pull request.

To see what would move before anything happens, run the same command with --dry-run and no key:

curl -fsSL https://aq.dev/import/aq-import.mjs -o aq-import.mjs && node aq-import.mjs conductor --dry-run

It prints every folder it looked in and, for each workspace, the path, remote, branch, what is not pushed, the script files and the chats it found, plus Conductor's id, number, state and dates and each Conductor session with its message count. Nothing is uploaded or pushed. If it finds nothing, it says where it looked and how to point it at another folder with --root; send us that output and we will help.

What the importer brings: every workspace as a private work item of yours on the same repository and branch; the Claude Code and Codex conversations that ran in that workspace, placed where the CLI resumes them on your AQ machine; the Conductor script files as a proposal. Conductor's own history too: when the conductor command is signed in on the Mac (or CONDUCTOR_API_KEY is set), the importer reads every workspace you created in Conductor, archived ones included, with all of its sessions and messages. Each Conductor workspace becomes one work item: Conductor's name, number and dates go in its description, its sessions become its conversations in their original order, and a workspace archived in Conductor is archived in AQ. A workspace with a checkout on your Mac is the same work item as above (its sessions are added to it, never a second item); one with no checkout here, such as an archived or Cloud workspace, keeps its conversations as readable history and gets a fresh branch when you start working in it. Running the importer again adds new sessions and messages to the same work items, without duplicates. It ends with a line such as "Imported 95 Conductor workspaces (77 archived), 340 conversations." What it leaves behind: uncommitted changes (it names the workspaces that have them), branches you decline to push, and gitignored files such as .env (import those into Secrets, below). There is no limit on how many workspaces or conversations you bring, or how large they are. Secrets pasted into old chats are replaced before anything is stored.

If you prefer to move a workspace by hand: push its branch, connect the repository from the repository menu, start a new work item, and set Base branch in the details menu to that branch. AQ creates the work item's own branch and worktree from its latest commit.

Conductor concepts and their AQ equivalents

ConductorAQNotes
WorkspaceWork itemEach work item has its own git worktree and branch.
scripts.setupWorktree setup command (repository settings)Runs once in each new worktree, from its root, after AQ installs dependencies and before the agent starts. AQ proposes it from your file; you can usually drop the install step.
scripts.run and named actions scripts.run.<id>Services (repository settings)One service per action, the default = true action first (it is the Preview button's target). Each service gets its own preview address. Hidden actions are skipped.
options.cwdThe service's directoryRelative to the repository root.
CONDUCTOR_PORT (through +9)The same variableEach work item owns ten consecutive ports for its whole life, as in Conductor, so --port $CONDUCTOR_PORT and $((CONDUCTOR_PORT + 1)) work unchanged. A server on the base port is the preview; the others open as extra preview tabs.
CONDUCTOR_WORKSPACE_PATHThe same variableThe work item's worktree. Setup, agents, terminals and services also start there.
CONDUCTOR_ROOT_PATHThe same variableThe repository's main checkout on your AQ machine. Gitignored files from your Mac are not there, so copy a .env through Secrets instead (next row).
CONDUCTOR_WORKSPACE_NAMEThe same variableThe work item's branch name, with slashes turned into dashes.
CONDUCTOR_WORKSPACE_ID, CONDUCTOR_SESSION_ID, the sender of a messageAQ_WORKSPACE_ID, AQ_SESSION_ID, AQ_RUN_ID, AQ_REQUESTED_BY_*AQ's own names, never Conductor's: code that attributes work to a workspace, thread or person reads them, and verifies them with a signed token AQ issues per turn. See execution identity.
.env copied into each workspaceSecretsSettings, Secrets, Add secret, Import a .env file. Personal or organization secrets reach terminals, previews, services and agents as environment variables and are kept out of transcripts.
scripts.archiveNo equivalentAQ has no command that runs when a work item ends.
run_modeNo setting neededEvery work item runs its services on its own ports and addresses.
Workspace started from a Linear issueLinear intakeConnect your Linear account in Settings, Connections, Integrations, then label an issue ai-task: AQ creates a work item and moves the issue to In Progress.
Conductor chatsClaude Code and Codex tabs on the work itemThe importer brings the CLI conversations of each workspace; the next message continues them. With the conductor command signed in, every Conductor session comes too, archived workspaces included, as readable history on the same work item. Every Claude Code and Codex chat comes over, whatever its size.

Converting .conductor/settings.toml: a worked example

Here is a typical Conductor file for a web app and an API, in the format Conductor's scripts reference describes:

[scripts]
setup = "pnpm install && cp \"$CONDUCTOR_ROOT_PATH/.env\" .env"
archive = "./script/workspace-archive.sh"
run_mode = "concurrent"

[scripts.run.web]
command = "pnpm dev --port $CONDUCTOR_PORT"

[scripts.run.api]
command = "pnpm start --port $((CONDUCTOR_PORT + 1))"
options = { cwd = "services/api" }

And here is the same setup in AQ:

Conductor lineWhere it goes in AQValue
pnpm installWorktree setup commandProposed as written. AQ already installs dependencies in each new worktree, so you can delete it and keep only steps beyond the install, such as pnpm db:migrate.
cp "$CONDUCTOR_ROOT_PATH/.env" .envSettings, SecretsDelete this part and import the saved .env with Import a .env file. Your code reads the same variable names from the environment.
scripts.run.webServices, row 1Service web, command pnpm dev --port $CONDUCTOR_PORT, unchanged. It is the Preview button's target.
scripts.run.apiServices, row 2Service api, command pnpm start --port $((CONDUCTOR_PORT + 1)), directory services/api, unchanged. It opens as its own preview tab.
archive, run_modeShown, not runAQ has no step that runs when a work item ends. Run cleanup by hand when you finish one.

You do not type any of this in: the repository's settings show Use your Conductor scripts with every command visible, and one click by an admin saves them. If your app reads .env from disk with a library such as dotenv, it still works: values already in the environment take effect without the file.

Test status: we checked each mapping against AQ's current settings on November 5, 2026, including the Conductor variables and the ten-port block. The importer was run end to end on a test machine with the layout Conductor's documentation describes and real Claude Code and Codex conversations, which resumed in AQ. Reading Conductor's own history was tested on November 10, 2026 against a stand-in conductor command that answers in the shapes of Conductor's published API; we did not have a signed-in Conductor install to test against, which is why --dry-run exists. Import one workspace and press Preview before you move a whole team.

What you keep after the move

  • Agents keep running when you close your laptop. Sessions live on a machine, not on your computer, and you can open them again from any device, including a phone.
  • Any operating system. AQ runs in a browser, so the same workflow works on macOS, Windows and Linux.
  • Your own subscriptions. Claude Code, Codex, Cursor and the other agent CLIs run signed in with each person's own accounts, and AQ does not mark up that usage.
  • Teammates in the same work item. On the AQ Pro plan, a teammate opens the same live terminal, editor and preview, steers the agent once the owner approves a control request, and reviews the diff before merge.
  • Machines you choose. Free runs one person's agents on your own Mac with the AQ Mac app. Pro adds a dedicated always-on machine AQ manages, or VMs connected from your own cloud account. Plan details are on the pricing page.

What AQ does not do

  • No import of uncommitted work or gitignored files. The importer carries committed branches, Claude Code and Codex conversations and Conductor's own sessions (as readable history, tool calls left out). Your Conductor export stays the record of everything else.
  • A different Mac app. AQ has its own Mac app (beta) beside the web app, and neither reproduces Conductor's native macOS interface.
  • No archive script. Conductor's archive step has no AQ counterpart.
  • No gitignored files in CONDUCTOR_ROOT_PATH. The variable is set, but files that were only on your Mac, such as .env, are not in the AQ checkout. Use Secrets for them.

Frequently asked questions

Is Conductor shutting down?

No. On November 12, 2026 Conductor struck through the wind-down plan in its announcement and wrote "Plans have changed! We'll still be developing Conductor." Its FAQ says Conductor will keep working as normal. Moving to AQ is optional.

Is Conductor Cloud shutting down?

The plan to shut down Conductor Cloud was part of the paragraph Conductor struck through on November 12, 2026, and the announcement gives no Cloud dates now. Check with Conductor for Cloud's current status. To keep a copy of a Cloud workspace, right-click it and choose Transfer to local, or export your data.

How do I export my Conductor data?

In Conductor, go to Settings → Account → Export data to download an archive of all your data. To keep working in a cloud workspace, right-click it and choose Transfer to local, which moves the workspace and its chats to your Mac. Then commit and push the branches you want, since unpushed commits live only in the workspace. These steps are optional backups, not a deadline.

What happens to my Conductor data?

Conductor's FAQ, checked November 12, 2026, says it will keep working as normal and that Conductor has never sold or trained on user data and still won't. For a copy you control, export from Settings → Account → Export data and push your branches to your Git host.

Can I import my Conductor workspaces and chats into AQ?

Yes. Open aq.dev/import/conductor and sign in; it gives you one command to paste in Terminal on your Mac. Each workspace becomes a work item on the same branch (the importer offers to push branches not on GitHub yet), its Claude Code and Codex chats continue on the next message, and your Conductor scripts are proposed in the repository's settings. With the conductor command signed in, it also brings every Conductor workspace you created, archived and Cloud ones included, one work item each with its sessions. Uncommitted changes and gitignored files such as .env stay behind; there is no limit on how many workspaces or chats you import, or their size. To bring the code of a Cloud workspace, push its branch first.

Is there a free alternative to Conductor?

Yes. AQ's Free plan runs one person's agents on your own Mac with the AQ Mac app, with the agent CLIs, editor and previews, and the Conductor importer works on it. You sign in to Claude Code, Codex and other CLIs with your own subscriptions, and AQ does not mark that usage up. Teammates, sharing and your own cloud are on the Pro plan; see pricing.

Is there a Conductor alternative for Windows and Linux?

Yes. Conductor's desktop app is Mac-only. AQ runs in a browser, so it works the same on Windows, Linux and macOS, with agents running on a cloud machine rather than your desktop. Our Windows and Linux guide covers the other options.

Do my Conductor setup scripts work in AQ?

Yes, mostly unchanged. AQ reads .conductor/settings.toml (or conductor.json) and proposes the setup command and one service per run action in the repository's settings, and it sets CONDUCTOR_PORT (with ten ports per work item), CONDUCTOR_WORKSPACE_PATH, CONDUCTOR_ROOT_PATH and CONDUCTOR_WORKSPACE_NAME, so the commands run as written. Import your .env into Secrets instead of copying it from the root path. AQ does not run the archive script.

Can I keep using Conductor locally while I move?

Yes. Conductor says it will keep working and keep being developed. You can run it and AQ side by side, as long as both work from the same git remote.