Conductor: orchestrating multiple AI agents on Mac without the mess

For a few weeks now I have been using Conductor as my hub for running AI agents on my Mac. This very post is being written inside a Conductor workspace.

In one sentence: it is the missing app that lets you stop wrestling with git worktree, tmux, and five terminal windows every time you want Claude Code, Codex, and other agents working in parallel.

The problem before Conductor

Once you start using AI agents seriously, two limits show up fast:

1. One agent, one repo, one terminal — if you want to run two tasks at the same time, they fight over the same working tree.
2. Fragmented context — each window has its own state, its own installed deps, its own .env.

The manual workaround exists: create a git worktree per task, install deps in each one, open the right editor pointed at the right directory. It works. But it is just enough friction that you give up and go back to running things serially.

What Conductor solves

Conductor is a native macOS app that takes all this orchestration and hides it behind a clean UI. Each "workspace" is a real git worktree of your repository, with its own agent running in isolation.

You see every workspace side by side, you know what each agent is working on, you review the diff, and you merge — all without leaving the app.

The features I actually use every day

Here is what genuinely changed my workflow:

• Isolated parallel workspaces — Claude Code, Codex, and other agents running at the same time, each in its own worktree. No branch conflicts, no panicked git stash.
• Automatic git worktree — when you click "+ New workspace", Conductor spins up a fresh worktree from the latest main. Zero manual commands.
• Built-in diff viewer — you review the agent's changes inside the app, with the same review quality you would get from a PR.
• Open and merge PRs without going to GitHub — "Open PR" button, "Merge" button. For small tasks, this saves a lot of clicks and context switching.
• Merge conflict guard — if there is a conflict with main, Conductor blocks the merge and tells you why. You cannot accidentally pollute the history.
• Checks visible in the workspace — CI status shows up next to the diff, so you decide with full information.
• Clean archive — task done, PR merged, you click archive and Conductor removes the worktree for you. No accidental rm -rf.
• Per-workspace .context folder — gitignored, ideal for coordination files between agents (plans, notes, attachments) without polluting the repo.
• Multi-agent support — it is not just a Claude Code wrapper. It runs Codex and other agents in parallel on the same project, so you can compare approaches.

How my workflow changed

Before, I was afraid to start a second task while the first was still running. Now it is the opposite: while Claude Code is finishing this post, another workspace has Codex solving a UI issue, and a third one has another Claude refactoring a build script.

When one finishes, I review the diff, merge the PR, archive it, and open a new workspace with +. New branch, latest main, ready for the next task.

Concretely: while writing this post, I had two active workspaces on the same repo — one with this article (+180 lines) and another with the Lenis smooth scroll integration (+262 lines). Two PRs created and processed in parallel, in the same time window I used to spend on a single task.

The feeling matches what the Conductor team describes on their home page: "feels like going from typing with two fingers to having eight arms". That is not marketing copy — that is exactly what it is.

The PR flow is the real highlight

Out of all the features, the one that won me over the most was the review → open PR → merge → archive loop, all inside the app:

1. The agent finishes the task in the workspace.
2. You open the diff in Conductor — and honestly, the diff is really good. Reads better than several desktop clients.
3. You click "Open PR". The PR lands on GitHub with title and body already filled.
4. If the task is clean, you click "Merge" and you're done.
5. If there is a conflict with main, Conductor blocks the merge and warns you — so you don't merge garbage by accident.
6. After the merge, archive removes the worktree.
7. The next "+ New workspace" already starts on a freshly updated main, including what you just merged.

The end result is that you almost never need to open GitHub in the browser. Delivery becomes a closed loop inside Conductor itself, and that completely changes how fluid the day feels.

What's missing (wishlist)

If I could request one feature from the Conductor team, it would be the freedom to plug in my current favorite coding agent: pi.dev.

On pi.dev I use the cmux terminal, which helps a lot to coordinate sessions — but the experience here on Conductor is still much better for the full loop of workspace → diff → PR → archive.

Native pi.dev support inside Conductor would be the perfect combo. Stay tuned for the next chapters.

When it makes sense to adopt

If you are already working with Claude Code or Codex and you feel capped at one task at a time, Conductor pays for itself fast. If you are still learning agents, master the basics first — orchestrating three confused agents in parallel just multiplies the chaos.

For an official overview, check:

• Site: conductor.build
• Docs: conductor.build/docs
• X: @conductor_build

Wrapping up

A good tool is the one that disappears in front of you. Conductor does that for the boring git worktree + multi-agent layer, and lets you focus on what matters: reviewing the agents' work and making decisions.

If you are building with AI as daily practice, not as a toy, it is worth a serious try.