# How to run AI coding agents in parallel

> To run AI coding agents in parallel, give each agent its own git worktree (a separate checkout on its own branch) and its own terminal, then review each diff before merging. You can wire this up by hand with git worktree and tmux, or use an ADE like Tallos, which creates the worktree, launches the agent and tracks its status for every task.

- Canonical: https://runtallos.com/run-ai-agents-in-parallel
- Português: https://runtallos.com/pt/rodar-agentes-de-ia-em-paralelo.md
- Updated: 2026-09-29

## Key facts

- Rule one: one agent, one worktree, one branch
- Manual setup: git worktree + tmux + your own bookkeeping
- Tallos creates the worktree and launches the agent per task
- Status per agent: working, waiting on you, done
- Review each diff, merge only the winners

## What does it mean to run AI agents in parallel?

Running AI agents in parallel means having two or more coding agents — for example Claude Code, Codex and Gemini CLI — work at the same time on the same repository, each on its own task or on its own attempt at the same task. Instead of waiting for one agent to finish before starting the next, you start them all and review the results as they come in.

The agents do not need to be different. Several sessions of the same CLI work just as well, which is the usual starting point for people who want to [run multiple Claude Code sessions](https://runtallos.com/learn/run-multiple-claude-code-sessions).

## Why run AI coding agents in parallel?

You run agents in parallel because a single agent is sequential, and most of your time with one agent is spent waiting. Parallel agents turn that waiting into throughput.

- **Ship more tasks at once** — a bug fix, a small feature and a test sweep can all run while you review the first one that finishes.
- **Race attempts** — send the same prompt to three agents and keep the best diff. Where they agree, the answer is probably right; where they split, you found the hard part.
- **Separate roles** — one agent builds while another reviews or writes tests in its own workspace.
- **Use your subscriptions fully** — if you pay for more than one agent, parallel work lets you use them side by side instead of picking one.

## What goes wrong when you run agents in parallel?

Almost everything that goes wrong comes from agents sharing things they should not share: files, branches, terminals and your attention.

- **Same files** — two agents in one folder overwrite each other's edits. Neither agent knows the other exists.
- **Same branch** — commits from different tasks mix, and one agent's half-finished work breaks another agent's tests.
- **Same ports** — two dev servers try to bind the same port, and one of them fails.
- **Missing setup** — a fresh checkout has no `node_modules`, no `.env` and no build cache until you recreate them.
- **Terminal chaos** — a dozen windows, and you cannot tell which agent is waiting for an answer.
- **Review pile-up** — five diffs arrive at once. Without a review flow, the fastest path is to merge without reading.
- **Usage limits** — several agents on the same account draw from the same allowance and can hit rate limits sooner.

## What are the ways to run agents in parallel?

There are two practical approaches: wire it up by hand with git worktrees and a terminal multiplexer, or use an ADE that does the wiring for you. Both rely on the same foundation — a separate git worktree per agent.

The manual approach looks like this for every task:

```bash
# one worktree + branch per task
git worktree add ../app-fix-login -b fix-login origin/main
git worktree add ../app-billing-tests -b billing-tests origin/main

# recreate what git does not track
cp .env ../app-fix-login/ && (cd ../app-fix-login && npm install)

# one tmux window per agent
tmux new-session -d -s agents -c ../app-fix-login 'claude'
tmux new-window -t agents -c ../app-billing-tests 'codex'

# later: review, merge, clean up
git -C ../app-fix-login diff origin/main
git worktree remove ../app-fix-login
```

| Step | Manual (git worktree + tmux) | ADE (Tallos) |
| --- | --- | --- |
| Create an isolated workspace | `git worktree add` with a path and branch name | Click + on the repo, name the task, pick the start point |
| Copy `.env`, install deps | By hand or a script per repo | Shared paths, a `.worktreeinclude` file and setup hooks run on every new worktree |
| Start the agent | Open a pane, `cd`, type the command | Pick the agent when you create the workspace |
| Know who needs you | Check each pane | Status per session: working, waiting on you, done, idle, plus a notification when an agent finishes |
| Review | `git diff` in a terminal | Diff view with line comments sent back to the agent in one batch |
| Ship | Commit, push and open the PR yourself | Commit, push and open a PR from the workspace |
| Clean up | `git worktree remove` and delete the branch | Delete the workspace; worktree and branch go with it |
| Coordinate agents | You are the coordinator | Optional squads: a leader agent dispatches members and reports back |

_Both approaches use real git worktrees. The difference is who does the bookkeeping._

The manual approach is a good way to learn how it works — the [git worktrees for AI agents](https://runtallos.com/learn/git-worktrees-for-ai-agents) guide covers it in depth. It gets expensive past three or four agents, when the bookkeeping becomes the job.

## Is there a faster way than setting up worktrees by hand?

Yes. An [ADE](https://runtallos.com/what-is-an-ade) creates the worktree, launches the agent and tracks its state for you. In Tallos, a new parallel task is a name, a start point and an agent.

> Run your first three agents in parallel. Tallos runs on macOS and Windows. → https://runtallos.com/signup

## How do I run agents in parallel in Tallos, step by step?

Here is the full loop in Tallos, from an empty app to a merged pull request, using three agents on three tasks or three attempts.

1. **Connect your agents** — Open Settings → Connections. Install the agents you use with the vendor's own command, sign in or save an API key, and see each agent's models.
2. **Add your repository** — Add a local checkout. Tallos picks up your default branch as the base every new workspace starts from.
3. **Create the first workspace** — Click + next to the repo, name the task, choose the start point and the agent. Optionally link a GitHub, GitLab, Linear or Jira item. Tallos creates a real git worktree and branch in the background.
4. **Give the agent its task** — Supported agents open in a chat view by default. Type the prompt, drop in files or screenshots, and let it work. Switch to the raw terminal whenever you want.
5. **Repeat for each agent** — Create a second and third workspace — different tasks, or the same prompt with a different agent to race them. Each one is isolated.
6. **Watch them side by side** — Drag tabs to split panes so you can see several agents, a dev server and a browser at once. Status icons show who is working and who needs you.
7. **Answer what needs you** — When an agent is waiting on a question or permission, it is marked as needing you. Answer, and it continues.
8. **Review each diff** — Open the diff for a finished workspace. Comment on lines, then send all notes back to the agent at once. Repeat until it is right.
9. **Ship the winner** — Commit, push and open a pull request from the workspace. Delete the workspaces you do not need; the worktree and branch go with them.

Prefer the keyboard or want an agent to do it? The `tallos` CLI creates the same workspaces:

```bash
tallos worktree create --name fix-login --agent claude --prompt "Fix the login race condition"
tallos worktree create --name fix-login-2 --agent codex --prompt "Fix the login race condition"
```

Learn more about how isolation works in [parallel workspaces](https://runtallos.com/features/parallel-workspaces) and how to read an agent's changes in [diff review](https://runtallos.com/features/diff-review).

## How many AI agents can you run in parallel?

You can run as many agents as your machine, your usage limits and your review time allow — and review time usually runs out first. A practical start is two or three agents, growing as your review habits keep up.

- **Machine** — each workspace may run its own dev server, tests and build. Heavy projects can move to a bigger machine through [remote workspaces over SSH](https://runtallos.com/features/remote-workspaces).
- **Usage** — every agent uses your own subscription or API key. Tallos shows usage and rate-limit windows for supported agent accounts.
- **Review** — a diff you do not read is a risk. Add agents only as fast as you can review what they produce.

## What comes after running agents in parallel?

The next step is letting an agent coordinate the others. A [squad](https://runtallos.com/features/squads) is a leader agent that splits an objective across member agents, each in its own worktree, checks their work in rounds and hands you a final report to accept or discard.

The “3 attempts, pick the best” template is parallel racing with a judge: three members attempt the same objective and the leader recommends one with its reasons. By default a squad runs up to 4 members at once for up to 5 rounds, and you can raise that to 12 members and 20 rounds. See the [best-of-three squad](https://runtallos.com/squads/best-of-three).

## Frequently asked questions

### Can I run two Claude Code sessions on the same repo at the same time?

Yes, as long as each session works in its own git worktree. In the same folder they overwrite each other's changes; in separate worktrees they each have their own branch and files.

### Do I need git worktrees to run agents in parallel?

You need some form of isolated checkout, and git worktrees are the lightest one because they share the repository history. Tallos creates a worktree for every task automatically.

### Is tmux enough to run AI agents in parallel?

tmux handles the terminals, not the isolation, status or review. Combined with git worktrees it works well for a few agents; an ADE adds status tracking, diff review and cleanup on top.

### How do I stop parallel agents from using the same port?

Run each dev server on its own port, set per workspace through environment variables or your framework's port flag. Each Tallos workspace has its own terminals, so each server stays with its task.

### Will running agents in parallel hit my rate limits faster?

It can, because parallel agents on the same account share one allowance. Spread work across the agents you have access to and watch usage; Tallos shows usage and rate-limit windows for supported accounts.

### How do I merge the results of parallel agents?

Review each workspace's diff, keep the ones you want and open a pull request from each winning branch. Delete the rest; in Tallos that removes the worktree and its branch.

### Does Tallos work on Windows for parallel agents?

Yes. Tallos runs on Windows 10 or later and on macOS 13 or later, with the same workspaces, terminals and review flow.

---

**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+)