Guide · Parallel agents

Get out of the bottleneck. Keep the craft.

Several coding agents can run in parallel — but only if the work never collides. How to slice it, isolate the agents, and stay the craftsman instead of the QA robot.

Mio Nilsson, creator of AerunitBy · Last updated

Parallel streams of cyan and purple light running side by side
The new job

You are the coordinator now

With one coding agent, you're a pair programmer: it types faster, you steer. With several, the job changes shape. Cloud agents run in their own isolated environments, work on their own branches and hand back pull requests — none of it touches your machine. [1] The promise of parallelism is real. But your throughput stops being your typing speed. It becomes how well you keep a fleet pointed in one direction.

And fleets fail in a specific way. Point a second agent at the same checkout as the first and, within minutes, they're both editing the same file — one overwrites the other mid-change, and you get half-applied diffs and a broken build with no idea which agent did what. [2] The cost isn't only broken code. It's the tokens your agents burn discovering the collision, resolving it and rebuilding — one vendor of parallel-agent tooling points to API credits wasted on merge conflicts and half-finished changes [3] — and it's you, at the end of it, untangling diffs you never wanted to exist.

The fix isn't a smarter agent. It's treating coordination as infrastructure: explicit task boundaries, isolated execution, and evidence-based merges. [2] Get that right, and you genuinely remove yourself as the bottleneck — the agents build, and you spend your hours on the decisions only you can make.

Why agents collide

Why agents step on each other

Most coding agents assume they own the project directory — they read and write files directly. Put two of them in one checkout and three things go wrong fast: file collisions, where agent A rewrites a file while agent B refactors it and git only sees the last write; context contamination, where B reads a file A is halfway through changing and reasons about a state that never existed; and build interference, where both agents trigger builds and tests that compete for the same output directories and ports. [4] None of these are rare edge cases. They show up the first time you try two sessions on one repo.

The standard fix is git worktrees: a linked working directory on its own branch that shares the same .git history — isolation without cloning. The command has existed since 2015; what changed is that it became the standard way to run more than one agent against a single codebase. [2] Each agent gets its own directory and its own branch, so it can't touch anyone else's files — and conflicts move to merge time, where normal git tooling detects them, instead of happening silently while work is in flight. [5]

Worktrees isolate files, but not everything else. Each agent also needs its own database (or database branch) and a unique dev-server port — otherwise two agents still collide in the data and on the network. [2]

How many is too many? Practitioners running local worktrees report five to seven agents on one laptop as the practical ceiling — past that, rate limits, disk and review load catch up. [2] Others recommend three to five, so call it three to seven, depending on who you ask. [4] Cloud agents remove the laptop limits, but not the review one.

Slicing the work

Slice work that can't collide

Isolation stops agents from stomping on each other's files. It doesn't stop them from building incompatible things. Real repositories have shared hotspot files — routes, configs, registries — and telling agents to stay in different files helps less than you'd hope: one tool maker notes that a refactoring touching a module interface affects every file that imports it, and two agents adding different endpoints often need the same router file. [6]

So the second half of the fix is slicing. Assign non-overlapping tasks, so overlap is difficult by design rather than avoided by luck. [5] The test is blunt:

"If two tasks have overlapping file lists, they need to be sequential, not parallel." [7]

In our experience, the cleanest cut is by boundary, not by layer: give each agent a feature or a seam, not a slice of the same vertical story. Then merge branches one at a time in dependency order, running build and tests after each merge, so each one lands into a codebase the next agent can build against. [2]

When two slices genuinely depend on each other, don't run them in parallel and hope. Mark one as blocked by the other in Linear, and let the second start only when the first has merged. The dependency becomes visible on the board instead of living in your head.

Every slice still needs the same contract as any single-agent story: the mission, the constraints, what's off limits, and what done means. A well-scoped story is what makes two agents' assumptions compatible without a meeting — we cover how to write one in our guide to stories for coding agents.

Quality at scale

Make the checks the quality bar

With several agents in flight, you can't eyeball every diff — and you shouldn't have to. Our advice: move the quality bar into automation. Require tests and automated verification before anything merges, and make the merge itself evidence-based rather than hopeful. The role split that emerges is coordinator, specialists and verifier — you plan and judge, agents execute, and checks verify.

This is also what keeps the tokens flowing toward useful work. When the acceptance checks live in the story, an agent that drifts fails its own tests instead of shipping its drift to a reviewer — or worse, to another agent that builds on top of it. When they don't, the failure surfaces as a conflict between two confident, plausible, wrong pull requests.

The payoff is where your attention goes: review time spent on judgment — is this the right behavior, the right shape, the right name — instead of conflict archaeology and mystery diffs.

