# How to run multiple Claude Code sessions at the same time

> To run multiple Claude Code sessions at the same time, give each session its own git worktree: a separate folder and branch of the same repository. Manually, you run `git worktree add` per task and start `claude` in each folder from its own terminal tab. Tallos automates this: every new workspace is a worktree with its own Claude Code session, side by side, with a diff review for each.

- Canonical: https://runtallos.com/learn/run-multiple-claude-code-sessions
- Português: https://runtallos.com/pt/aprenda/rodar-varias-sessoes-do-claude-code.md
- Updated: 2026-09-29
- Section: Learn

## Key facts

- One session per worktree: no shared files, no shared branch
- Manual: `git worktree add` + one terminal tab per session
- Tallos: one click per workspace, split panes, per-workspace diff
- All sessions share your Claude plan's usage limits

## Can you run multiple Claude Code sessions at the same time?

Yes. [Claude Code](https://runtallos.com/integrations/claude-code) is a CLI, so you can start as many `claude` processes as your machine and your plan allow. The catch is the folder. Two sessions in the **same working directory** edit the same files on the same branch, and they overwrite each other. The fix is to give every session its own working directory, and the clean way to do that is a **git worktree**.

- **Same files:** session A rewrites `auth.ts` while session B is halfway through editing it.
- **Same branch and index:** one session's `git add` or `git stash` sweeps up the other's changes.
- **Same build output:** tests, dev servers and lockfiles collide.
- **Unreadable history:** you cannot tell which change came from which prompt when you review.

## How do I run multiple Claude Code sessions manually with git worktrees?

Create one worktree per task, then open one terminal tab per worktree and start Claude Code in each. Each worktree is a full checkout on its own branch, sharing the same `.git` history.

```bash
# from the root of your repo
git worktree add ../myapp-auth -b feat/auth-flow
git worktree add ../myapp-tests -b test/checkout

# terminal tab 1
cd ../myapp-auth && npm install && claude

# terminal tab 2
cd ../myapp-tests && npm install && claude

# see what you have
git worktree list
```

1. Copy the gitignored files each session needs (`.env`, local config) into every worktree, and install dependencies there.
2. Give each session a different port if it runs a dev server.
3. Review each branch with `git diff main...feat/auth-flow` before merging.
4. Clean up with `git worktree remove ../myapp-auth` and `git branch -d feat/auth-flow` when you are done.

This works, and it is exactly what happens under the hood in Tallos. The [git worktrees guide](https://runtallos.com/learn/git-worktrees-for-ai-agents) covers every command and pitfall in detail.

## What goes wrong when you manage parallel sessions by hand?

The manual setup is fine for two sessions and painful at five. The work is not the agents; it is everything around them.

- **Tracking state:** which tab finished, which is waiting for a permission prompt, which one crashed.
- **Setup per worktree:** dependencies, `.env` files and ports, every time.
- **Reviewing:** switching folders and running `git diff` per branch, with no place to leave line comments for the agent.
- **Cleanup:** stale worktrees and forgotten branches pile up, and a folder deleted by hand leaves metadata that needs `git worktree prune`.

> Skip the setup. Tallos gives every Claude Code session its own worktree in one click. → https://runtallos.com/signup

## How do I run multiple Claude Code sessions in Tallos?

1. **Connect Claude Code** — Open **Settings → Connections** and make sure the Claude Code card says **Connected**. If not, click **Install**, then **Sign in** (runs `claude auth login`) or **Use API key**. Guide: [connect your agents](https://runtallos.com/learn/connect-your-agents).
2. **Open your project** — Add the repository once. Tallos uses its default branch as the base every workspace starts from.
3. **Create one workspace per task** — Click **New workspace**, pick the project, name the task and choose **Claude Code** as the agent. Tallos creates a real git worktree and branch in the background. Repeat for each task; you can keep working while they are created.
4. **Give each session its task** — Claude Code opens in a chat inside each workspace. Describe the task there, or switch to **View terminal** for the raw CLI. Each session runs with its workspace as the working directory.
5. **Watch them side by side** — Drag a tab to the right or bottom edge of a pane to split, so you can watch several sessions at once. The sidebar shows which workspaces are working and which need you, and the status bar shows your Claude usage against the plan's limits.
6. **Review each diff** — Open each workspace's diff against its starting branch. Leave notes on lines and send them back to that session in one batch with **Send notes to**.
7. **Ship the winners, delete the rest** — Commit, push and **Create PR** from the workspaces you keep. Delete the others; Tallos removes the worktree folder and branch after you confirm.

To stop copying `.env` files by hand, list them in a `.worktreeinclude` file at the repo root. Tallos copies those gitignored files into every new workspace. More in [parallel workspaces](https://runtallos.com/features/parallel-workspaces).

## Manual worktrees vs Tallos: what is the difference?

| Task | Manual (git + terminal tabs) | Tallos |
| --- | --- | --- |
| Create an isolated session | `git worktree add ../dir -b branch`, `cd`, `claude` | New workspace → Claude Code |
| Copy `.env` and local config | By hand, per worktree | `.worktreeinclude`, applied to every new workspace |
| See which session needs you | Check each tab | Status in the sidebar |
| Watch several sessions | Terminal splits or tmux | Drag tabs into split panes |
| Review a session | `git diff main...branch` | Diff view with line notes sent back to the agent |
| Clean up | `git worktree remove` + `git branch -d` | Delete the workspace (with confirmation) |

_Running parallel Claude Code sessions, two ways_

Both approaches use the same git feature, so nothing is locked in: every Tallos workspace is a normal worktree you can open in any terminal, and worktrees you create yourself can be shown in the Tallos sidebar.

## How many Claude Code sessions should I run in parallel?

Run as many as you can review. Tallos does not set a fixed cap, but three limits apply. **Your plan:** every session draws on the same Claude account's usage limits, so parallel sessions reach them faster. **Your machine:** each workspace keeps file watchers, dependencies and processes alive. **Your attention:** each diff still needs a human review before it ships.

Start with two or three independent tasks, such as a feature, a test suite and a bug fix. If you want several attempts at the **same** task, use the [best-of-three squad](https://runtallos.com/squads/best-of-three): set the attempt member to Claude Code and a leader starts three copies in separate worktrees, compares the results and recommends one. For the wider picture, read [running AI agents in parallel](https://runtallos.com/run-ai-agents-in-parallel).

## Troubleshooting parallel Claude Code sessions

- **`fatal: 'branch' is already checked out`.** Git allows a branch in only one worktree at a time. Create a new branch per session.
- **Tests fail only in the new worktree.** Gitignored files are missing. Install dependencies and copy `.env`, or add them to `.worktreeinclude`.
- **Port already in use.** Two sessions started the same dev server. Give each workspace its own port.
- **Sessions stall at the same time.** You probably hit your plan's usage limit. Check the usage readout in the status bar.
- **A session waits with no output.** It is asking for permission. Open the chat and answer.

> Try it on your own repo. → https://runtallos.com/signup

## Frequently asked questions

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

They can, but they will edit the same files on the same branch and overwrite each other. Give each session its own git worktree instead.

### Do parallel Claude Code sessions share usage limits?

Yes. Every session on the same account draws on that account's limits. Tallos shows your Claude usage in the status bar so you can see how close you are.

### Does Tallos use git worktrees for Claude Code sessions?

Yes. Every Tallos workspace is a real git worktree with its own branch, and Claude Code runs with that worktree as its working directory.

### Can I run Claude Code and Codex on the same task in parallel?

Yes. Create two workspaces from the same starting branch, one with each agent, give them the same prompt and compare the diffs.

### How do I stop copying .env into every worktree?

List the gitignored files in a `.worktreeinclude` file at the repo root. Tallos copies them into each new workspace.

### What happens to the branch when I delete a workspace?

Tallos removes the worktree folder and its branch after confirmation. If git keeps a branch because it may have unmerged commits, Tallos lets you review it before deleting.

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)