# MAO vs Conductor: which should you use to run coding agents in parallel?

Conductor is a Mac app that runs Claude Code, Codex, Cursor and OpenCode as chat sessions, each task in its own Git worktree, with a free plan. MAO is a canvas for macOS, Windows and Linux where agents run as real terminals you wire together. Choose by platform, and by whether agents should hand work to each other.

Conductor is a Mac app that runs Claude Code, Codex, Cursor and OpenCode in parallel as chat sessions, gives each task its own Git worktree and branch, and takes the work through diff review to a pull request. MAO is a desktop canvas for macOS, Windows and Linux where each agent runs as a real terminal node, and agents you wire together can hand tasks to each other and drive a browser or a phone. Choose Conductor if you work on a Mac and want a free, chat-based path from task to pull request; choose MAO if you need Windows or Linux, terminal agents beyond those four, or agents that pass work along a wire.

## What is Conductor?

**Conductor is a macOS app for running several coding agents at once, each in an isolated workspace that maps to one Git branch.**

Its documentation describes it as the workspace layer around an agent runtime it calls a harness. It runs four harnesses: Claude Code, Codex and OpenCode come bundled with the app, and Cursor sessions use Cursor Agent through the Cursor API. Each chat tab uses one harness and one model, and Conductor bills no model usage: it uses the logins and API keys already on your Mac.

Each workspace is a separate checkout that Conductor creates with Git worktrees, named after a city. Chats in one workspace share its branch; separate workspaces get separate branches and pull requests. Setup scripts, a **Files to copy** list for gitignored files such as `.env.local`, and a `$CONDUCTOR_PORT` variable let each workspace run its own copy of the app. When the work is ready, Conductor's diff viewer, checks and pull request tools take it to a merge, and the workspace is archived.

Conductor Cloud (Pro plan and up) runs workspaces in isolated Linux sandboxes that keep working after your Mac closes and are shared with your organization. Conductor's own docs say local workspace isolation "is development isolation, not a security boundary": agents run on your Mac with your user permissions, without sandboxing.

## How do MAO and Conductor differ?

**Both give parallel agents their own Git worktree; they differ on platforms, on how an agent runs, and on whether agents can reach each other.**

| Criterion | Conductor | MAO |
| --- | --- | --- |
| Platforms | macOS. Not available for Windows or Linux yet. | macOS (Apple silicon and Intel), Windows (x86_64), Linux (x86_64, Wayland and X11) |
| Agents supported | Claude Code, Codex, Cursor and OpenCode as chat harnesses. The experimental Big Terminal Mode has presets for Claude, Codex, OpenCode, Amp, Pi, Copilot and Gemini and runs any command. | Claude Code, Codex, Gemini CLI, Grok, OpenCode, Antigravity, shells and custom commands |
| How an agent runs | A chat tab with one harness and one model; Claude Code, Codex and OpenCode are bundled with the app. Each workspace also has a terminal. | A real terminal node on the canvas running the agent's own CLI and login, with an optional chat mode |
| Isolation per agent | One Git worktree and branch per workspace; chats in one workspace share it. Cloud workspaces run in isolated Linux sandboxes. | Optional layers: each layer is a Git worktree on its own branch with its own canvas, landed into Ground after a check |
| Agents handing work to each other | Not documented. The Conductor API and MCP server let a client create cloud workspaces and send prompts; teammates hand a workspace over with **Reassign to**. | Wires between agents; `mao ask`, `mao send` and `mao result` deliver tasks with IDs and return results |
| Built-in browser or device testing | Experimental in-app browser that previews a localhost page; you annotate the UI and attach the notes to the chat. Agent control of it and device testing are not documented. | A Chromium browser portal and an Android emulator or phone that a wired agent drives; an iOS Simulator portal on a Mac |
| Remote machines | Conductor Cloud workspaces in Linux sandboxes, opened over SSH or synced to your Mac; the iOS app can control your Mac's local workspaces (experimental). Your own servers: not documented. | A workspace on your own Linux server over SSH, or inside WSL on Windows; remote workspaces need a licence |
| Source | Closed source: no public repository, and its terms of service forbid copying, modifying or reverse engineering it | Closed source; sold as a licence |
| Price | Free; Pro US$50 a month; Teams US$60 per user a month; Enterprise custom. Model usage is billed by your provider. | One-time purchase, US$20 in most countries and lower in parts of Asia and South America; 7-day free trial with 1 workspace and 1 project |

