Skip to content
  1. Home
  2. Articles
  3. Running Several Coding Agents at Once: The Bottleneck Moves From Writing Code to Review and Verification Gates
108
AI & Infrastructure

Running Several Coding Agents at Once: The Bottleneck Moves From Writing Code to Review and Verification Gates

Running Several Coding Agents at Once: The Bottleneck Moves From Writing Code to Review and Verification Gates

When several AI coding agents work on one system, review, merge and verification capacity limits delivery. Decide isolation, merge order, gates, stop rules and rollback before adding agents.

On Monday morning a reviewer opens the pull request list and finds a longer queue than last week, with the same number of people on the team. The only change is two more coding agents, each of which delivers faster than a person can read. This article is for the delivery owner who has to decide how many agents may work at once, under which conditions, and who is allowed to stop them.

It is not about prompts or model choice. It is about managing the work that several agents produce while a system is being built. That separates it from two pieces we have already written. One covers the readiness gates before an agent touches a production system: identity, permissions, audit. The other is the acceptance checklist for code a vendor wrote with AI, which covers what to put in a TOR and which evidence to ask for at handover. This article starts after both: the team is building, and more than one agent is working.

What Gartner says about the harness, and what the figure does not prove

Gartner's 2027 list has ten trends in three stages, and the AI coding agent harness is one of them, as Ann Bednarz summarised in Network World on 20 October 2026. Gartner defines it as a closed-loop system that governs autonomous developer behaviour across the software development lifecycle, joining coding platforms to enterprise context, model routing, verification gates and feedback loops.

The same article reports Gartner's warning that without a dedicated harness, developers must spend time manually verifying machine output. The forecast with a number in it is that by late 2026, autonomous coding agents will generate 20% of all public commits. That is a Gartner forecast as reported by Network World, not a measurement, and its population is commits on public repositories, not private enterprise code.

We could not open Gartner's own page, which refused our request, so every figure and definition here is Gartner's as reported by Network World. The source does not tell you what share of your organisation's code comes from agents, how much faster or safer teams become with a harness, or which product works. We use it as a signal of direction and explain the rest from how delivery work operates.

When agents are added, the queue moves to review

The following is an illustration with invented round numbers, not data from any team. Suppose the agents together open 10 changes a day and the team can review 4 of them properly. Every working day then leaves 6 more changes waiting. After a week about 30 are queued, and a change opened on Monday waits more than a week. The point is the age of the queue, not the numbers.

A long queue does two things. Old changes collide with newer ones that merged first, so they need conflict fixes and agent rework, which creates more review work. Worse, reviewers start approving faster to shorten the queue. Review turns into ritual, and an agent that writes code quickly also delivers its mistakes to production quickly.

Rushed review is a risk nobody sees.

Writing code ten times faster does not make delivery ten times faster, because throughput is set by the slowest stage, and in a team running several agents that is usually review, merge and verification. We think the delivery owner should be able to answer five questions before adding the next agent: isolation, merge order, gates, stop rules and rollback.

Isolation: one task per branch and per environment

The baseline is one agent per task, on its own branch, with its own environment for running tests. The collisions that hurt are rarely in source files, because Git shows those. They are in shared mutable state, which does not appear in a diff.

  • A shared database: two agents running migrations or seed data against one database overwrite each other, and neither test result can be trusted.

  • Editable config and environment variables: a value one agent changes to make its own work pass can break another agent's work with no visible cause.

  • Secrets and tokens: if every agent uses one credential, there is no audit trail saying which one acted. Issue a credential per agent or per task, scoped to what that task needs.

  • Files every task touches: lock files, a central schema and route tables are where conflicts repeat. Make them one-at-a-time work instead of letting several agents edit them.

Identity and permissions for agents that reach real systems are covered in the readiness article. The point to add here is that separate environments do more than prevent accidents. They let you believe a passing test passed because the code is right, not because it happened to use data another agent prepared.

Merge order, and the gates that run before a human spends time

Merging needs an owner. We suggest writing down three rules. Agents may open changes but may not merge them. The person who merges must see the gate results and the attached evidence, not just a green button. And merge order follows risk and dependency, not who opened first: a change touching schema or permissions goes in and settles first, and others rebase behind it.

