# Run Claude Code agents in parallel on separate machines

> Give each Claude Code agent its own machine, branch and tmux session, pushing to one remote. Cloud sessions, Codespaces, Prized, boxd and shedix compared.

*2026-11-10 · agents, claude-code, workflows, remote-dev*

To run several Claude Code agents in parallel on separate machines, give each agent a machine of its own, a git branch of its own and a tmux session, and have all of them push to one remote where you review. The quickest way to get there is to set up one machine properly and copy it once per agent, so every copy starts with your code, your tools and your sign-ins.

You can use Anthropic's cloud sessions when Claude Code on a GitHub repository is all a task needs, fork boxes on Prized or boxd, or let your agent do it on [shedix](/), which copies a signed-in machine once per task. If one machine is enough for you, our post on [running parallel agents with git worktrees](/blog/parallel-coding-agents-git-worktrees) covers that layout. This one is about separate machines.

We make shedix. Every other figure comes from each provider's own pages, linked, as of 2026-11-10.

## Why give each agent its own machine?

Worktrees solve the file problem: each agent gets its own folder and branch. A machine per agent solves the rest.

- **Ports.** Two dev servers want port 3000, and two test databases want 5432. On separate machines both can have them.
- **CPU.** Every agent brings a type checker, a test runner and often a browser. [Playwright](https://playwright.dev/docs/test-cli) alone uses half your cores by default, so agents sharing a machine slow each other down. On their own machines, each gets all of its cores.
- **Shared state.** One machine means one Docker daemon and one local database. An agent that wipes a volume changes it for everyone. Separate machines give each agent its own.
- **Blast radius.** On a machine of its own, a bad `rm -rf` or a runaway process costs one task, not the others, and never your laptop.
- **Your laptop.** When it sleeps, every agent on it stops at once. Machines in the cloud keep going.

## Can't I just use git worktrees on one machine?

Often, yes. Anthropic's [parallel agents guide](https://code.claude.com/docs/en/agents) lists worktrees as the way to keep sessions you run yourself from editing the same files, and `claude -w <name>` makes one per session. For a few agents doing light work on one repository, one bigger machine with a worktree each is simpler than several machines. Move to separate machines when the agents need the same ports or services, when their builds compete for CPU, or when you want one agent's mistakes kept away from the others.

## What does the setup look like on each machine?

The pattern most guides describe, wherever the machines come from:

1. **One machine per agent.**
2. **Set each one up:** install your tools and Claude Code, clone the repository, and sign in to Claude Code and `gh`. A snapshot saves repeating the installs.
3. **One branch per agent:** `git switch -c agent/search` on each machine.
4. **Start Claude Code in tmux**, named after the task, so it survives your SSH connection dropping: `tmux new -s search 'claude'`.
5. **Push and review:** each agent pushes its branch, and you merge from pull requests.

To check on them from your phone, start each session with `claude --remote-control "search"`. Each one then appears by name in the Claude app ([Remote Control docs](https://code.claude.com/docs/en/remote-control)). The same connection lets sessions message each other: Anthropic's [cross-session messaging](https://code.claude.com/docs/en/cross-session-messaging) reaches sessions on your other machines through Remote Control, so one agent can tell another that a schema changed.

The costs are setup and idle time: every machine needs the same installs and sign-ins, and a machine that keeps billing while it waits costs full price between tasks. The services below each handle those two costs differently.

## What about Codespaces or Anthropic's cloud sessions?

**Anthropic's cloud sessions** are built for handing Claude Code a well-defined task on a GitHub repository. Each `claude --cloud "task"` starts its own session on its own VM, and they run at the same time ([cloud session docs](https://code.claude.com/docs/en/claude-code-on-the-web)). They draw on your plan's usage limits. Cloning needs GitHub, you get no shell into the VM, and an idle session pauses after a few minutes ([environment docs](https://code.claude.com/docs/en/cloud-environments)). If a task needs nothing beyond Claude Code and the repository, they fit; we compare the two in [cloud sessions or your own machine](/blog/claude-code-cloud-sessions-or-your-own-machine).

**GitHub Codespaces** is built for opening a branch in VS Code without setting up a laptop. Each codespace is a container with a shell; a 2-core one is $0.18 an hour ([billing docs](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces)). It stops after 30 minutes idle by default, at most 4 hours ([timeout docs](https://docs.github.com/en/codespaces/setting-your-user-preferences/setting-your-timeout-period-for-github-codespaces)). Saved files survive a stop, running processes don't ([lifecycle docs](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle)), and you sign in to Claude Code again in each new codespace.

## What do Prized and boxd do?

Both can copy a machine for you, each built for a different job.

**[Prized](https://prized.dev/docs/parallel-agents.md)** is built around boxes: Ubuntu VMs whose project folder syncs to your laptop. Its parallel-agents guide covers both layouts, one big box with a worktree per agent, or a box per agent made with `prized fork`.

**[boxd](https://boxd.sh)** is built around forking a running VM on bare metal, and bills for the vCPU a machine actually uses. Its machines hibernate after 4 hours without traffic and wake with their processes intact ([pricing](https://boxd.sh/pricing/)).

## How does shedix run agents on separate machines?

Every shedix machine is a real computer of its own: a whole Linux virtual machine with a full desktop, root, Docker and its own public address, with Claude Code, Codex and VS Code in the browser ready to use. Machines run in the United States. For parallel work, you don't set anything up by hand: your agent starts one machine, sets it up, and copies it once per task ([a machine per agent](/use-cases/many-at-once)):

1. **The source machine** gets the project, with its git history and anything it needs installed.
2. **Each copy** starts from the source's whole disk: code, installed packages and every sign-in on it (Claude Code, Codex, `gh`, Docker, cloud CLIs), so nothing needs installing or signing in again. Each copy gets its own name, address and SSH host keys. [Copying an agent's machine](/blog/copying-an-agents-machine-clones-and-snapshots) explains how.
3. **On each machine** the agent makes a branch named after the task and starts Claude Code in tmux with Remote Control on, so every session shows up in the Claude app under its task's name. You can also open any of them from a browser, your phone or SSH.
4. **When a task is done**, its session commits, pushes if the machine is connected to GitHub, and runs `shedix sleep` as its last step. Each machine stops being charged for running the moment its own task ends.

Each machine sits on an isolated network, walled off from your others, so one agent's mistake can't reach another's machine. They share work the way a team does, through your git remote.

A sleeping machine keeps everything, running programs included, wakes in under a minute and costs cents a day, so a machine you'll want again tomorrow can simply sleep instead of being deleted and rebuilt. While it runs, you pay by the second, from $0.09/hr for 2 vCPU, 4 GB RAM, 30 GB disk. Every machine and the account limits are on the [pricing page](/pricing).

The steps above are written into [the agents' guide](/docs/agents), so Claude Code, Codex or Cursor can do them for you from one sentence.

## What does a machine per agent cost?

Five agents means five machines, so the hourly rate and the idle rate both get multiplied. Here is the same box on each option that publishes a rate, as of 2026-11-10. boxd bills only the vCPU and memory a machine actually uses ([boxd pricing](https://boxd.sh/pricing/)), so its row is the price at full use; an agent that waits on a model most of the hour pays less.

| The same box, running for one hour | 2 vCPU, 4 GB | 4 vCPU, 8 GB | 8 vCPU, 16 GB | 16 vCPU, 32 GB |
|---|---|---|---|---|
| shedix, disk included | $0.09/hr (30 GB) | $0.21/hr (45 GB) | $0.42/hr (60 GB) | $0.84/hr (75 GB) |
| [boxd](https://boxd.sh/pricing/), at full use | €0.126 ($0.14) | €0.252 ($0.28) | €0.504 ($0.56) | €1.008 ($1.13), on its Scale plan |
| [GitHub Codespaces](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces), twice the memory, plus storage | $0.18 (2-core, 8 GB) | $0.36 | $0.72 | $1.44 |

Rows are ordered by the 2 vCPU price; euros are converted at the [ECB rate](https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html) of $1.1193. Anthropic's cloud sessions have no hourly rate: they draw on your Claude plan's usage limits. Running, shedix comes out 25–36% below boxd at full use and 42–50% below Codespaces, disk included; that's $0.0450 per vCPU-hour at 2 vCPU and $0.0525 from 4 vCPU, memory and disk in the price.

Prized sells monthly plans rather than hourly use ([Prized billing](https://prized.dev/docs/billing)): from $10 to
$1,000 a month, paid each cycle and turned into credit that boxes spend by the second. A 2 vCPU / 4 GB Micro box draws
$0.034 an hour from that credit, and the plan that runs one around the clock is $25 a month; unused credit carries over
for up to two months.

The shedix price covers the disk, Ubuntu with root and Docker, Claude Code, Codex, VS Code in the browser, previews, SSH, by the second with no plan.

The idle rate matters as much, because most of an agent's machines sit waiting between tasks:

| Idle for one hour, 2 vCPU and 4 GB | What you pay | What's kept |
|---|---|---|
| boxd, hibernated | €0.0024 ($0.0027) for 30 GiB written | Processes intact |
| Codespaces, stopped | $0.0031 for its 32 GB disk | Saved files, not processes |
| shedix, asleep | $0.006/hr | Everything, running programs included |
| Prized Micro, asleep | $0.008 for its 80 GB disk | Processes, through a pause of up to 3 days |

Asleep, a shedix machine costs 25% less than a Prized Micro box, with every running program kept, so leaving five agents' machines asleep overnight costs cents.

## How do the options compare?

As of 2026-11-10, for the jobs an agent's home has to do:

| Option | What each agent gets | Setup to a working agent machine | A machine per agent | When idle | What survives a stop | How you reach it |
|---|---|---|---|---|---|---|
| Worktrees on your laptop | A folder; CPU, ports and Docker shared | `claude -w` per session | No, one machine | Stops when the laptop sleeps | Everything | Your laptop |
| [GitHub Codespaces](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle) | A container with a shell | A `devcontainer.json`; sign in to Claude Code in each codespace | New codespace per branch; sign in each time | Stops after 30 min by default (up to 4 h) | Saved files, not processes | Browser, VS Code |
| [Anthropic cloud sessions](https://code.claude.com/docs/en/cloud-environments) | Claude Code on a managed VM, no shell | None beyond a GitHub repository | Yes, `claude --cloud` per task | Pauses after a few minutes; may be reclaimed | Conversation and files, not running commands | claude.ai, the Claude app |
| [Prized](https://prized.dev/docs/parallel-agents.md) | An Ubuntu VM; the project folder syncs to your laptop | Set up one box from its CLI | `prized fork` | Auto-pauses ([limits](https://prized.dev/docs/limits.md)) | Processes through a pause of up to 3 days on small boxes | `prized ssh` from its CLI |
| [boxd](https://boxd.sh/pricing/) | A VM on bare metal | Install its CLI, sign in, `boxd m new` | Fork a running VM | Hibernates after 4 h without traffic | Processes intact | SSH, CLI, web console |
| [shedix](/pricing) | A whole Ubuntu VM: root, Docker, Claude Code, Codex, VS Code | One click, or one line to your agent | Copy, with every sign-in: ready to work | Sleeps when unused, $0.006/hr for 2 vCPU | Everything, running programs included | Browser, phone, SSH, your agent |

## Which should I pick?

- **A few light tasks on one repository:** worktrees on one bigger machine, with a branch and a folder for each agent.
- **Claude Code only, on a GitHub repository, with no tools of your own:** Anthropic's cloud sessions, one per task.
- **A project folder synced to your laptop, or forking a VM mid-run:** Prized and boxd are built for those jobs.
- **A real computer per agent:** shedix. Each copy is a whole machine with a desktop, root, Docker, its own address and every way in; your agent starts, drives and copies them, and can move the conversation it's in onto one; a shared browser and Claude Code come ready, and each pays only while it works.

## Try it on shedix

Prices and limits change, so check each provider's own pricing before you choose. On shedix, install the skill with `npx skills add shedix-dev/skills` ([shedix skills](/skills)), then tell your agent "split these tasks across shedix machines, one each". [Who makes shedix](/about) and [how machines are kept apart](/security) are on their own pages. Your first 12 hours of compute are on us.