The moment you start using Claude Code or Codex and think, “I want to run multiple agents at the same time,” you hit the same wall most people do. Conductor, Superset, cmux. They all advertise themselves as parallel agent runtimes, and the screenshots barely tell them apart.
Here’s the conclusion up front: the choice between these three doesn’t come down to a feature comparison chart. The real difference lives on your side of the screen — in the way you actually work.
In this article, we’ll pull out the two axes that create the gap between these tools, and walk you through far enough that you can pick the right first one for your style. Instead of a feature dump, we’ve focused on the kind of information that actually matters once you’ve installed the thing.
What problem are these three trying to solve?
First, let’s name the shared problem these three tools are answering.
When you’re running just one agent — Claude Code or Codex — a terminal and VS Code are plenty. But the moment you want to run a “refactoring agent,” a “test-fixing agent,” and a “docs-updating agent” in parallel, things get awkward fast. Multiple agents editing the same branch will collide. Open enough terminals and you’ll lose track of what’s running where.
All three tools step into the same role: the control tower for the parallel-agent era. So where do they actually diverge? The differences come from two places — the shape of the UI (GUI or terminal) and the relationship with Git. These two axes are everything.
Axis #1: Are you a GUI person or a CLI person?
The first axis is about where your work actually lives.
Conductor and Superset are both shipped as native macOS apps. You can see agent status, diffs, PRs, and browser previews lined up in a single window. They suit people who like the reassurance of a GUI, who want to share their screen with teammates, or who appreciate dashboard-style visibility.
cmux, on the other hand, isn’t an app at all — it’s a native terminal. It’s built on top of Ghostty, the popular terminal, and it splits panes tmux-style so you can line up agents side by side. Because it isn’t Electron-based, it feels light, and your existing Ghostty themes and font settings carry straight over.
This isn’t a matter of taste; it’s a matter of where you spend your day. If you live inside a terminal and want to drive everything from the keyboard, a GUI app is a source of friction, not comfort. The reverse is true too: someone used to one-click GUI buttons will end up relearning pane-switching keybindings if they jump straight into cmux.
If VS Code or Cursor is your daily driver, lean GUI (Conductor or Superset). If your home base is the terminal and Neovim, lean cmux. That single question already narrows the field.
Axis #2: Isolated worktrees, or working directly on main?
The second axis is your relationship with Git.
Conductor is built around the idea of “spin up a fresh worktree every time and run the agent inside it.” Each agent gets its own directory and branch, so they never collide. The catch is that instead of reusing your existing local checkout, it re-clones the repository from scratch, which means every new worktree forces you to reinstall dependencies and reconfigure .env files. Hacker News commenters have called this re-clone approach out repeatedly.
Superset auto-manages worktrees in a similar spirit, but it grows them on top of your existing local repository. No re-cloning, and your node_modules and .env.development.local stay in place. This is what people mean when they say it “feels close to working directly on main.” On top of that, Superset has rich integrations with external editors (VS Code, Cursor, JetBrains, Xcode) and an in-app browser preview, so you can verify frontend behavior without leaving the app.
cmux doesn’t do native worktree automation. You — or the agents themselves — create worktrees via the CLI. In exchange, commands like cmux new-split, cmux send, and cmux read-screen let agents spawn their own tabs and panes. It’s low-level and flexible, but you have to assemble the setup yourself.
In short: Conductor is “isolate me at all costs,” Superset is “let me use my repo as-is,” and cmux is “let me build the whole thing myself.”
A 2-axis map: where do you want to stand?
That’s the groundwork. Define your own style first, then go shopping — that’s the spine of this article.
Picture a chart with “GUI vs CLI” on the vertical axis and “isolated worktree vs direct work” on the horizontal.
- Top-left (GUI × isolated): Conductor’s territory
- Top-right (GUI × direct work): Superset’s territory
- Bottom-right (CLI × leaning direct): cmux’s territory
- Bottom-left (CLI × isolated): no product fits — this is where you’d bolt scripts onto cmux yourself
Where do you want to stand? Once you’ve answered that, you’ve already cut the field down to one or two candidates. What’s left is checking the practical stuff — pricing, licensing, reputation — that hits you after adoption.
Conductor: a Mac app aiming for “Just Works” with a GUI
Conductor is a Mac app from Melty Labs (Y Combinator S24), released in July 2025. Linear, Vercel, Notion, Ramp, and Spotify are listed as official adopters.
Its strength is a tight focus on Claude Code and Codex. You bring your own API keys; the app itself is free. Create a workspace, fire up an agent, and you can run diff review, PR creation, AI review, and CI checks end to end inside the GUI. On Hacker News, the responses skew positive: “a clean GUI extension for Claude Code,” “does one thing well.”
There are two landmines. The first is the re-clone approach mentioned earlier — having to wait every time you spin up a worktree adds up when you’re iterating fast. The second was an early-version issue around overly broad GitHub permissions, which raised privacy concerns; this has since been improved with finer-grained permissions and gh auth integration.
Conductor fits people who work primarily on Mac, have already settled on Claude Code or Codex, and value the comfort of a GUI.
Superset: the case for a neutral orchestrator
Superset is a relatively new tool that surfaced on Hacker News in late 2025 and got attention on Product Hunt in March 2026. Its GitHub repo has crossed 9,000 stars.
What stands out is its commitment to being “agent-neutral.” It can drive Claude Code, Codex, Gemini, Cursor Agent, OpenCode, Aider, and other major CLI agents from a single surface. When a new CLI lands, you’re not locked into a wrapper — you can adopt the latest features right away. It’s a design rooted in real-world usage.
Pricing-wise, there’s a free individual tier plus a Pro plan at $20/seat/month. Superset is the only one of the three with explicit charging for the app itself. In return, you get the features teams actually want: built-in browser preview, chat, a diff editor, MCP server connections, and integrations with GitHub and Linear.
User reactions range from “it changed how I think about coding with AI” to a more sober “can a human really review ten parallel agents?” That second concern isn’t specific to Superset — it’s an early warning about the parallel-agent era as a whole.
Superset suits people who want to mix and match different CLI agents, who want to keep working on their existing local repository, and who are eyeing it as a shared team tool.
cmux: the rising star for terminal sovereignty
cmux is an open-source native terminal from Manaflow (also a Y Combinator company). It’s GPL-3.0, has crossed 14,900 GitHub stars as of April 2026, and has reached version v0.63.2. There are reports of 9,500 stars added in two weeks — the strongest momentum of the three.
It inherits your Ghostty configuration (theme, font) directly, and lets you arrange multiple agents using vertical tabs and split panes. A blue ring marks “agents waiting for input,” and the sidebar gives you a single view of git branches, PRs, port numbers, and notifications. The cmux notify CLI hooks into Claude Code’s hooks, sending a macOS notification the moment an agent finishes.
Going further, cmux ships a built-in scriptable browser and a socket API. Agents can snapshot the DOM accessibility tree to automate clicks and form fills, or spawn other agents. For people who want to drive everything from the CLI, there are very few tools that let you reach this deep.
On Product Hunt, Brian Ellin (co-founder of Pilot) called it “a daily companion and the best tool for managing multiple agents across multiple workspaces,” and users have followed up with comments like “the notifications changed my workflow in ways I didn’t expect.” It’s currently winning over Ghostty users and people who want to avoid Electron apps.
Two caveats. The first is that it’s macOS-only — no mobile, no remote environments. The second is the GPL-3.0 license. Reddit has voices saying “it would see broader corporate adoption under MIT or Apache,” and organizations with license review processes will need to weigh this carefully.
Pricing, licensing, OS: the differences that bite in practice
Let’s organize the discussion around three practical lenses that map directly to adoption decisions.
Pricing. All three use BYO API keys, and your Claude or OpenAI usage fees are separate. The only one with app-level charging is Superset Pro ($20/seat/month). Conductor and cmux are free. For individuals, the app cost is the same across the board; for teams, only Superset’s per-seat charge kicks in.
Licensing. Conductor is closed-source, Superset is open-source, and cmux is GPL-3.0. GPL is “viral” — it propagates the same license to derivative works — so if there’s any chance you’ll embed it in your own product, you need legal review. For personal development environments, there’s no practical issue. If you want OSS by default, Superset or cmux. If you want the comfort of a branded product, Conductor.
OS. Unfortunately, all three are macOS-only. Conductor has a Windows waitlist, but at this point none of them officially support Linux. If your daily driver is Windows or Linux, choosing among these three is itself difficult, and you’ll likely be looking at alternatives like VS Code’s Agent mode or Dev Container–based setups.
Your first pick, by type
Combining the 2-axis map with the practical factors, here’s the first tool to try, by type.
- You’re committed to Claude Code or Codex and want the comfort of a Mac app → Conductor. Almost no setup, and you can start running things in parallel inside the GUI right away.
- You want to switch between multiple agents (Claude, Codex, Gemini) depending on the moment → Superset. No wrapper lock-in, and it keeps up with new CLIs quickly.
- You live in the terminal and like growing your environment through customization and automation → cmux. There’s a learning curve, but what you can do on the other side of it is in a different league.
- You want a single team tool that also handles frontend preview → Superset. Browser preview and external editor integration are right there.
- You’re at an organization where GPL-3.0 won’t pass legal review → Conductor or Superset. Keep cmux to personal experimentation.
Pick whichever of the five you’re closest to, and try that row’s tool for one week. That’s the lowest-cost way to fail.
After you pick the first one
One last thing about this choice: it’s provisional.
How to actually wield parallel agents is still an open question in 2026 — best practices haven’t settled. None of these three existed in this form a year ago. Six months from now, another tool may be on the rise, and one of these three may have shifted position.
So you don’t need to settle everything with your first pick. Use the 2-axis map to locate yourself, try whatever fits best for a week, and move on if something feels off. That cycle itself is what shapes your work philosophy.
Start with Conductor and learn what an easy GUI feels like. Move to Superset and pick up the rhythm of switching between agents. Reach cmux and discover how deep terminal automation can go. Climb that staircase over a few months, and what you actually want to build will start to come into focus — through the act of choosing tools.
References
- Conductor official site: https://www.conductor.build/
- Superset official site: https://superset.sh/ (comparison with Conductor: https://superset.sh/compare/superset-vs-conductor)
- cmux on GitHub: https://github.com/manaflow-ai/cmux
- Conductor review (The New Stack): https://thenewstack.io/a-hands-on-review-of-conductor-an-ai-parallel-runner-app/
- Show HN: Conductor: https://news.ycombinator.com/item?id=44594584
- Show HN: Superset: https://news.ycombinator.com/item?id=46368739
- cmux on Product Hunt: https://www.producthunt.com/products/cmux