A Deep Dive on Conductor (YC S24)
Closing the tooling gap for multi-agent coding workflows.
Conductor is a Mac app that orchestrates multiple coding agents in parallel Git workspaces and turns their output into reviewable, testable, mergeable code. The primary UI for “AI-managers” coordinating AI “employees,” i.e., the human interface to AI organizations.
When “More Agents” Becomes “More Chaos”
Agentic coding makes writing code cheap, but makes coordination expensive. The pain is managing multiple partially-correct changes across branches, terminals, tests, and PR checks without losing your place or breaking main. Conductor points to the tedium of running multiple Claude Code sessions across multiple cloned repos.
Most teams are currently improvising. Common patterns: (1) one agent at a time inside an IDE copilot; (2) multiple terminals/windows running Claude Code or Codex against separate repo copies; (3) manual git worktrees/branches; (4) cloud agents that open PRs for you. Each can work, but each pushes coordination cost back onto the human.
The shortcomings cluster into three buckets: (a) setup friction (clones, env files, ports, dependencies); (b) safety/traceability (what changed, why, and can I undo it?); (c) merge readiness (tests, checks, review). Conductor’s docs and changelog repeatedly add features in these buckets: scripts for setup/run/archive, checkpoints for undo, a diff viewer and checks tab for merge readiness.
The Eureka: Turn Agents Into Parallel Worktrees
The solution is to treat each agent like a junior engineer: give it its own workspace, let it work without stepping on others, then review/merge its changes. Conductor operationalizes that idea by making new agent = new isolated workspace a first-class primitive (Cmd+N), backed by Git worktrees.
Conductor’s unique move is to combine (1) parallelism (many agents), (2) isolation (worktrees/branches), and (3) a merge pipeline (diff review, checks, PR creation) into one tight loop. Many tools do one or two; Conductor is trying to own the whole “agent → merge” arc.
Endurance comes from workflow gravity. If Conductor becomes the place where work starts (issues), work happens (agents + IDE), and work ends (checks + PR + merge), then switching costs rise: scripts, conventions, team policies, and historical context live there. Checkpoints (local, separate from Git history) are also a trust feature: they make experimentation less scary.
The obvious frontier is collaboration: shared agent fleets, shared scripts, shared policies, and shared audit trails. Conductor’s FAQ suggests monetization around collaboration features, implying the product roadmap likely expands from single-player orchestration to team orchestration.
Instead of cloning a repo three times and running three agents “by hand,” you create three workspaces, attach them to issues, and watch progress in a single sidebar. When one agent finishes, you can review diffs, check CI, and merge - without mentally reconstructing what happened in which terminal.
Conductor runs locally on macOS, clones repos to your machine, and relies on your terminal environment for GitHub auth (gh auth status) and Claude Code login. It can also open workspaces in your preferred IDE while keeping orchestration in its own UI.
Common use cases: (1) parallel feature development (one workspace per feature/bug); (2) rapid PR iteration (review + checks + fix loop); (3) multi-repo changes (several repos, several workspaces); (4) test automation via scripts/run panel; (5) migrating from Cursor while keeping MCP servers and project rules.
Why This Didn’t Exist
The limiting factor shifted. In 2020-2023 the limiting factor was “can the model write code?”; in 2024-2026 it’s increasingly “can you coordinate and verify lots of model-written code?” Conductor exists because multi-agent coding turns coordination into the bottleneck. The team describe trying to run multiple Claude sessions by cloning repos felt like “driving a Subaru with a jet engine strapped on.”
Before agentic tooling (Claude Code/Codex-style CLI agents), there was no “fleet management” problem at the individual developer level. IDE copilots live inside one editor session; they don’t force you to manage ten concurrent branches. The vacuum appears when agents become cheap enough to run in parallel and powerful enough to be worth it.
The category evolved in layers: autocomplete copilots → chat-in-IDE → repository-aware agents → multi-agent workflows. Conductor positions itself in the last layer: not “help me write this file,” but “help me supervise parallel work and merge safely.”
Three trends matter: (1) rapid adoption of AI assistance in development; (2) the rise of agent-first tools (Claude Code/Codex as command-line agents rather than just in-editor helpers); (3) standardization of dev workflows around GitHub PRs + CI checks, which orchestration tools can tap into.
How Big Is “AI Management,” Really?
Primary customer (today): individual developers and small teams on macOS who already use (or are willing to use) Claude Code/Codex workflows and GitHub PRs. Conductor requires GitHub CLI auth and Claude Code login, and is not yet available for Windows/Linux.
Conductor is trying to name (and therefore own) an emergent job-to-be-done: “AI manager / AI orchestrator.” If that job becomes common, the market is not just ‘IDE seats’ but ‘agent-fleet management seats.’
Early adopters look like: high-output builders, fast-moving startups, and product-minded engineers who are comfortable with Git branches and PR workflows, and who feel the pain of context-switching across parallel workstreams. Clustering around productivity unlocks and parallelization. Conductor lists builders at (among others) Linear, Vercel, Notion, and Stripe.
The Arena: IDEs, Orchestrators, and the OS Layer
Direct competition is any tool that can (a) run agents and (b) manage multi-step changes toward a PR. Closest adjacency today is agent-capable IDEs/editors (e.g., Cursor) and platform copilots (GitHub Copilot) as they expand into agent workflows.
Indirect alternatives include: (1) plain Claude Code/Codex in multiple terminals; (2) manual git worktrees and shell scripts; (3) cloud agents that open PRs; (4) existing IDE + task management without orchestration. These are “good enough” substitutes until parallelism becomes a daily habit.
Conductor’s plausible winning plan is a workflow wedge: become the best UI for supervising multiple agents (visibility, safety, merge readiness) while staying model-agnostic (supporting Claude Code logins and multiple providers). Then expand into team collaboration, where the real lock-in lives.
Advantages visible in the product/design choices: (1) isolation-by-default via workspaces/branches; (2) reversible experimentation via checkpoints stored outside Git history; (3) an end-to-end merge loop (diff viewer + checks) inside the same app; (4) low marginal infrastructure cost because work executes locally.
Inside the Cockpit: What Conductor Actually Ships
Conductor has a macOS desktop app that manages repositories and workspaces and embeds chat, a terminal, and review tooling. Conductor is not available for Windows/Linux yet (with a waitlist).
Core primitives: repositories → workspaces (isolated copies/branches) → chats (Claude Code/Codex sessions) → review (diffs, comments, checks) → merge. Creating workspaces from branches, PRs, or Linear issues and then opening in an IDE or using built-in chat.
Notable features: parallel agents (Cmd+N); scripts (setup/run/archive); testing via run scripts and experimental ‘spotlight testing’; diff viewer with recommended merge actions; todos that can block merging; MCP integration; slash commands; and checkpoints (automatic turn-by-turn snapshots with revert).
The architecture is intentionally local-first. Workspaces are isolated Git copies/branches; environment setup can be automated via scripts; authentication relies on the user’s local GitHub CLI and Claude Code login. Conductor can route Claude Code through alternative providers using environment variables
How This Becomes a Business
Conductor’s current go-to-market appears product-led: a free Mac download that uses the customer’s existing Claude Code login, paired with fast shipping and social proof from builders. The likely long-term play is to monetize the coordination layer (collaboration, policies, audit trails) rather than the underlying model usage.
No detailed revenue disclosures exist publicly as of the moment. Conductor is currently free and that the team expects to charge for collaboration features in the future, which implies a seat-based SaaS model for teams. Current: $0 for the app (model costs are paid to the model provider via the user’s login). Future: likely per-seat for collaboration, anchored to comparable tools ($10-$40/user/month range).
A reasonable base-rate model: individual seats at $20/mo and team plans at $40/user/mo (Cursor Teams anchor). If Conductor becomes a daily ‘manager UI,’ retention should resemble core dev tools (high), but this is unproven today.
Near-term sales & distribution model: self-serve, developer-driven adoption. Mid-term: team collaboration will create a natural ‘land and expand’ motion (a manager adopts; teammates join to share scripts/policies). Long-term: enterprise features (SSO, audit logs, data controls) if Conductor targets regulated orgs - but no public roadmap commits to this yet.
Public-facing pipeline signals include testimonials and listed logos (Linear, Vercel, Notion, Stripe, Life360, etc.) and YC-associated hiring traction. These are useful for narrative, but not a substitute for contracted ARR visibility.
The Builders
Conductor’s story reads like a small-team advantage play: two founders with product + engineering taste, plus a founding engineer with orchestration/UI experience, building a tool they use daily.
Charlie Holtz (CEO) and Jackson de Campos (co-founder) are the active founders. Holtz previously led growth at Replicate and worked as a quantitative developer at Point72; de Campos frames Conductor as “the human interface to AI organizations.” A founding engineer, Omid Mogasemi, describes the stack as Tauri + React + TypeScript and notes prior orchestration work at Netflix.
Conductor has raised $2.8M and lists investors including Goodwater, Caffeinated Capital, YC, and several notable angels.
Five Years Out: From App → Operating System for Agent Work
A default control plane for agentic development: a place where a human can spin up specialized agents, assign them to issues, monitor progress, enforce policies (tests, lint, security), and merge with confidence - across individuals and teams. In Conductor’s own framing, this is the “human interface to AI organizations.”
A five-year Conductor that wins probably looks more like air-traffic control: queues, permissions, audit logs, reproducible environments, and shared organizational memory. The trick is to build those without losing the lightweight feel that made the early product adoptable.