Conductor vs PRCHD: Move the Agent, or Move the Desk?

What happens to your coding agent when you stand up?

That's the whole comparison. The rest is detail.

Conductor and PRCHD agree on more than they disagree. Both run Claude Code and Codex on a Mac. Both give every task its own git worktree and branch, so parallel agents never trip over each other. Both have a plan mode that proposes before it edits. Both treat the diff as the product and the merge as the finish line.

Then you leave the desk, and they split.

Conductor moves the agent. Its cloud workspaces run in managed sandboxes, so the work carries on after you shut the laptop.

PRCHD moves the desk. The agent stays on a computer you own. Everything you'd have done sitting at it, from picking up the story to opening the pull request, moves to your phone, which reaches that computer over your own network.

Neither is an accident. They're two bets on where your code should be when nobody's watching.

Where does the agent go when you leave?

Conductor gives two answers.

Local workspaces run on your Mac. Messages go straight to the model provider, session data stays on your device, and Conductor doesn't see your inputs or outputs. That's a clean promise. Its limit is in Conductor's own docs: close the app or shut down the Mac, and those sessions end.

For work that should outlive the laptop, there's Conductor Cloud. Each workspace is an isolated microVM, a Vercel sandbox in us-east-1, with your repository and dependencies installed. It takes GitHub repositories. And because the session runs there, Conductor stores its inputs and outputs on its own servers. Their docs say that plainly too. Credit where it's due.

PRCHD gives one answer. The agent runs on a computer you own. Always.

The host lives in the menu bar, not in a window you might close. Want an agent working at 3 a.m.? Give it a computer that stays awake. That's all a team host is.

Conductor rents the agent a computer. PRCHD asks you for one of yours.

That's the real tradeoff, so here it is without varnish. Conductor Cloud keeps working with every machine you own switched off. PRCHD needs one of yours switched on.

What you get in return: the repository, the transcripts and the environment values never land on anyone else's disk. PRCHD's own service does three jobs: host identity, push notifications and sealed webhooks. It stores no project, no chat, no prompt, no source code and no notification body.

One caveat applies to both, and it belongs in writing. Your agent still talks to its model provider. Neither product changes that. The question is whether the work picks up another home on the way. In Conductor Cloud, it does. In PRCHD, it doesn't.

What does your phone actually reach?

Conductor's iPhone app came with Conductor Cloud, and it drives cloud workspaces: keep agents running, review the code, check the pull request, merge. Cloud workspaces, the app and the Conductor API come with the Pro plan.

PRCHD's phone app reaches your own computer, directly, over your Tailscale network. No public port. Nothing listening on the internet. It runs on iPhone, iPad and Android.

And it's built to deliver a story, start to finish. The chat is the easy part. The job is everything around it, so the phone does all of it:

• Story. Pick one from your tracker or a GitHub issue, and start a workspace with the story as the agent's brief.
• Plan. Read the agent's plan, push back on it, and approve it with one tap.
• Review. The real diff from the worktree, syntax-highlighted. Select any line, attach a note, send it back to the agent.
• Verify. Tests, lint or build, with pass or fail inline. A real terminal. The dev server, open on your phone over your own network.
• Land. Commit message and pull request drafted by the agent, edited by you. Push, open the PR, merge.

The price of admission: Tailscale, on the computer and on the phone.

Who else on the team gets in?

Conductor's team answer is Multiplayer. People in the same Conductor organization share workspaces, follow each other's work and prompt agents together, live. Pro covers up to five people. Teams covers any size, per seat, with an admin portal and central billing.

If the goal is several engineers steering one agent together, that's the right shape.

PRCHD's team answer is a Slack channel. Install it once on a computer the team already owns, bind a channel to a project, and the people who used to interrupt engineers ask the code instead. Product, support, QA. They mention @PRCHD with the question, the agent reads the real checkout, and the answer lands in the thread, signed:

answered from payments-api @ 4f2c9ab (main) · Act mode