Gates exist so that a human never reads a change that should not be read yet. We think the minimum before a reviewer sees anything is four layers.

  1. The full automated test suite passes, including tests the agent added, with a check that tests were not deleted or loosened to get a pass.

  2. Static checks such as lint, type checks, and scans for dependencies or secrets that entered the diff.

  3. A diff-size ceiling. Past the ceiling the change goes back to be split, since large diffs are where review degrades fastest.

  4. A required evidence note saying what changed, what was tested, and what the agent is unsure about. A change without it does not enter the queue.

This order filters out failures before they reach people, which matches what Gartner describes for verification gates and its warning about manual verification. The gates do not replace review: a passing test does not show that a change matches the requirement. They make sure the reviewer's time goes to that question.

Stop rules, the person holding the switch, and rollback

Without a stop rule an agent keeps working while gates fail repeatedly. We suggest at least three triggers: spend per task, time a single task has been running, and the number of consecutive gate failures. At any ceiling the agent stops and hands the task to a person rather than trying again on its own. Set the ceilings from your own past work; we have no neutral figure to give.

Name who holds the switch that stops everything. It should be one person or one rota that everyone knows, with authority to stop without asking for approval, because the moment you need to stop is not the moment to call a meeting.

For rollback, assume agent-made changes are as hard to undo as human ones, only more numerous. Keep each change revertible as a single unit, avoid merging several tasks into one lump, and record which agent produced which change so you know what to revert later. Release and rollback planning at production level is in our article on production change and release management. The same thinking applies, with one addition: agent merges go through the same release path as human work, with no shortcut lane for agents.

What to measure to see that review is the constraint

Do not settle this by feel. Two measures are enough to start, and both can be pulled from your pull request system without new tooling.

  • Age of the oldest unreviewed change: if it keeps growing for several weeks with the same headcount, a queue is building.

  • Share of changes sent back: a high share means earlier gates are not filtering enough. An unusually low share alongside a long queue suggests reviewers are approving too quickly.

Read together they mean something. A long queue with a high send-back share points at the quality of the agents' work; a long queue with a very low share points at review capacity. Neither is a Gartner figure or ours. They are data your own team already produces.

Limits we should state plainly

If your team has a few developers and one agent with ordinary review, a full harness is more overhead than benefit. The queue from one agent is something people can still read, and every added layer of control becomes work to maintain. The case for a harness grows with the number of agents and with the cost of a wrong merge: systems that handle money, personal data, or that cannot go down. For the small case, we think the basic gates in your existing pipeline and a clear rule on who presses merge are enough.

Objections we often hear

A common one is that if an agent can write the tests, another agent can review instead of a person. A second agent is a useful first pass and we would use it. But a reviewing agent works from the same information and assumptions as the one that wrote the change, so it can miss the same things. We see it as an extra gate before a human, not a replacement, for anything that touches data or permissions. How much risk to accept for each kind of work is your organisation's decision.

Where to start

Start with what costs nothing. Pull the age of the oldest unreviewed change and the send-back share for the last four weeks. Then write one page stating who may merge, who holds the stop switch, and the ceilings for spend, time and failed gates. Separate each agent's environment and credentials before adding the next one. If you are drafting a TOR for a vendor who uses AI to write code, the acceptance checklist linked above covers the handover evidence.

Summary

Before adding the next agent, ask how old today's review queue is. An added agent does not add delivery capacity; it adds work waiting for a person to decide. If the queue is already aging, what you need to add is gates, a merge rule and a stop rule, not another agent.

If you would like to talk through the details of a project, you can reach us at 088-983-9386 or [email protected]. Our office is in Bang Kapi, Bangkok. For organizations still drafting a scope of work, we are glad to arrange a conversation to understand the problem first, without needing complete documents. And if we find that the problem is not yet at the point of needing a new system, we will say so plainly, because starting a project at the wrong time costs more than waiting another quarter.

FAQ: Frequently Asked Questions about This Article

A collection of questions and answers to help you better understand the content of this article.

Tags:

AI coding agent harnessmultiple coding agentsAI code review bottleneckverification gatesparallel AI agents repositoryGartner 2027 tech trendsagent merge policyAI-assisted software delivery
Share:

Other Articles

Stay tuned for upcoming articles!