Five coding agents, one repository, and a review queue you did not plan for
Running multiple coding agents concurrently against one codebase, each in its own isolated workspace, with their output funnelled through a single review gate.
Personal assistants are one agent per person. This chapter is several agents on one codebase at the same time — each in an isolated workspace, all producing diffs, all arriving at the same human. → Worktree and container isolation, merge discipline, and the honest measurement of whether five agents actually beat one. → The bottleneck moves, and it moves somewhere most teams do not have capacity: review.
Several coding agents on one repository at once. Isolation so they cannot collide, merge discipline so the work survives, and an honest measurement at the end — because the bottleneck moves from writing code to reviewing it, and that is a capacity problem no tool solves.
Many small, independent, well-specified tasks — a backlog of mechanical fixes. Not one hard task you hoped to parallelise.
Per-agent isolation (worktree or container), a task list with real independence, a merge strategy, and a review gate with a throughput limit.
The orchestration tooling is open source; the model tokens scale linearly with the fleet. Five agents cost five times as much whether or not they helped.
Tooling in this niche does not merely stall, it shuts down. The best-known fleet tool of 2026 posted a shutdown notice in April with no sustainable business model. Learn the technique; treat every tool here as replaceable.
A git worktree creates a separate checkout directory linked to its own branch while sharing the same repository metadata.
Run multiple coding agents on the same repository without branch conflicts using git worktree
cwd-f only if you need to discard uncommitted changes)git worktree list output showing one line per active checkout with its path, commit and branch namegit worktree add -b assigns an agent its own folder and branch while sharing a single repositorygit worktree add -b let each coding agent work without branch conflicts?A container‑use workspace launches an isolated Docker‑based environment for a coding agent, keeping its execution separate from the host system.
Select either a git worktree or a containerised workspace based on what the task must be kept away from
docker ps) to see that the container‑use agent runs inside its own isolated environmentcontainer-use: free and open source, but the container runtime and image builds cost real setup time and disk — budget more than the "five minutes" a worktree takes.An independent parallel task is a self‑contained description that neither reads nor writes files modified by any other task.
Distinguish a genuinely parallel task list from one that merely appears parallel before creating worktrees
A git merge --no-ff integrates an agent’s branch into the integration branch while preserving a separate commit history.
Integrate every agent's work into the main line one at a time while catching conflicts early
git status and passing tests after each merge before the next branch is processedgit merge --no-ff, what outcome indicates it is safe to remove that worktree and delete the branch?git merge you'd run for one branch, run N times instead of once. The cost you're managing is your own time if you skip the "one at a time" discipline and have to untangle a compound conflict instead.A wall‑clock time calculation adds the agents’ execution duration to the reviewer’s time to assess overall speed and cost.
Determine whether running multiple agents saves overall time and tokens compared with one agent
A diffs‑per‑hour limit caps the number of concurrently running agents to match the reviewer’s capacity.
Restrict the number of active agents so they never exceed the diffs you can honestly review per hour
A review‑capacity‑aligned workflow structures agent launches to keep the pending diff queue within human review limits.
Design a workflow that scales writing agents without exceeding human review limits
14 outcomes in all — one per recipe below.
Agents keep overwriting each other’s files
Create a markdown file (plan.md) that maps each target component or directory to a specific sub‑agent. By being explicit about which files each agent may modify, you prevent overlapping writes and merge conflicts during parallel execution.
Need to check a new fleet launch safely
Use the `--dry-run` (or similar) flag when first launching the fleet. The command parses plan.md, checks that all referenced paths exist, and simulates agent startup without writing any code, catching typos or mis‑assignments early.
Many separate code changes need checking
After the fleet finishes, it creates separate Git branches each containing only that agent’s final diff. By reviewing each branch individually you retain full control over integration and can catch logical errors before merging to main.
Want to apply many fixes and upgrades across a repo
The /fleet command lets you issue a single prompt that spawns several Copilot agents, each handling a separate sub‑task (e.g., fixing an issue, upgrading dependencies). By delegating these tasks to parallel agents, you finish routine maintenance without manual intervention.
Need several AI drafts at once
Replit’s parallel agents let you launch several AI‑driven tasks (e.g., mobile app, video, pitch deck) from the same project. Each task runs in its own isolated copy so changes never affect the main code until you approve them, enabling true multitasking without context switching.
Multiple agents edit separately
Each parallel agent’s output lives in an isolated workspace until you move it to the “Ready” stage, where you can review a diff against the main branch. This prevents accidental overwrites and enforces disciplined merging of multiple contributors.
Multiple people need separate code spaces
A Git worktree creates a fresh checkout of the same repository in a separate folder, allowing multiple agents to edit code without interfering with each other. Zed can create these worktrees directly from the UI, giving each agent its own isolated workspace.
Juggling separate AI chat windows
Zed’s Threads sidebar lets you import, start, stop, and monitor any number of agent threads (Zed, Claude, Codex, etc.) in one window, removing the need for separate editor instances.
Parallel agent threads filling up disk
When you archive a thread, Zed moves its uncommitted changes into Git storage and deletes temporary files, freeing disk space while preserving the ability to restore later.
Multiple AI bots need separate code copies
Worktrees let each AI agent operate on its own copy of the repository, preventing file conflicts. By creating a separate worktree per issue, agents can modify code independently and later merge via pull requests.
Turn every GitHub issue into an auditable pull request
Treating a GitHub issue as the input spec and the resulting pull request as validation output creates a clear, auditable workflow for each agent. This aligns planning, implementation, and review steps.
Running multiple worktrees causes port conflicts
Assigning each worktree a unique port based on its name prevents runtime collisions when agents start the application for testing. A simple script can compute a deterministic offset from a base port.
Need a sandbox DB for each git worktree
Neon's branching feature clones the production database schema and data into a separate branch for each worktree, giving agents safe sandboxed databases. This avoids cross‑worktree data races.
Want a bias‑free pull‑request check
Running a review in a new AI session (cleared context) prevents the writer’s bias from influencing the reviewer, similar to an independent code audit. The dedicated /review_pr command automates diff extraction and issue comparison.
The same set on /recipes, filtered by tool and role.
Ask, share, or report — over on the Heidelberg AI community forum.
Copilot