Nobody creates an account, installs an app or takes a seat. Membership of the channel is the whole grant. And Act mode is structural: a question can't be turned into something that writes to the repository.

One puts more engineers around the agent. The other puts the codebase in front of everyone who isn't one.

What happens when something else pulls the trigger?

Both products run work nobody typed.

Conductor calls it routines: a saved prompt that runs on a schedule or on a GitHub event. Routines run in the cloud, so they come with the Pro and Teams plans.

PRCHD calls it recipes. One recipe fires four ways: on demand, on a schedule, from Slack, or from a webhook sent by anything that can send one: GitHub, Sentry, Stripe, Slack, ClickUp. The run lands on your own computer, so the bar goes up:

• The public URL lives on PRCHD's service, which seals each delivery to your host's key and stores only ciphertext. The host collects it outbound. Nothing listens.
• A small verifier you write decides whether each delivery is rejected, ignored or run. It gets its own process and two seconds.
• The recipe fixes the posture in advance: which mode, a fresh worktree or read-only, which model, which tools. A trigger can't name its own prompt, mode or target.

When a webhook opens a door onto your own computer, a secret URL isn't enough. You want a guard behind the door.

Which agents do they run?

Conductor runs Claude Code, Codex, Cursor and OpenCode. PRCHD runs Claude Code, Codex and Grok. Both run each vendor's own agent, signed in with your own subscription or keys.

Need Cursor or OpenCode? Conductor. Need Grok? PRCHD. That one's easy.

Side by side

	Conductor	PRCHD
Built around	The desk: one Mac app steering many agents	Leaving it: phone, iPad and Slack in front, your computer behind
Where agents run	Your Mac, or managed cloud sandboxes with Conductor Cloud	A computer you own
Keeps working when you walk away	In cloud workspaces. Local sessions end when the app closes	On your computer, while it's awake
Isolation	One git worktree and branch per workspace	One git worktree, branch and agent session per workspace
Agents	Claude Code, Codex, Cursor, OpenCode	Claude Code, Codex, Grok
Phone	iPhone app for cloud workspaces	iPhone, iPad and Android, straight to your own computer, from the story to the pull request
Team	Multiplayer: shared workspaces for members of a Conductor organization	Slack: anyone in a bound channel asks the codebase, and the channel is the whole grant
Automation	Routines on a schedule or a GitHub event, run in the cloud	Recipes on demand, on a schedule, from Slack or from a webhook. Sealed deliveries, your own verifier, run on your computer
What the vendor stores	Local: nothing from your sessions. Cloud: session inputs and outputs on Conductor's servers	Host identity, push forwarding and sealed webhook ciphertext. No code, prompts, diffs or chat
Repositories	Any, locally. GitHub in the cloud	Any git repository on your computer. Pull requests through GitHub
Needs	macOS. Pro plan for cloud, the phone app and the API	macOS on Apple Silicon. Tailscale for the phone. Slack for the team lane

So which one should you use?

Pick Conductor if:

• You spend the day at your Mac and want one desktop app steering many agents at once.
• You want agents to keep going with every computer you own switched off, and a managed cloud sandbox suits your code.
• Several engineers want to steer the same agent together, live.
• You need Cursor or OpenCode.

Pick PRCHD if:

• The repository has to stay on hardware you own, whether that's policy, a client contract or principle.
• You want to take a story from the tracker to a pull request on your phone, on iPhone, iPad or Android, against your real checkout.
• Product, support and QA should ask the code in Slack, without a seat each.
• Automations and webhooks should run on your own computer, behind a verifier you wrote.
• You want Grok.

So which bet is right?

Here's mine, stated plainly, because I built it.

The agent was never the thing that needed to travel. The job around it was. Which story, which plan, whether the diff is right, when the pull request opens: those calls are mine, and none of them needs a desk. So I moved the desk, and left the code where it was.

Conductor made the other bet, and built it well. If a managed sandbox suits your code, it's a good bet.

PRCHD is for the code that doesn't leave the building.