How to Run Multiple Claude Code Agents in Parallel

One Claude Code agent is useful. Three or four working in parallel is a different kind of leverage — one refactoring auth while another writes tests while a third chews through a migration. The catch: the more agents you run, the more time you spend tabbing between terminals trying to figure out which one is stuck.

Here's how to actually run multiple Claude Code agents at once without it turning into chaos — the isolation patterns that keep them from stepping on each other, and how to keep track of all of them.

Why not just open more terminals?

You can — and for read-only or research tasks, separate terminal tabs in the same repo are fine. The problem is write conflicts. Two agents editing the same working tree will clobber each other's changes, trip over half-written files, and produce git diffs that make no sense. Parallelism only works cleanly when each agent has its own sandbox.

Pattern 1: Git worktrees (the clean one)

A git worktree gives each agent its own checkout of the same repo on its own branch, sharing one .git. They can't collide because they're editing different directories.

# one worktree per task
git worktree add ../app-auth   -b feat/auth
git worktree add ../app-tests  -b feat/tests
git worktree add ../app-migrate -b feat/migrate

# then run an agent in each
cd ../app-auth   && claude
cd ../app-tests  && claude
cd ../app-migrate && claude

Each agent works on its branch, you review and merge independently, and nothing overlaps. When you're done, clean up with git worktree remove.

Pattern 2: Separate projects, separate terminals

The simplest case is when your agents are working on genuinely different repos — a frontend, a backend, a scripts folder. Here you just need one terminal per project. No worktrees required; the isolation is already there. The only thing missing is a single place to see all their statuses at once.

Pattern 3: Subagents inside one session

Claude Code can also fan out work to subagents within a single session — useful when one task naturally decomposes (search five directories in parallel, then synthesize). This is parallelism you don't manage by hand; Claude orchestrates it. It's great for breadth inside one job, but it's not a substitute for running independent agents on independent features.

The real bottleneck: knowing which one needs you

Once you're running three or four agents, the hard part isn't starting them — it's the constant context-switching to check on them. You alt-tab to terminal one: still cooking. Terminal two: finished four minutes ago. Terminal three: been waiting on a permission prompt the whole time. That polling is pure overhead, and it gets worse with every agent you add.

The fix is to invert it: instead of you checking on the agents, have the agents report to you. Claude Code hooks fire on every state change, so you can route all of them to one consolidated view and only look when something actually changes.

One dashboard for every terminal

This is exactly what Agentfy is built for. Point every agent's hooks at it and you get one screen showing all of them — which are cooking, which need you, which just finished — across unlimited terminals and projects. On iPhone, Live Activities roll it up into a single lock-screen line: "2 cooking · 1 needs you."

The moment any agent stops for input, you get a push naming the one that needs you. Run as many as you want; you only spend attention when attention is required. More on the mobile side in Claude Code on iPhone: the complete guide.

A sane parallel workflow

1. Split the work into independent tasks with no shared files.
2. Give each one isolation — a worktree or a separate repo.
3. Start an agent in each.
4. Route every agent's hooks to one monitor so you see all statuses in a single place.
5. Go do something else. Come back only when you're pinged, review each branch, and merge.

That's the difference between running four agents and being run by four agents.