Conductor

Platform · Last verified 2026-09-30

TL;DR

Conductor is a macOS app that runs Claude Code, Codex, Cursor and OpenCode sessions in separate Git-worktree workspaces, so several coding agents can work on one repository at once, each with its own branch, diff review and pull request. The Conductor team maintains it; a paid plan adds cloud workspaces. It suits developers who already use those agents.

Key facts

Conductor key facts. Data as of 2026-09-30.
Type	Platform
Languages / SDKs	Not applicable (hosted product)
License	Proprietary
Pricing model	Hosted, paid
Orchestration pattern	Other
Repository	No public repository (closed source)
Website	www.conductor.build
Documentation	www.conductor.build
Last verified	2026-09-30

Key features

Each workspace is a Git worktree with its own branch, files, terminal and review state, so parallel agents do not edit the same checkout. (source)
Claude Code, Codex, OpenCode and Cursor Agent run as selectable harnesses inside a workspace; each chat tab uses one harness and one model, and several chats can share a workspace. (source)
A decision guide says when to split work across workspaces (independent features, issue fan-out, throwaway experiments) and when to run several agents in one workspace (implement, review and test repair on one branch). (source)
Workspaces can be created from a branch, pull request, GitHub issue or Linear issue, then reviewed in a diff viewer where inline comments go back to the agent. (source)
Setup and run scripts prepare each workspace, and a per-workspace port variable lets several copies of an app run side by side. (source)
Cloud workspaces run agents in isolated Linux sandboxes that keep working after the Mac app is closed, and workspaces and chats are shared across an organization. (source)
A hosted MCP server at api.conductor.build lets ChatGPT, Claude, Codex and other MCP clients create cloud workspaces, delegate tasks and read results; an HTTP API covers the same operations. (source)

Architecture and orchestration pattern

Pattern: Other

Conductor is a workspace layer around existing coding agents, not an agent framework. The docs describe a harness as the runtime that writes code and Conductor as the surrounding layer. Claude Code, Codex and OpenCode are bundled in the app; Cursor sessions go through the Cursor API. The user is the coordinator: they decide how to split a problem, create one workspace per shippable unit, start an agent in each, and review and merge the results.

Parallelism comes from two mechanisms. Separate workspaces get separate Git worktrees, branches and pull requests, so streams of work stay independent. Several agents can also share one workspace when they should see the same branch and files, for example one implementing while another reviews. The docs warn that agents in one workspace can edit the same files. No automatic task routing or agent-to-agent messaging is described.

State lives in the workspace: branch, chats, diff, terminal, pull request status and a gitignored .context folder for handoffs. Local workspaces run on the Mac with the user's permissions and store data locally; cloud workspaces run in Vercel sandboxes, and chat messages are stored on Conductor's servers according to the pricing FAQ.

Human in the loop

A person drives every workspace. Plan Mode asks an agent to plan before editing, and some tool calls (shell commands, file changes, MCP tool use, web fetches) can ask for approval before they run. Checkpoints revert code and chat state to an earlier turn. The diff viewer supports manual review with inline comments that go back to the agent, and the Checks tab shows git status, CI, comments and todos before merge. Nothing merges without the user pressing merge in the PR flow.

Harnesses it can drive

Claude Code (evidence)
Codex (evidence)
OpenCode (evidence)

Protocols

MCP, A2A and AG-UI support for Conductor. See the full matrix.
Protocol	Support	Note
MCP	Yes evidence checked 2026-09-30	Both directions: agents in Conductor sessions load MCP servers configured in Claude Code and Codex (reference/mcp), and Conductor hosts its own Streamable HTTP MCP server (beta) at https://api.conductor.build/mcp for managing cloud workspaces.
A2A	Unknown checked 2026-09-30	No mention of A2A or Agent2Agent in the site's llms-full.txt, which contains the docs and site pages.
AG-UI	Unknown checked 2026-09-30	No mention of AG-UI in llms-full.txt; Conductor is a closed-source app with no public repository to search.

Best for

Developers on a Mac who want several Claude Code, Codex, Cursor or OpenCode tasks running side by side on one repository, each on its own branch. (shortlist)
Turning GitHub or Linear issues into one workspace and one pull request each, with diff review and checks in the same window. (shortlist)
Teams that want agent work to continue in the cloud and be visible to teammates (Pro, Teams and Enterprise plans).

