Why parallel agents collide
Two things go wrong, and they are different problems.
They edit the same files. Two agents both add a column to the schema file, or both touch the same route. Each change is fine alone. Together they conflict, and an agent resolving a conflict it does not understand tends to keep its own half.
They decide the same thing twice. Ticket A needs a function that ticket B is supposed to provide. B has not been built, so A's agent invents the function. B's agent, an hour later, invents a different one. Both pull requests pass their own tests.
The first is a scheduling problem. The second is a design problem. You need to handle both.
Decide shared interfaces before you split
Anything two tickets must agree on belongs in the design, written once, before either ticket starts: the table and its columns, the function name and its arguments, the states an order can be in. Then neither agent has to invent it. See How to write a tech design AI agents can build from.
If you find yourself unable to write the interface down, the tickets are not ready to run in parallel. That is useful to learn before the agents start.
Give each ticket dependencies
A dependency is a plain statement: this ticket can start only after that one is merged. "Email the customer when a payment fails" depends on "Retry failed card payments", because it reacts to a state the first one creates.
Write dependencies down per ticket. Do not leave them in someone's head or in the order of a list. With them, the question "what can start now?" has a mechanical answer: every ticket whose dependencies are all done.
Give each ticket its areas
Dependencies do not catch file collisions. Two independent tickets can still both edit payments/retry.ts.
For that, list on each ticket the areas it changes. An area can be a path (src/payments/) or a simple tag (billing). Two tickets that share an area should not run at the same time, even if neither depends on the other. One goes first and the other waits for it.
Be honest and coarse. You do not need every file. You need enough to know that two tickets will meet.
The file everyone touches
Every codebase has a few files that most tickets edit: the database schema, the route table, the translations. If you treat them as areas, every ticket blocks every other and nothing runs in parallel.
Those files usually conflict in small, mechanical ways: two added lines. It is reasonable to mark them as shared and leave them out of the collision check, and accept a trivial rebase. Reserve the blocking for areas where two agents would make real, competing changes.
Ready, held and waiting
With dependencies and areas written down, every ticket is in one of three states:
- Ready: its dependencies are done and nothing ahead of it touches the same area. Start it.
- Held: its dependencies are done, but it shares an area with a ticket that is ready or in progress. It starts when that one finishes.
- Waiting: a dependency is not done yet.
Run everything that is ready, at once. When a ticket merges, recompute. That gives you waves: the first wave is everything ready now, the second is what those unlock, and so on.
A worked example
A checkout rework has three tickets:
| Ticket | Depends on | Areas |
|---|---|---|
| T1 Retry failed card payments | payments | |
| T2 Email the customer when a payment fails | T1 | emails |
| T3 Roll out behind a flag | T1, T2 | config |
Only T1 is ready. T2 and T3 are waiting. Nothing can run in parallel yet, and no amount of agents changes that: the plan tells you so before you launch three sessions.
Now add T4, "Export failed payments as CSV", with area export and no dependencies. T1 and T4 are both ready and share no area, so two agents take them at the same time. When T1 merges, T2 becomes ready. If a fifth ticket also touched payments with no dependency on T1, it would be held behind T1, not started beside it.
Keep pull requests small
Parallel work only pays off if merges are quick. A ticket that takes a day to review holds everything behind it. Tickets sized so that one agent finishes one in a session, with acceptance checks a reviewer can verify, keep the waves moving.
Where Tuskway fits
In Tuskway each ticket brief carries its dependencies and areas. The ticket board marks tickets as ready, held (with the ticket and area holding it) or waiting (with what it waits on), and a plan view shows the waves. When one path appears in most tickets, Tuskway suggests ignoring it for overlaps. Agents get the same answer from the ticket_plan tool, and the board can copy a start prompt for each ready ticket, so launching a wave is one paste per agent.
The method works without the tool: a table like the one above, kept up to date, is enough for a small feature.
Questions
How many agents can run at once?
As many as there are ready tickets. The limit is the shape of the work, not the number of agents. If only one ticket is ready, more agents will not help.
What if two tickets really must touch the same file?
Make one depend on the other, or merge them into one ticket. Running them side by side and hoping is the expensive option.
Do I need to list every file a ticket touches?
No. List the areas where a collision would be a real conflict of intent. Coarse is fine.