Skip to main content
The safest multi-agent setup is simple: one lane per task, one clear goal per agent, and a review pass before merge. Isolation is what keeps parallel agents from writing over each other — give each its own worktree and the collisions disappear.
Several agents running in parallel in ADE

Several agents working at once, each reporting back into the parent.

​
One lane per task

Every lane is its own git worktree — its own branch, files, and sessions. That isolation is the whole game: two agents in two lanes can’t touch each other’s working tree, so they run in parallel without stashing, rebasing, or fighting over the same files.
1

Split the work

Turn a large goal into small, independent, lane-sized tasks.
2

Create one lane per task

Name lanes after the outcome, not the agent.
3

Start one chat per lane

Keep each prompt scoped to that lane’s goal.
4

Watch Work and Graph

Use Work for live sessions and Graph for branch relationships and merge risk.
5

Review independently

Inspect each diff, run tests, and open PRs separately.

​
Good task splits

A clean split has slices that touch different files and can be reviewed on their own.

​
Watch for collisions

Parallel agents stay safe as long as their work doesn’t overlap. Most collisions come from scope creep, not from the tool.
  • Don’t send two agents into the same lane for unrelated work.
  • Avoid broad prompts that invite repo-wide edits — keep each agent narrow.
  • Start from another branch with Bring: Local when a task depends on its unmerged commits.
  • Merge parent work before rebasing children when possible.
  • Use History to see exactly what each session changed.

​
Grid view: several agents on one screen

Grid view tiles full chats next to each other so you can run several agents in parallel — across lanes or against the same task — and watch them all at once.

One task, many models

Send the same prompt to Claude, Codex, and Cursor, then keep the best result.

Many tasks, one screen

Tile one agent per lane and supervise a whole batch of parallel work.

Race a hard problem

Let several agents attempt the same fix and compare diffs before committing.

​
Send one prompt to several models

Compose a prompt once and launch it across the models you pick. Each runs in its own tile with its own transcript, diff, and approval gate. Each tile is a full chat. Open one to read the transcript, inspect its diff in Files, or promote its work to a PR — and close the rest. Nothing is committed until you say so.

​
Grid or separate lanes?

Both run agents in parallel, but they answer different questions.

Grid view

Same task, several models — race a narrow, well-specified change and keep the best diff. Each tile is a full chat.

Separate lanes

Different tasks — give each its own worktree so broad, multi-step work never competes for the same files.
Use the grid for narrow, well-specified work where comparing a few attempts is cheap. For broad, multi-step features, give each agent its own lane instead.

Agent chat

How a single lane-scoped chat works.

Lanes overview

Isolate each task in its own worktree.