Not for

Windows or Linux users: the install page says Conductor is available for macOS only for now.
Anyone who needs agents to coordinate with each other automatically; the docs describe person-driven workspaces, not an agent-to-agent protocol.
Work where workspace isolation must act as a security boundary; the docs say agents still run with the user's permissions.

Quickstart

Download Conductor for Mac from https://www.conductor.build/docs/installation, drag the app to Applications, then open it.

Install not yet verified by this site. What this means

# Conductor checks for these on first launch; run them yourself if setup stalls
gh auth status        # GitHub auth in your terminal environment
claude /login         # if you plan to use Claude Code
codex login           # if you plan to use Codex

# Then, in the app:
# 1. Open project / Open GitHub project / Quick start to add a repository
# 2. Create a workspace (Command + N for another one)
# 3. Start a chat with Claude Code, Codex, Cursor or OpenCode
# 4. Review the diff (Command + Shift + D), open a PR (Command + Shift + P)

Common pitfalls

macOS only; the install page offers a sign-up form for Windows and Linux.
GitHub authentication in your terminal and at least one agent provider are required.
Cursor sessions need a Cursor API key, added under Settings, Harnesses, Cursor.
Git allows a branch to be checked out in only one worktree, so a workspace branch belongs to one workspace at a time.
A new worktree contains tracked files only; use Files to copy or a setup script for .env files and dependencies.
Conductor does not resell model usage; harness usage is billed through your provider account or API key.
The Conductor API and hosted MCP server are in beta and their shapes may change.

Official quickstart

Pros

A free plan covers local parallel workspaces, and the docs say Conductor does not bill or resell model usage; you bring your own subscriptions or keys. (source)
Supports four harnesses (Claude Code, Codex, Cursor, OpenCode) in one interface, with Claude Code, Codex and OpenCode bundled in the app. (source)
Worktree isolation keeps each task's files, branch, running app and review path separate, with the pull request as the integration unit. (source)
Docs give explicit guidance on when to use one workspace versus many, including the trade-off of agents editing the same files. (source)
Exposes a hosted MCP server and HTTP API so other agents or bots can create and follow cloud workspaces. (source)

Cons

Closed-source and macOS only; Windows and Linux are not available yet. (source)
Workspace isolation is development isolation, not a security boundary: agents and commands run on the Mac with the user's permissions. (source)
Cloud workspaces need a Pro plan or above, and chat messages sent in cloud workspaces are stored on Conductor's servers, unlike local sessions. (source)
The pricing FAQ says usage-based pricing for cloud compute is planned; Team plans are invite-only and self-hosted cloud is not available yet. (source)
The Conductor API and hosted MCP server are labelled beta, and tools and input shapes may change. (source)

Alternatives

FAQ

Does Conductor support MCP?

Yes, in two ways. Claude Code and Codex sessions inside Conductor load the MCP servers configured for those agents, and Conductor runs a hosted Streamable HTTP MCP server (beta) so MCP clients can manage cloud workspaces.

Is Conductor free?

The pricing page lists a Free plan at $0 with local workspaces and parallel agents. Pro is $50 per month and adds cloud workspaces, multiplayer, the API and a mobile app; Teams is $60 per month per user; Enterprise is custom. Prices are as read on the page on 2026-09-30.

Which coding agents does Conductor run?

Claude Code, Codex, Cursor (through the Cursor API) and OpenCode. Conductor itself is not an agent; the docs call it the workspace layer around the agent runtime.

How is Conductor different from running git worktrees by hand?

Its docs say it automates the recurring steps: creating the branch and worktree, copying allowed local files, running setup and run scripts, showing the diff, tracking pull request state and archiving the workspace.

Sources

Unknown fields: A2A and AG-UI: searched the site's llms-full.txt (docs plus site pages) for A2A, Agent2Agent and AG-UI and found nothing; the product is closed-source so there is no repository to search. Orchestration pattern is 'other': coordination is by the person creating workspaces, not by an agent-level pattern the docs name. Product license terms were not read beyond the site's terms page link; license is recorded as proprietary per the closed-source rule.

Something wrong or out of date, or do you maintain Conductor and want this page removed? Report a correction or request removal.