## When does Conductor fit better?

**When you work on a Mac, want to start free, and want each task to end as a reviewed pull request.**

- **It is free to start.** The Free plan runs several agents in parallel in local workspaces with your own subscriptions and keys. MAO's trial lasts 7 days and covers one workspace and one project.
- **The path to a pull request is built in.** Conductor's diff viewer, checks and pull request tools are part of every workspace, and you can start a workspace from a GitHub or Linear issue.
- **Workspace setup is automated.** Setup scripts, **Files to copy** for gitignored config and `$CONDUCTOR_PORT` give each workspace its own environment and its own port without manual steps.
- **Checkpoints undo a turn.** Conductor snapshots the branch before each agent reply, and you can revert the code and the chat to an earlier turn.
- **Cursor runs inside it.** Conductor runs Cursor Agent through the Cursor API; Cursor is not among the agents MAO lists.
- **Hosted cloud workspaces.** On Pro and up, agents keep working in a Linux sandbox after you close your laptop, and teammates can open the same workspace and chat. MAO's remote workspaces run on a Linux server you provide.

## When does MAO fit better?

**When you are not on a Mac, when your agents are terminal CLIs, or when agents should pass work to each other.**

- **Windows and Linux.** MAO runs on macOS, Windows and Linux; Conductor is macOS only.
- **Real terminals with the agent's own login.** Each agent in MAO is its own CLI in a terminal node, including Gemini CLI, Grok and Antigravity, and any custom command.
- **Agents hand work along wires.** Connect two agents on the canvas and one can send the other a task with `mao ask` and get the result back by task ID, with no copy and paste through you.
- **Agents test in a browser or on a phone.** A wired agent navigates, clicks and screenshots a Chromium browser portal, or taps and types on an Android emulator or phone, while you watch on the canvas.
- **Your own server.** A MAO workspace can live on a Linux server over SSH, or in WSL on Windows, so the project and agents run next to the compute.
- **One payment.** MAO is a one-time purchase, with remote workspaces included in the licence.

## How do I compare them on a real task?

**Give both the same task with two independent parts and watch how the work moves.**

1. Pick a change with two parts that touch different files, such as an API endpoint and its tests.
2. In Conductor, create one workspace per part, start an agent in each, then review each diff and open a pull request.
3. In MAO, create one layer per part, start an agent on each, wire them so one reviews the other's work, then land each layer into Ground.
4. Compare how you followed both agents, how work and feedback moved between them, and what was left for you to do by hand.

## Frequently asked questions

### Is MAO an alternative to Conductor?

Yes, for running several coding agents in parallel on one repository, each on its own Git branch and worktree. Conductor runs Claude Code, Codex, Cursor and OpenCode as chat sessions on a Mac; MAO runs agents as real terminals on a canvas on macOS, Windows and Linux, and lets them hand tasks to each other.

### Is Conductor open source?

No. Conductor's site links no source repository, and its terms of service forbid copying, modifying or reverse engineering the platform.

### Does Conductor run on Windows or Linux?

No. Conductor's install guide says it is available for macOS and not yet for Windows or Linux. Its cloud workspaces run in Linux sandboxes, but you open them from the Mac app.

### Does Conductor support Gemini CLI?

Not as a chat harness: Conductor's harnesses are Claude Code, Codex, Cursor and OpenCode. Its experimental Big Terminal Mode has a Gemini preset that runs `gemini -y` in a terminal. MAO runs Gemini CLI as a terminal agent node.

### How much do Conductor and MAO cost?

