How do I run several Claude Code agents in parallel without supervising each one?
By Soumen Sarkar · October 2026
Short answer: Give each parallel Claude Code session one clear goal, the context it needs when it starts, and a standing instruction to state assumptions and keep going instead of stopping to ask. Then check on the sessions through what they leave behind, their assumptions and handoffs, rather than by watching each terminal.
Why do parallel sessions need supervising?
Mostly because they stop. A session hits something unclear, asks, and waits until you switch back to its terminal. With four sessions running, you spend the morning cycling between windows to unblock them, and the sessions spend most of it idle.
The rest of the supervision is checking that sessions don't trip over each other or over a teammate's work. Giving each session its own git worktree keeps them out of each other's files; it doesn't keep them out of each other's way (see do git worktrees stop parallel agents conflicting?). Both problems shrink when each session knows more at the start and asks less on the way.
How do I set each session up to run on its own?
- One session, one goal, one area. Give each session a goal you could write in one line, and keep it to one part of the code. A separate git worktree per session keeps their files apart.
- Context at the start. Each session should begin knowing what is in progress around it, the decisions that stand in its area and anything handed to it. Put stable instructions in CLAUDE.md and load the changing state when the session starts.
- A rule for unknowns. Tell every session what to do when something is unclear, so it never needs you to answer:
When something is unclear, look in the code and the team's notes first.
If the answer isn't there, choose the most reasonable option, write
"Assuming <X> because <reason>.", and keep going.
Stop only before an action that can't be undone.
- A handoff when it stops. Ask each session to finish with what is done, what is left, the next step and what it assumed.
What does a morning with four sessions look like?
You are working on a mobile app. Session one adds dark mode to Mobile · app/screens/settings. Session two changes when the app asks for notification permission. Session three adds an offline cache for the feed. Session four fixes a crash on older Android versions.
Session two isn't sure whether to ask for permission after sign-up or after the first saved item. It assumes after the first saved item, because the prompt makes more sense once there is something to be notified about, and it keeps going. Session three finds the feed's data layer half-migrated and notes it in its handoff rather than stopping. By lunch, three sessions have finished and one has a clear next step. You read four short summaries and one assumption, and correct nothing.
How do I check on them without watching them?
Read what they leave, not what they do. A useful check takes a few minutes: the list of assumptions, highest stakes first; each handoff's next step; and anything that touched the same files as another session. You correct what is wrong and start the next round of goals.
What does Campfyrr automate here?
In Claude Code, Campfyrr's hooks do the setup for you. Each session starts with a brief of the team's state, with your own unfinished work and handoffs to you at the top. Its first request becomes the one-line goal of its work in progress, visible to the team. When it stops or compacts, a handoff is written from the session. Assumptions go to whoever can settle them, and corrections arrive at the session's next turn.
Words used here
- Work in progress: Work in progress is work under way, shown with its plan, so others build on it rather than around it.
- Assumption: An assumption is the best available answer to an unknown, stated and acted on, kept visible so anyone can correct it.
- Handoff: A handoff is what unfinished work carries for whoever continues it: what's done, what's left, the next step, and what to watch out for.
The principle behind this: Keep moving: The work never waits, and neither do we.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).