The human part

Stay the craftsman

There's a quieter cost than merge conflicts, and it lands on people who have been coding all their lives. Agents eat exactly the work that used to make the day satisfying — the small, complete wins — and what's left is deciding what to build, judging tradeoffs, reviewing, and catching subtleties. [8] Some who ship features this way feel nothing afterward: the work happened near them instead of through them. [9]

One developer traced the feeling back to his own choices. AI didn't take the joy, he concluded — he gave it away by choosing speed:

"I stop being the person who made it and become the person who approved it." [11]

Another frames it as a values question: we automate tasks we don't value — so be honest about whether you want the result or the understanding, and when it's the understanding, do it the hard way. [10] That's the feeling behind "I've become a code-review robot." It isn't a law of AI coding. It's what happens when the division of labor gets decided by default instead of by choice. So decide — on purpose — what stays yours:

Keep the decisions that define the product

The mission, the architecture, the naming, the feel — these are your intent, and intent is exactly what agents can't carry for you. It's also what makes their work good.

Keep the work you love in your own hands

Automate what you don't value; keep what you do. If understanding the system is the point for you, keep a piece of it you build and reason about yourself.

Review against the vision, not the diff

The fastest route to being 'the person who approved it' is reviewing against 'does it work'. Review against 'is this what I meant' — the vision you wrote into the story is the standard.

Motivation

Make building fun again

Fun, it turns out, is a design problem too. Let the agents take the boilerplate, and stay in the hard, satisfying problems yourself. [8] One developer argues for intentional slowness and for picking ambitious projects:

"The key to having fun is challenging yourself right at the edge of your abilities." [9]

Optimizing purely for shipping fast drains exactly that. As the same writer puts it: "The capacity to think through complex problems just goes away." [9]

There's an honest counterpoint, and it deserves a hearing: "If you run five agents in parallel, you're not programming anymore, you're air traffic control." [8] That's true when the coordination lives in your head. It's exactly why the coordination — who runs next, what's blocked, what needs review — should be tooling, not your attention.

Some concrete moves that survive contact with a real week: take one story's hardest slice for yourself and hand the rest to the fleet. Keep one part of the system that's always yours — the place where you still write every line. End the day with a review that's architecture, not inspection: you're the one who decides what the code should become next.

This isn't nostalgia. Motivation is a production input: nobody sustains a fleet from a job that feels like monitoring machines. Keep the craft, and the agents are leverage.

Where we come in

Where Aerunit fits

This guide's advice comes down to three habits: slice work so it can't collide, merge one branch at a time in dependency order, and let checks — not your eyes — be the first quality gate. Aerunit turns those habits into automation for teams on Linear and Cursor Cloud Agents.

It follows Linear's blocks / blocked-by relations: when a pull request merges, Aerunit finds the issues that PR was blocking and queues them to Cursor Cloud Agents, so the next slice starts on top of merged code. That's sequential merging, done for you. When an agent opens a PR, Aerunit runs a code review on it and can send the findings back to the agent session. And Aerunit reads every repository a story touches before writing it, so cross-repo work gets one coherent plan and a sub-issue per repo. You still decide what runs; Aerunit handles the "what's next" once a blocker merges.

Agents busy

Unblocked work is queued to Cursor Cloud Agents the moment its blocker merges.

Checked work

Every agent PR gets an automatic code review, with findings sent back to the agent.

Quick answers

Common questions

How many coding agents can I realistically run in parallel?

It depends on who you ask — somewhere between three and seven. Practitioners running local worktrees report five to seven agents on one laptop as the practical ceiling, because rate limits, disk space and review load catch up; others recommend starting with three to five. Cloud agents remove the laptop limits, but not the review one. [2] [4]

Doesn't running agents in parallel create more conflicts?

It creates more isolated work. With each agent on its own branch and directory, conflicts surface at merge time — where normal git tooling catches them — instead of silently corrupting work in progress. Assigning non-overlapping tasks and merging branches one at a time keeps the ones that do appear small. [5]

Do I still have to review everything myself?

Yes — but well-scoped stories, automated checks and an automatic first-pass review change what your review is: checking the code against a named target instead of reverse-engineering what the agent was trying to do. Your time goes to judgment, not conflict archaeology.

Won't this turn me into a code-review robot?

Only if you let the division of labor be decided by default. Be honest about whether you want the result or the understanding — and when it's the understanding, do that part the hard way yourself. [10]

Aerunit

Keep the agents busy. You do the thinking.

Sign-up is open — create an account and start with pay-as-you-go credits. No subscriptions, and teams share one credit pool at no extra cost.

Create account