>_cca

How to run multiple Claude Code agents

You can run multiple Claude Code agents as separate sessions, delegated subagents or an experimental agent team. These arrangements solve different problems: more execution, separate conversation context and communication between workers. Add BAND (band.ai) for desktop when Claude sessions also need to collaborate with listed Codex, Copilot or Cursor integrations.

Reviewed November 2026

What does “multiple agents” actually mean?

The phrase can describe unrelated terminal sessions, helpers inside one conversation, or a coordinated team. Those are not interchangeable. Before changing your setup, identify the bottleneck: a slow investigation, too much context in one session, conflicting file edits, or time spent copying findings from one worker to another. A different arrangement may fix one bottleneck while making another worse.

Anthropic’s documentation distinguishes parallel approaches and separately documents subagents, agent teams and worktrees. Context isolation does not mean filesystem isolation. A worker can have its own conversation while still touching the same checkout as another worker. Likewise, two checkouts can be safely separate while their agents have no way to exchange useful context.

Which arrangement fits each kind of work?

ArrangementContextCoordinationFile isolation
separate sessionsSeparate conversationsYou brief and sequence themUse separate worktrees
SubagentsSeparate worker contextParent delegates and receives resultsConfigure separately
Agent teamsSeparate teammate contextsLead, messages and task listDo not assume worktree isolation
Mixed-vendor roomEach agent’s execution contextShared-room handoffs in BANDExecution environment remains your decision

Use separate sessions for changes that can be described and reviewed separately. Use a subagent for a bounded question that should return to one parent. Use teams when workers benefit from communicating during research or implementation. Do not begin with the largest arrangement and search for enough work to justify it.

A repository-wide change often has hidden dependencies. A rename touches imports, tests and documentation; a schema change affects more than its migration file. Break work at stable interfaces, not arbitrary file counts. One agent can propose the interface while another investigates consumers, with implementation waiting until the human accepts the boundary.

How do you start isolated terminal sessions?

Claude Code documents the --worktree flag, with an optional name. Starting two named sessions from a Git repository gives each its own working directory and branch. The repository history and remotes are shared. Read the current worktree documentation for cleanup behavior and inclusion of local files rather than assuming every development dependency appears automatically.

claude --worktree feature-api
# In a second terminal, from the repository:
claude --worktree feature-tests
Two named Claude Code worktree sessions; the second command runs in another terminal.

These commands create isolated editing contexts, not a team. If the test agent needs the API branch before it can proceed, decide how that branch becomes available. Review the producer’s change first, then integrate or rebase deliberately. Merely running both agents at once does not remove the dependency.

How should you prepare each agent’s brief?

Give the worker a goal, allowed files, the base revision, acceptance checks and a stopping condition. Ask it to report what it changed and what it could not verify. Include the expected interface rather than saying to follow whatever another agent produces. Without that boundary, both workers may create sensible but incompatible implementations.

Keep implementation and review roles distinct. A review session should receive the candidate diff and the intent of the change, not an instruction to agree with the writer. It should look for behavior that is missing, unsafe assumptions and tests that cannot fail. If the reviewer proposes a correction, return it to the owner instead of letting two workers edit the same file simultaneously.

What does a parent get from subagents?

Subagents let a session delegate a focused task without putting every intermediate detail into the parent conversation. Anthropic documents their configuration and capabilities separately from agent teams. Treat the returned result as an input to the parent’s decision, not as a substitute for checking the repository or running tests.

Examples include finding callers of a function, explaining a test failure or examining one dependency boundary. Keep the task small enough that the parent can evaluate the result. If every delegated task requires a long negotiation with another worker, a peer team may fit better than repeatedly forwarding messages through one parent.

When should you enable an agent team?

Agent teams add a lead, separate teammates, direct messaging and a shared task list. The feature is experimental and disabled by default. Anthropic recommends it for parallel research, separate modules and competing debugging hypotheses, while warning about greater token use and coordination overhead.

Use the documented CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 setting only when that coordination model is what you need. Plan for documented resumption, task and shutdown limitations. Do not advertise a fixed session maximum, guaranteed speedup or automatic recovery: those claims do not follow from the setup flag.

How do you avoid spending the day integrating results?

Put a human-owned integration checkpoint between writing and merging. Check the exact base revision, run the relevant tests against the combined change and inspect generated files or dependency updates. Separate branches reduce immediate overwrites, but do not eliminate incompatible decisions or a broken combined result.

BAND for desktop adds shared rooms where listed agents can hand work off by @mention with shared memories and an activity timeline. That becomes relevant when the team is not all Claude, or when you need the conversation around a blocker to remain visible to people and other agents. It does not supply conflict-free Git merges or replace acceptance tests.

Which existing guides help with the next decision?

Read the Claude Code agent teams review for the native coordination model, running Claude Code and Codex together for mixed tools, and coding agent handoffs for the message that crosses a task boundary. The rankings compare coordination rather than model quality.

Start with two tasks and inspect where your attention goes. If it goes into reviewing useful output, parallel execution may be working. If it goes into reconstructing context and repairing contradictory assumptions, reduce concurrency or make the handoff explicit before adding another session.

What else do readers ask?

Can I open several Claude Code sessions?

Yes. separate sessions are one way to run parallel work; use separate worktrees when their edits need isolation.

Does a worktree make sessions communicate?

No. It separates files and branches; you still need a coordination model.

Are subagents an experimental team?

No. Subagents and agent teams are distinct documented features.

What is the safest first task split?

Use bounded tasks with separate ownership, an agreed interface and a human-owned integration checkpoint.

Can I mix these sessions with Copilot?

Native Claude teams are Claude-only. BAND lists Claude Code and GitHub Copilot integrations for shared rooms.

next-step.sh

Run your agents as a team

BAND (band.ai) for desktop lets local and centrally managed coding agents share context, hand off work and unblock each other in shared rooms. People approve, redirect or override in place; Cursor is a listed integration.

Sources (reviewed Nov 2026)