Three Copilot Agents on One Project Without Collisions: The Worktree Isolation Behind Parallel Sessions

Three AI agents on one project sounds like chaos. GitHub’s 2026-09-03 tutorial answers it directly: in the Copilot app the agents work separately and do not interfere with each other — because each session can run on its own Git worktree.

Here is the documented mechanism, plus our own practical notes. Verified 2026-09-08.

1. Three terms from the documentation

1. Agent session GitHub’s definition: a task you have given Copilot, start to finish. In the sessions view, each card shows its title and how far along the agent is.

2. Its own Git worktree The key part, in GitHub’s words: each agent session in the Copilot app can run on its own Git worktree, and because each session is isolated they can run in parallel.

In plain terms, a worktree is a second working directory for the same repository — different branch, different file state, shared git history. Files that agent A edits never appear in agent B’s directory, so they cannot overwrite each other.

3. Independent context Also stated: each session keeps its own context, so switching back picks up exactly where you left it, with nothing to re-explain.

2. The metaphor, and what it actually implies

The tutorial uses a laundromat: several loads at once, each with its own settings, no waiting for one to finish.

The overlooked part: the machines do not fold anything. GitHub’s own framing is that you spend your time reviewing and making decisions rather than watching agents work. Parallelism does not mean the AI does more; it means your waiting time compresses. The review workload does not shrink — it arrives three at a time.

3. Which tasks parallelise well (from the official example)

The tutorial’s sample repository has three jobs for one day:

1. Add a feature (a funded sort)
2. Run an accessibility review
3. Run some tests

What they have in common is worth copying: no dependencies between them, and no overlapping edits. One builds, one inspects, one verifies — not three agents editing the same file.

Conversely, two agents editing the same module means worktree isolation defers the conflict to merge time. That is not the problem this feature solves.

4. Settle three things first (our recommendation)

GitHub suggests starting two small tasks at once. Before you do:

1. Each session’s task must be reviewable on its own. Three results arrive together and you need to judge each independently. Tasks that are too large or too vague turn into a review bottleneck.
2. Decide the merge order in advance. Isolation applies to execution, not integration. Which branch lands first, and whether the others re-run tests afterwards, is cheaper to decide now than later.
3. Start small. In GitHub’s words, it is a low-stakes way to watch tasks progress independently. Opening three large refactors on day one just produces three unreviewable diffs.

5. A related lesson: parallelism can be lost in configuration

The same week, another GitHub engineering post documented a real incident: while compressing prompts, flexible “can run in parallel” guidance was rewritten into a hard scheduling policy, and independent agents that should have run in parallel ran sequentially instead.

For users, the implication is simple: check that parallel work is actually parallel. If the three progress bars advance one after another, it is not. Full story in shortening your agent’s output can cost more.

6. One note on cost

Parallelism makes nothing cheaper — three agents running at once is three times the usage. How Copilot credits are consumed: Copilot AI credits explained. Plan differences: GitHub Copilot tool page.

Source read directly on 2026-09-08: GitHub’s tutorial GitHub Copilot app for Beginners: Run several agents at once (Kayla Cinnamon, 2026-09-03); the parallelism regression in section 5 comes from GitHub’s companion engineering post of 2026-09-02. The recommendations in section 4 are ours, not vendor guidance.