Conductor has a free plan for local workspaces; Pro is US$50 a month and Teams US$60 per user a month, and you pay your model provider separately. MAO is a one-time purchase of US$20 in most countries, lower in parts of Asia and South America, after a 7-day free trial.

## Sources

- [Conductor home page](https://www.conductor.build/): parallel Claude Code, Codex and Cursor agents in isolated workspaces on a Mac, and review and merge.
- [Conductor: Introduction](https://www.conductor.build/docs): the four agents, and review, pull request, merge and archive of a workspace.
- [Conductor: Install](https://www.conductor.build/docs/installation): macOS only, not yet Windows or Linux, and the GitHub and agent sign-in checks.
- [Conductor: Isolated workspaces](https://www.conductor.build/docs/concepts/workspaces-and-branches): Git worktrees, one branch per workspace, and isolation that is not a security boundary.
- [Conductor: Harnesses](https://www.conductor.build/docs/reference/harnesses): the four harnesses, the bundled CLIs, one harness and model per chat tab, and model usage billed by the provider.
- [Conductor: From issue to PR](https://www.conductor.build/docs/guides/issue-to-pr): starting a workspace from a GitHub or Linear issue.
- [Conductor: Parallel agents](https://www.conductor.build/docs/concepts/parallel-agents): sharing one workspace or splitting work across workspaces.
- [Conductor: Big Terminal Mode](https://www.conductor.build/docs/reference/big-terminal-mode): the experimental full terminal and its agent presets.
- [Conductor: Testing](https://www.conductor.build/docs/concepts/testing) and [Files to copy](https://www.conductor.build/docs/reference/files-to-copy): actions, `$CONDUCTOR_PORT`, Spotlight testing and copying gitignored files into workspaces.
- [Conductor: Checkpoints](https://www.conductor.build/docs/reference/checkpoints) and [Diff viewer](https://www.conductor.build/docs/reference/diff-viewer): reverting to an earlier turn and reviewing changes before a pull request.
- [Conductor 0.62.0 changelog](https://www.conductor.build/changelog/0.62.0-repo-settings-browser-preview): the experimental in-app browser preview with Agentation annotations.
- [What is Conductor Cloud?](https://www.conductor.build/docs/cloud) and [Work with cloud workspaces](https://www.conductor.build/docs/cloud/working-with-cloud-workspaces): Linux sandboxes, SSH, file sync, sleep and lifetime, and **Reassign to**.
- [Conductor API](https://www.conductor.build/docs/api) and [Conductor MCP server](https://www.conductor.build/docs/api/mcp): creating cloud workspaces and sending prompts from code or an MCP client.
- [Conductor: Remote Control](https://www.conductor.build/docs/reference/remote-control): controlling a Mac's local workspaces from the iOS app.
- [Conductor: FAQ](https://www.conductor.build/docs/faq): agents run with your user permissions without sandboxing, and Conductor uses the logins on your machine.
- [Conductor pricing](https://www.conductor.build/pricing): Free, Pro, Teams and Enterprise.
- [Conductor terms of service](https://www.conductor.build/terms): the restrictions on copying, modifying and reverse engineering.
- [MAO product facts](https://trymao.dev/llms.txt): platforms, supported agents, price and free trial.
- [Run a shell or agent](https://trymao.dev/docs/terminals-agents/terminal-and-agent-nodes) and [Switch an agent node to chat mode](https://trymao.dev/docs/chat-mode-threads/framed-chat): terminal nodes and chat mode.
- [Create a worktree layer](https://trymao.dev/docs/layers-git-worktrees/create-layer) and [Land a layer into Ground](https://trymao.dev/docs/layers-git-worktrees/land-layer): layers as Git worktrees and landing them.
- [Send a task and collect its result](https://trymao.dev/docs/connections-orchestration-mao-cli/task-delivery): `mao ask`, `mao send` and `mao result`.
- [Browser and device portals](https://trymao.dev/portals) and [Remote workspaces](https://trymao.dev/remote-workspaces): browser, Android and iOS Simulator portals, SSH and WSL workspaces.

Checked on 2026-10-28.

Source: https://trymao.dev/mao-vs-conductor