Splitting work across agents
Last updated: 20 September 2026
Running several agents at once doesn't make things faster by itself. Split correctly and it's parallel; split badly and they trip over each other — the second one edits a file the first already deleted.
The only test that matters
Two things: do they write to the same place, and does the later task need the earlier one's output.
Neither applies, and they can run in parallel. Either applies, and they queue.
| Pair of tasks | Parallel? | Why |
|---|---|---|
| Frontend styles / backend endpoint | Yes | Different files |
| Tests for three separate modules | Yes | Different outputs, no dependency |
| Research / code change | Yes | One reads, one writes |
| Two edits to the same file | No | The second overwrites the first |
| Install dependencies / run tests | No | Tests depend on the install |
| Refactor / add a feature to the old structure | No | The second builds on what the first is dismantling |
Three ways to split
By file
Safest. Each agent's territory doesn't overlap — yours is src/api/, theirs is src/ui/. Works when the project has clear module boundaries.
By stage
Not simultaneous — a pipeline. One researches, one edits, one verifies. It looks like parallelism but it's a queue, with the handoffs happening without you carrying results between them.
By approach
Give one task to two agents and compare the proposals. This isn't about speed; it's about having a second opinion. Useful when you haven't decided how to do something.
When they've already collided
The symptom is usually an agent reporting "the file isn't what I expected". It's reading a version someone else already changed.
- Stop one of them — continuing only makes the conflict worse
- Check Git status to see who changed what
- Pick a version, or merge by hand
- Re-queue the remaining work as serial
If you're using version control this is far easier — uncommitted changes can be discarded wholesale. So before letting agents run, make sure the working tree is clean.
Managing it in Aiglade
Aiglade's task queue lays out everything running at the same moment, so you can see what's moving and what's waiting. The real value is spotting a collision early — two tasks writing the same file is easier to notice in one view than across two terminals each scrolling its own log.
The approval gate matters more here too. When several agents want to take consequential actions, the requests arrive in one place instead of scattering across four windows.
Related: what the approval gate is for.