"Run a bunch of agents in parallel" is the kind of thing that demos beautifully and then corrupts your working tree the first time two of them edit the same file. The hard part of multi-agent work was never spawning the agents; it's keeping them from standing on each other. That's what aide's swarm is actually about, and it just grew a proper coordination layer.
Two design choices do most of the work.
Isolated git worktrees. Each agent works in its own worktree, not the shared checkout. They can edit, build and test in parallel without colliding, and the results merge back deliberately rather than racing. A blast radius of one worktree is a very different thing from a blast radius of your branch.
Atomic task claiming. Work is a queue of tasks, and an agent claims one atomically before touching it: no two agents pick up the same task, and a crashed agent's task is reclaimable rather than lost. With the new coordination layer that's gRPC streaming over the daemon, an agent CLI to drive it, and a dashboard to watch it happen.
The other half is that the swarm runs work through an actual SDLC pipeline (design → test → implement → verify → docs) rather than asking one agent to do everything in one shot. Each stage is a checkpoint, which is how you get a reviewable result out the far end instead of a pile of plausible diffs.
None of this is "AGI writes your app while you sleep." It's the unglamorous orchestration (worktrees, queues, claims, stages) that makes parallel agents safe enough to be useful. Which, predictably, was far more work than the demo version. Repo and docs on GitHub.