Quick answer
Give each agent its own sandbox so they can't clobber each other: a git worktree per task, a separate repo per terminal, or subagents inside one session. Then route every agent's hooks to one monitor so you see all statuses at once and only step in when an agent is actually waiting on you.
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.
The mental model that helps: think of each agent like a separate teammate. You'd never have two people committing to the same uncommitted working copy at once. Give each one an isolated place to work and the chaos disappears.
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.
Worktrees share the same .git, so they're cheap to create and tear down — no full re-clone, no duplicated history. Keep them as sibling folders next to your main checkout (../app-auth, ../app-tests) so they're easy to find and git worktree list stays readable.
A few things worth knowing: each worktree is on a distinct branch (git won't let two worktrees check out the same branch), and per-directory artifacts like node_modules or build caches aren't shared, so a fresh worktree may need its own npm install before an agent can run tests there.
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.
So the three patterns layer rather than compete: subagents give you parallelism inside one task, while worktrees and separate repos give you parallelism across tasks. Most real workflows end up using both.
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.
Hooks are the key primitive here. Each Claude Code session fires events like Notification (waiting on input) and Stop (finished) — so a monitor can tell the difference between "still working," "needs a decision," and "done" without you reading a single terminal. See the complete guide to Claude Code hooks for the full event list.
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.
To be clear about what Agentfy does and doesn't do: it's monitoring-only. It never runs agents, sends keystrokes, or approves prompts for you — it just reads the hook events your terminals emit and surfaces their status. You stay in control of every agent; Agentfy just makes sure the right one gets your attention at the right moment. The Live Activities and Dynamic Island view is where the multi-agent rollup really shines, collapsing four terminals into one glanceable line.
Stop babysitting your terminal
Agentfy pushes Claude Code status to your iPhone — Live Activities, Dynamic Island, and instant alerts.
Setup takes under a minute and is the same whether you're monitoring one agent or ten: install the open-source Agentfy plugin — it stores your token in your OS keychain and wires up the hooks for you (or paste the setup prompt, which still works on older Claude Code). No CLI wrapper, no proxy, nothing sitting between you and Claude — just hooks pointed at a webhook. Each new terminal or worktree you spin up reports in automatically. Agentfy runs on iOS 18+; the free tier covers 25 notifications a month, and Pro unlocks unlimited notifications plus Live Activities — which is what you'll want once you're regularly running several agents at once.
A sane parallel workflow
- Split the work into independent tasks with no shared files.
- Give each one isolation — a worktree or a separate repo.
- Start an agent in each.
- Route every agent's hooks to one monitor so you see all statuses in a single place.
- 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.
If notifications aren't coming through from one of your terminals, the most common culprit is a hook that didn't get wired into that project — see notifications not working for the quick fixes, and the full features overview for what the dashboard tracks.