For the last weeks I’ve been playing a lot with Conductor, a Mac app that let you run many coding agents at the same time, each one inside its own workspace. After some years of using AI assistants only from the terminal, this changed quite a lot how I work, so I want to share my thoughts about it. 🚀
This is not a sponsored post, just my honest experience as an iOS engineer that also touches web stuff (like this blog you are reading).
What is Conductor?
The short version: Conductor is a desktop app that wraps coding agents (Claude Code, Codex, etc.) and gives them a proper home. Instead of one terminal session with one agent, you get a list of “workspaces”, and every workspace is an isolated copy of your repo with its own branch, its own agent, and its own state.
You can think of it like having multiple junior engineers, each one working on a different ticket, and you are the tech lead reviewing their PRs. Except they don’t sleep, and they type really fast.
The things I like the most
Multi-workspaces
This is the killer feature for me. You spin up a workspace, give the agent a task (“add a sitemap”, “fix the contact form spam”, “write a blog post about X”), and while it works, you open another workspace and start something completely different.
Before, when I used Claude only from the CLI, I had this mental block: I could not really start a second task until the first one finished, because they all shared the same working directory. Now, every workspace is a separate git worktree, so there is zero conflict between them.
In practice this means I can have:
- One agent migrating a UIKit screen to SwiftUI
- Another writing tests for a network layer
- A third one drafting a blog post
…all at the same time, and I just jump between them when one needs my input.
GitHub and Linear integrations
Conductor connects with GitHub and Linear, and this is where it stops feeling like a toy.
- GitHub: the agent can open PRs, read diffs, comment, and even respond to review comments. When you finish a workspace, creating the PR is one click (or one command). No more copy-pasting commit messages between terminals.
- Linear: you can pull a ticket directly into a workspace as the task description. The agent reads the ticket, understands the context, and starts working on it. Closing the loop between “ticket in the backlog” and “PR open for review” becomes really fast.
For me as an iOS engineer this is huge, because a lot of my work is small, well-scoped tickets that an agent can knock out while I focus on the bigger architectural stuff.
Inline reviews
This one took me by surprise. Inside Conductor you can review the agent’s diff inline, leave comments, and the agent will read them and respond, just like a normal PR review on GitHub. But local, before anything is pushed.
It feels much more natural than the typical CLI flow of “scroll up to find the diff, copy a snippet, paste it back with your feedback”. You just click on a line, write what you want, and the agent iterates.
Choosing between Claude and Codex (and others)
Conductor doesn’t lock you to one model. You can pick Claude (Opus, Sonnet, Haiku), Codex, or others, and switch per workspace. I tend to use:
- Opus for architecture decisions and writing prose (like this post 😄)
- Sonnet for everyday coding tasks where speed matters
- Codex when I want a second opinion or when a task is very code-heavy
Having both in the same app, with the same UI, is more powerful than I expected. Different models really do have different strengths, and being able to A/B them on the same task is something I now do often.
Conductor vs the command line
If you already use Claude Code or similar tools from the terminal, you might wonder if a desktop app is really necessary. Some honest comparisons:
What you gain:
- Parallelism without manual git worktree juggling
- A proper UI for diffs, inline reviews and workspace status
- Built-in PR / Linear integration
- Easy switching between models
- Notifications when an agent finishes or needs your attention
What you might miss:
- The pure terminal feel (although you still have a terminal inside each workspace)
- Some scripting flexibility, if your workflow is very CLI-heavy
- Total control over the environment (but Conductor exposes most of it)
For me the trade is very worth it. The CLI is great for one-off tasks, but the moment I want to run two or three things in parallel, the desktop app wins easily.
Some considerations
It’s not all magic, of course. A few things to keep in mind:
- Cost: running multiple agents in parallel means multiple API calls. If you are on a metered plan, watch the bill. Opus is specially expensive.
- Review discipline: it’s tempting to just merge whatever the agent produces because the diff looks fine. Don’t. Read the code, run it, test it. The agents are smart but not infallible, and small issues compound when you ship a lot of PRs in a day.
- Context fragmentation: with many workspaces running, it’s easy to lose track of what each one is doing. I use the Linear ticket title as the workspace name and that helps a lot.
- Mac only: at the moment of writing this, Conductor is a Mac app. If you are on Linux or Windows, you will have to wait or stick with the CLI.
Final thoughts
Conductor is one of those tools that change the shape of your day. Instead of “I’m going to code feature X for the next 3 hours”, it becomes “I’m going to coordinate 4 small tasks and review their results”. The role of the engineer shifts a bit closer to a tech lead reviewing junior work, which is sometimes refreshing and sometimes exhausting, depending on the day. 😅
If you are already comfortable with Claude or Codex from the terminal and you find yourself wishing you could just clone yourself, give Conductor a try. The first time you have three agents working in parallel and you realize you just need to review and merge, it’s hard to go back.
You can check it out at conductor.build.