Your Agents Don't Sleep. Your CI Pipeline Wasn't Built for That

The pitch for background agents is hard to argue with: hand off a task at 6 p.m., come back to a pull request at 9 a.m. Engineers who've made it work describe it as the biggest change to their day since version control.

The reports from teams that scaled it up this month sound different. CI queues backed up with hundreds of pull requests nobody has looked at. Test runners saturated overnight. Compute and token bills with an extra digit, discovered the next morning. The agents did what they were told. The system around them had no idea they were coming.

In June I wrote that code review had become the new bottleneck. Background agents move it again — one step earlier, into the pipeline itself.

The rate limit you didn't know you had

Every delivery pipeline was sized around an unstated assumption: pull requests are opened by people, and people are slow. An engineer opens a few PRs a day, during working hours, and watches each one go through. Your runner capacity, your test suite's runtime, your flaky-test tolerance — all of it was tuned to that pace.

A background agent has no pace. It opens a PR, CI fails, it pushes a fix, CI runs again, and it'll repeat that loop a dozen times without anyone watching. Multiply by every engineer who queued three tasks before leaving, and your pipeline sees a week of human load in a night.

The data on what arrives is mixed in a useful way. Microsoft's study of its own early-2026 rollout of command-line agents found that developers who used them regularly merged about 24% more pull requests — a real gain. Research on agent-authored PRs in open source finds they tend to be larger, touch more files, and fail CI more often than human ones. Both are true. More good work gets through, and it arrives surrounded by a lot more load.

Four controls that pace the work

None of these are exotic. They're the limits humans imposed on themselves by being human.

A pre-CI gate. The agent should run lint, type checks, and the relevant unit tests inside its own sandbox, and only open a PR when they pass. Shared CI is for confirming a change, not for the agent's trial and error. This one step removes most of the queue.

A concurrency cap. Limit open agent PRs per repo and per engineer; the rest wait. It feels like throttling productivity. It's the same reason you limit work in progress on a board — unfinished work is inventory, not output.

A per-task budget. Every delegated task gets a token and compute ceiling. When the agent hits it, it stops and reports what it tried. An agent that's still looping after its budget is gone isn't close to done; it's stuck, and the sooner a person sees that, the cheaper it is.

Blast-radius triage. Stop reviewing every agent PR the same way. Low-risk changes — dependency bumps, test additions, contained refactors — merge on green checks. Schema migrations, security boundaries, and public API contracts get a human who knows the system. Review attention is the scarcest thing you have; spend it where a mistake is expensive.

Change the number you watch

Most teams running background agents track how many PRs the agents opened. That number goes up no matter what, which is what makes it useless.

The one worth tracking is cost per merged change: tokens plus compute plus review time, divided by what actually shipped. It rewards the agent that gets it right in one pass over the one that brute-forces through CI eleven times. And with usage-based billing now standard, it's also the number your finance team is about to ask for.

The mid-size advantage

Large companies will solve this with a platform team and a merge queue rebuilt for agent traffic. A 50-engineer team can solve it in a sprint: a sandbox config, two limits, a budget setting, and a one-page triage rule.

Agents that work while you sleep are worth having. They just need the thing every other producer in your system already has — a limit.

Finding where unattended agent work is piling up in your pipeline is part of what our AI readiness assessment looks at.