---
url: https://clusto.app/docs/run-multiple-claude-code-sessions.md
description: >-
  How to run multiple Claude Code sessions in parallel without edit conflicts:
  terminals, tmux, git worktrees, agent teams, and Clusto across several
  machines.
---

# How to Run Multiple Claude Code Sessions in Parallel

To run multiple Claude Code sessions in parallel, give each session its own
checkout of the repository and a place to keep running. The usual recipe is one
git worktree per task, one `claude` process per worktree, and something to hold
the processes: terminal tabs, tmux, or a session manager such as Clusto, which
keeps every session on a daemon and shows them side by side from your desktop,
phone or browser. Claude Code's own subagents and agent teams cover parallel
work inside a single session.

This guide goes through each option, then shows how Clusto handles it.

## Option 1: several terminal windows

Open two terminals, `cd` into the project in each, and run `claude`. It takes
no setup. The catch is that both sessions edit the same working tree, so one
agent's half-finished change breaks the other's test run, and both may touch the
same file. It also ends when you close the terminal or the laptop sleeps.

## Option 2: tmux

tmux keeps sessions alive after you disconnect and splits one terminal into
panes:

```bash
tmux new -s agents
# run claude, then split with Ctrl+B % and run claude again
tmux attach -t agents   # later, from another SSH session
```

That fixes persistence on a server. It does not fix the shared working tree,
and tmux has no idea when an agent is waiting on a permission prompt. See
[A tmux Alternative for AI Coding Agents](/tmux-alternative-for-ai-agents).

## Option 3: git worktrees

A worktree is a second checkout of the same repository on its own branch. Give
each session one and the edits stop colliding:

```bash
git worktree add ../myapp-auth -b feature-auth
cd ../myapp-auth && claude
```

