← Back to blog

Running Multiple AI Coding Agents: What Does It Cost You?

Running multiple AI coding agents costs human attention, not just tokens. What we measured, which interruptions earn their place, and what to track.

Starting a coding agent is cheap. Getting its work accepted is not. Someone has to notice when it stalls, answer its questions, re-explain context after a handoff, and check whether the result is actually correct.

Search for how to run multiple AI coding agents in parallel and you find good setup advice: git worktrees so agents don’t overwrite each other, a terminal per session, tools that put every run on one screen. Almost every guide also mentions, in passing, that context switching is the real bottleneck. Almost none of them measure it.

That work never shows up on the invoice. We think it should be part of how agent work is priced and compared, so we started by measuring it on ourselves.

Why does a cheap agent run sometimes cost more?

A run’s cost has two lines: what the agent spent, and what the human spent getting the result accepted.

In an internal comparison this month we tried a lighter, cheaper agent setup against our standard one. On most tickets the lighter setup behaved as expected. On one ticket a review loop kept bouncing the change back, and the cheap run ended up costing more than the standard one would have.

That is the visible part. The invisible part is what each extra round costs the person watching: another look at what happened, another decision about whether to let it continue, another moment of rebuilding context that was already built once.

Neither line is enough on its own. A run that spends little on tokens but needs a person to rescue it three times is not cheap. A run that spends more but comes back with a result someone can accept in five minutes may be the better deal.

How much of a developer’s time goes into directing agents?

More than most teams assume. A workplace shadowing study of 11 developers (October 2026) found that, on average, 33.4% of observed time went into formulating prompts or checking AI responses, and task-switching rates ranged from zero to about a hundred switches an hour. The sample is small, but the category is real: directing and checking agents is part of the job now.

An eight-month ethnography at one technology company by researchers at UC Berkeley Haas saw the same pattern from another side. People took on wider scope, filled former pauses with new tasks, and kept several AI-assisted threads running at once. Some ran multiple agents simultaneously. A long run used to be a natural stopping point. With agents, it becomes a reason to start the next thing.

What did we find when we counted our own interventions?

Gleb Rosev, who works on YAGNI, went through two weeks of his own coding-agent sessions, from 31 October to 14 November. We kept only the sessions that produced a pull request that was later merged: 58 merged pull requests, and 606 messages he typed in the sessions that produced them. That is about 10 human messages per merged pull request.

A model labelled each message, and we spot-checked the labels by hand.

Kind of message Share Examples
Decision 46% “Yes, merge it.” “Do A and C.”
New task or change of direction 17% “Now take the next ticket.”
Coordination about 1 in 5 “How’s it going?” “What are we waiting for?” “Repeat the task you’re doing.”
Defect caught 7% “This check is failing and you missed it.”
Other 11% Thanks, pasted context, unclear

The coordination row is the one that matters here. It works out to roughly two messages per merged pull request where a person had to rebuild context only to keep the work moving. The spot-check showed some design questions filed as coordination, so the honest range is one in six to one in five.

This is one person, one tool and two weeks, not a benchmark. The sessions ran in a general-purpose coding agent, not in YAGNI’s Teams. But it gives us a baseline to bring down without moving the quality line.

Does a better dashboard fix it?

Partly. ParallelPilot, a research tool for supervising parallel coding sessions, added a planning interface, a run logger and an ambient dashboard. In a study with 16 participants on short coding tasks, ticket throughput rose by 63% and tracking effort and context switching dropped. Participants did not report a significant gain in perceived control, or in their success at redirecting the agents.

That gap is the useful finding. An overview tells you which session is green. It does not tell you what green means, what evidence sits behind it, or whether the work is right. The authors suggest pairing high-level awareness with low-cost paths back to the implementation evidence, which is the part most parallel-agent setups leave to the person.

Which interruptions should reach a person?

We separate two kinds of human involvement.

Decisions that need a person. A product ambiguity needs whoever owns the product. An architectural tradeoff needs an engineer. A change outside the approved scope should never quietly become the agent’s call. These are worth an interruption, because the judgment can’t be delegated.

Coordination the system should carry. Finding a stalled run, restating the original request, repeating context after a handoff, collecting the evidence that a task is done. These cost attention and add no judgment.

Our working rule is that a human action is expensive. The click takes a second. Understanding the task well enough to make that click can take ten minutes, and if the person had already switched to something else, it includes getting back into it.

What should a setup for parallel agents do?

The rule turns into four requirements, whatever tool runs the agents.

  1. Keep the task’s state with the task. The goal, the approved plan, the decisions made along the way, the progress and the open questions travel with the work across steps and handoffs. Nobody should reconstruct them from a chat log.
  2. Ask specific questions. When a person is needed, say what is blocked, show the evidence, and lay out the consequences of each choice. “Please look at the conversation” pushes the coordination back onto the person.
  3. Ship evidence with the result. What changed, which checks ran and where, and what remains unverified. A status that says “done” without proof from the source is a claim, not a result.
  4. Respect review capacity. More parallel tasks means a longer review queue. Parallelism has to account for shared files, dependencies and the people making the final call.

How does YAGNI handle this?

YAGNI runs agent teams, managed like your engineering team. The enemy we design against is the unmanaged agent: a pilot that impresses for an afternoon and then decays into babysitting.

On a Team, Bailey proposes work and Reeve plans it, Wright builds against the approved plan, and Proctor reviews. When something consequential needs a person, the Team stages a Decision: the proposal, the evidence and a confidence, waiting for the person authorized to answer that specific ask. That is requirement two, built in.

Results carry Receipts: proof from the source of where something stands, such as the pull request merged or the check passed. YAGNI does not say “done” on its own say-so. Harper’s Daily Brief posts to Slack what shipped, what is in flight and what needs a person, with the Receipts attached, so the status check happens once a day instead of whenever someone feels uneasy. Merge stays a person’s click unless the Team turns on Merge automatically.

For the wider frame of ownership, review and the record, see how to manage AI coding agents and keep them accountable and who reviews AI-written code. The guide to AI code review tools covers the review side of the same arithmetic: human minutes per pull request.

What should you measure?

Track the human cost next to the machine cost:

Measure What it tells you
Human interventions per accepted task How often work comes back to a person
Active human minutes per accepted task How much attention the work really takes
Time to understand a resumed task Whether the setup keeps usable context
Reasons for intervention Real decisions versus avoidable coordination
Acceptance and rework after review Whether less supervision is paid for with quality
Agent and infrastructure spend Whether the whole workflow pays off

Fewer interventions alone prove nothing. An agent can ask fewer questions by making unsupported assumptions, and a reviewer can spend less time by missing defects. Attention numbers only mean something next to quality and rework.

Start with a count like ours: pick two weeks, take the tasks that were accepted, and label what each human message was for. The coordination share is the number to bring down.

The workflow worth building toward

Hand over a meaningful task, leave, and come back to a result you can assess: what changed, what was checked, and the one decision that is actually yours. A process ending or a pull request appearing does not mean the work is finished. Someone still has to understand it well enough to accept it.

If you want to see how a Team carries that coordination on your own repositories, book a 30-minute call.