Back to blog
Governed AI

How Many Agents Is Too Many, Without a Governance Layer?

The agent count isn't the number that matters. Here's the actual signal that tells you review can't keep up anymore.


Rows of agent cards streaming toward one reviewer's in-tray, stacking neatly below a dashed capacity line and spilling over it, on an ice grid

Someone always asks the same question once a team’s running more than one or two coding agents: what’s the right number before this gets risky? It’s a reasonable question with an unhelpful answer, because the number itself was never the thing that mattered.

There’s no fixed number; the real signal is whether review keeps pace with proposals. Once agents produce more proposed changes per day than a person can meaningfully check, the team already needs a governance layer, regardless of the actual agent headcount. A team running three agents that each propose two changes a day is in a completely different situation than a team running three agents that each propose forty. Same headcount, opposite reality.

How many agents is too many, without a governance layer?

However many it takes for the volume of proposed changes to outpace what a person can actually review with care, which is a review-throughput question, not a counting question. Two agents proposing a handful of changes a day is easy for one person to check thoroughly. Two agents proposing a hundred changes a day between them isn’t, and the fix isn’t hiring more reviewers, it’s building a rule that decides which of those hundred changes actually need a person’s attention and which ones can clear on their own under clear conditions.

That reframing matters because “how many agents” invites teams to set an arbitrary headcount cap, which solves nothing. A team could stop at three agents and still be badly under-governed if those three are prolific. A team could run eight agents and be perfectly fine if a real tiered rule is already sorting routine changes from the ones that need judgment. The number of agents was never the variable that determined safety. Review throughput against proposal volume always was.

What are the actual warning signs a team has crossed the line?

Three, and they show up in roughly this order. First, rubber-stamped approvals: someone’s still technically reviewing every change, but the reviews get faster and shallower as volume climbs, until “review” means glancing at a diff for two seconds before clicking approve. Second, a backlog of unreviewed changes: proposals pile up faster than anyone gets to them, so things sit in a queue for hours or days waiting on a look that never quite happens. Third, and this is the one that should worry a team most: someone turns off the review step entirely, without telling anyone, just for a specific agent or a specific category of change, to keep the queue from growing further. That’s not a policy decision made deliberately. It’s usually one person, under pressure, making a local fix to a symptom that’s actually a sign the whole approval structure needs to change.

Any one of these three should read as a signal, not a nuisance to route around. A team that notices rubber-stamping starting and treats it as “we just need to review faster” is missing that the actual fix is deciding, calmly, which changes don’t need that level of scrutiny in the first place.

What changes technically once a team is running a fleet instead of a single agent?

A single agent’s mistakes are individually reviewable, one at a time, as they happen. A fleet’s mistakes compound before anyone notices the pattern, because volume makes it harder to see that five separate, individually-plausible-looking changes are actually the same category of mistake happening five times. One agent proposing a wrong change is a single bad call, caught or missed on its own. Five agents each independently making a version of the same category of mistake, say, all treating a particular kind of config change as low-risk when it isn’t, produces a pattern that’s easy to miss when each individual instance looks fine in isolation and gets reviewed (or rubber-stamped) separately from the others.

That’s the specific way scale changes the nature of the risk, not just its volume. A tiering rule that groups changes by category rather than reviewing each one in isolation is what actually catches a pattern like that, because it forces someone to think about “how should we treat this whole category of change” once, rather than re-deciding it ad hoc, differently, every single time an instance of it comes through.

What does a tiered rule actually buy back?

Review time, spent on the changes that genuinely need judgment instead of spread thin across everything indiscriminately. A tiered rule decides, once, which categories of change can clear automatically because they’re small and easily reversible, and which categories always wait for a person because they create a real commitment: an ownership change, a priority flip, anything touching a security-relevant default. Once that line is drawn, the volume problem changes shape. A person isn’t reviewing every proposed change anymore; they’re reviewing the smaller subset that was actually flagged as needing a real decision, while everything else moves through a rule that was set deliberately, not under the pressure of a growing queue.

Five agents, one inbox

Take a concrete version of the volume problem. Five agents are running across a mid-sized engineering team: one on bug triage, one on test coverage, one on dependency updates, two on feature work. Each proposes roughly one ticket update an hour during the workday. That’s forty or more proposed changes a day, all routed to one engineering manager’s review queue, with no tiering at all.

Before a tiered rule: every one of those forty changes needs a look. By midafternoon, the queue has thirty items in it. The reviewer starts skimming faster just to keep the number from climbing further, which is rubber-stamping by another name. A dependency bump that also changed a default timeout, with nothing calling that out, gets the same two-second glance as a priority change that should have prompted a real conversation. Nothing about this is anyone being careless; it’s what happens by default once volume outpaces the time available to look carefully at each item.

After a tiered rule: the same five agents propose the same forty changes. Routine ticket updates, status changes, and reversible config tweaks clear automatically under a rule the team set in advance. Priority changes, ownership changes, and anything touching a customer-facing default still route to the reviewer, but now that’s six or seven items a day instead of forty, each one actually worth the attention it gets. The agent count didn’t change. What changed is that the review queue only contains the changes that were ever going to benefit from a careful look.

Before tiering After tiering
Proposed changes per day ~40, all requiring review ~40 total; ~6-7 actually reach a person
Review quality Degrades as volume climbs; rubber-stamping by midafternoon Consistent, since the reviewer only sees what genuinely needs judgment
What a person misses A pattern across several fast-reviewed, individually-plausible changes Nothing new; the tier line was drawn deliberately, not under pressure

What does “too many” actually look like, compared to a governed setup at the same headcount?

The same five agents, the same forty daily proposals, and two completely different outcomes depending on whether a tiering rule exists. “Too many” isn’t a property of the agent count; it’s what happens when volume outruns an ungoverned review process, at whatever headcount that happens to occur. Research on human-in-the-loop oversight breaking down under volume backs this up directly: approval quality degrades with volume regardless of how careful or well-intentioned the human reviewer is, because sustained careful judgment doesn’t scale linearly with how many things need judging. The fix was never asking a person to review faster. It’s deciding in advance, through real guardrails, which categories of change need that person at all.

That’s also the argument for treating this as a governance question rather than a staffing question. Adding a second reviewer to handle the same forty daily changes just delays the same failure mode; two tired reviewers rubber-stamp changes almost as readily as one. A real governance layer fixes the actual mechanism, not the headcount on either side of it.

FAQ

Is there a rule of thumb for agent count that’s generally safe?

No, and treating one as safe is itself a risk. Three low-volume agents can be fine with light review; three high-volume agents can overwhelm the same reviewer. Proposal volume against review capacity is the number that matters, not agent count.

What’s the fastest sign a team should check for right now?

Whether review time per change has been shrinking as volume grew. If reviews are getting faster without the changes themselves getting simpler, that’s rubber-stamping starting, and it’s worth catching before it becomes the default.

Does adding more human reviewers solve this?

It buys time, not a fix. More reviewers handling the same undifferentiated volume eventually hit the same wall, just later. Tiering which changes need a person is the structural fix; adding reviewers is a delay.

Does a tiered rule mean less oversight overall?

No, it means oversight goes to where it actually matters. Routine, reversible changes clearing automatically isn’t less oversight, it’s oversight allocated to the changes that create real risk instead of spread evenly across everything.

How would a team know what belongs in which tier?

By deciding, calmly and in advance, which categories of change create a real commitment (ownership, priority, security-relevant defaults) versus which are small and easily undone. That decision is specific to each team’s own codebase and workflow.

Curious what your agents would build with Thor’s context instead of a raw tool read? Try Thor free.

Related Posts