**Last reviewed: November 20, 2026.** Claude Code has this built in.
[Common workflows](https://code.claude.com/docs/en/common-workflows#run-parallel-sessions-with-worktrees)
shows `claude --worktree feature-auth`, which starts an isolated session in a new
worktree; run it with another name in a second terminal for a second session.
Cleanup is covered under [Worktrees](https://code.claude.com/docs/en/worktrees).

Each worktree still needs its own dependencies installed, and if your app binds
a fixed port or uses one local database, two sessions running the app at once
will fight over them.

## Option 4: subagents and agent teams

Claude Code can parallelize inside one session:

* **Subagents** run focused tasks in their own context window and report a
  result back to the main agent. See
  [Subagents](https://code.claude.com/docs/en/sub-agents).
* **Agent teams** coordinate several Claude Code instances with a lead, a shared
  task list and direct messages between teammates. The
  [agent teams docs](https://code.claude.com/docs/en/agent-teams) mark them as
  experimental and disabled by default, enabled with
  `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`. They list limits that matter here:
  one team per session, no nested teams, `/resume` does not restore in-process
  teammates, and split-pane mode needs tmux or iTerm2. They also warn that teams
  use significantly more tokens than a single session and suggest starting with
  3 to 5 teammates.

These are good when one agent should split up a job. They still run inside the
lead's process on one machine, so they stop when that process does.

## Option 5: a session manager

A session manager runs the sessions for you and gives you one view of them.
Conductor does this on macOS with a workspace per task; see
[Conductor Alternative](/conductor-alternative) for how it compares. Clusto does
it on Linux and Windows machines and keeps the sessions on a daemon, covered
below.

## How Clusto runs parallel Claude Code sessions

### Every session lives on a daemon

Install the daemon (`clustod`) on the machine that should do the work:

```bash
curl -fsSL https://dl.clusto.app/install.sh | sh
```

Then connect the desktop app, the Android app or the web app. Each
**New Session** with the **Claude agent** preset starts another Claude Code
process on that node. Sessions keep running when every client is closed, and any
client reattaches to them. Setup details are in
[Run Claude Code on a Server or VPS](/run-claude-code-on-a-server) and
[Downloads and Installation](/downloads).

From a shell on the node you can start sessions in separate worktrees you
created yourself. The CLI streams output but does not forward keystrokes, so you
type into them from the app:

```bash
clusto open --dir /srv/myapp-auth --shell claude --name "auth"
clusto open --dir /srv/myapp-billing --shell claude --name "billing"
clusto ls
```

### Watch them side by side

The **Terminals** view splits into panes: `Alt+Shift+=` splits right,
`Alt+Shift+-` splits down, `Alt+Arrow` moves focus and `Ctrl+Shift+M` maximizes
one pane. A pane is only a view, so closing it leaves the session running. See
[Terminal Workspace](/terminal-workspace).

Each session row shows what its agent is doing: a spinner while it works, a green
check when the turn is done, and an amber `?` when Claude waits for an answer.
**Go to next waiting session** in the `F1` palette cycles through the ones that
need you. See [Agent Waiting Marker](/agent-attention).

### Or as chats

A [Chat](/chats) runs Claude Code headless with a conversation view, approval
cards and queued messages. The Chats view splits into panes with the same keys,
and `Ctrl+Shift+D` splits the focused pane and starts a new chat in the same
workspace. You can mix providers: Claude, Codex, OpenCode or OpenRouter.

### Let a team split the work in worktrees

A Clusto [team](/teams) is a leader plus workers, each a headless Claude, Codex,
OpenCode or OpenRouter agent. Workers spawned with `assign` or `handoff` get an
isolated git worktree under `.clusto/worktrees/<worker-id>`, a private port
range and a database name of their own, which covers the two conflicts worktrees
alone leave open. At most five workers are active at once; extra assignments
queue until a slot frees up.

```bash
clusto team create --name review-team --working-dir /srv/myapp
clusto team ls
clusto team assign <TEAM_ID> --prompt "Write tests for the billing module"
clusto team assign <TEAM_ID> --prompt "Fix the flaky login test" --agent codex
clusto team wait <TEAM_ID> --timeout 600
clusto team merge <TEAM_ID>            # preview
clusto team merge <TEAM_ID> --apply    # merge worker branches
```

Teams persist across daemon restarts and are visible in the **Teams** view and
in the **Agents** tab beside the chat or session that started them. The full
command list is in the [CLI reference](/cli#clusto-team-manage-agent-teams), and
the coordination model in [Teams Autopilot](/teams-autopilot).

### Spread sessions over several machines

When one box runs out of CPU or memory, add another. Up to about five nodes form
a leaderless [cluster](/clustering) and the app lists sessions from all of them.
A project can be pinned to a node, and `clusto team create --node <NODE_ID>`
runs a team on another machine (node ids come from `clusto cluster-status`).
Each session stays on the node that started it.

## Tips that save time and tokens

* One task per worktree. Two agents in the same files will overwrite each other
  whatever tool you use.
* Keep tasks independent. Parallel sessions help with separate modules,
  reviews and investigations, less with a chain of dependent steps.
* Watch your plan limits. Every session signed in to the same account draws on
  the same usage. Clusto's chat status line shows the 5-hour and weekly limits.
* Review before merging. Preview with `clusto team merge` before `--apply`, or
  check each branch in the [git panel](/git-panel).

## FAQ

### How many Claude Code sessions can I run at once?

There is no fixed number for separate sessions; CPU, memory and your plan's
usage limits set it. A Clusto team runs at most five active workers and queues
the rest. Anthropic suggests 3 to 5 teammates for agent teams.

### Can two Claude Code sessions work in the same repository?

Yes, if each has its own git worktree. Use `git worktree add`,
`claude --worktree <name>`, or a Clusto team, which creates one per worker.

### What is the difference between subagents, agent teams and parallel sessions?

Subagents report back to one main agent. Agent teams are several Claude Code
instances coordinated by a lead inside one session. Parallel sessions are
independent `claude` processes that you or a session manager run side by side.

### Can I run Claude Code and Codex in parallel?

Yes. In Clusto, terminal sessions run any CLI, chats support Claude and Codex
as providers, and a team can mix Claude and Codex workers.

### Is Clusto free?

Clusto requires a license. The Personal plan is free for one user on up to three
devices, and split panes are included. See
[Accounts and Licensing](/accounts-licensing).
