AI coding agents: why traditional CI/CD is breaking

AI coding agents are autonomous systems that generate, validate, and merge code at machine speed - replacing the human-centric pull request workflow. They expose a fundamental flaw in modern CI/CD: pipelines built for one or two diffs per week cannot handle thousands of concurrent machine-generated commits.

For the past decade, organizations have optimized their development lifecycle around human limitations. Now, as AI coding agents make code generation remarkably cheap and continuous, the very systems designed to protect codebases are shattering under the weight of machine speed.

Research into the engineering practices at the absolute forefront of development - observing how highly technical teams at organizations like Vercel, Zed, and Ramp operate - reveals a stark reality. Traditional CI/CD is practically dead in an agent-first world. The transition from monolithic AI tools to microservice-based autonomous agents is flooding repositories with thousands of concurrent, short-lived branches, making human review mathematically impossible.

CTOs and engineering leaders must now confront a critical architecture decision. Adapting to this shift requires moving away from delayed human feedback loops and adopting stateful, continuous compute infrastructure. Here is why the conventional pull request is obsolete, and how organizations must architect their systems to govern the next wave of synthetic engineering labor.

How AI coding agents collapse human-centric infrastructure

To understand why AI coding agents break existing pipelines, we have to look at the latency inherent in how software is validated today.

Historically, a human developer submits one or two diffs a week. These pull requests (PRs) initiate a well-worn path: colleagues take time to review the code, GitHub actions run build, test, and deploy steps, and the developer iteratively addresses failed test cases. The entire CI/CD pipeline, from local caches to merge queues, was built to accommodate this predictable, low-volume cadence.

At agent scale, this infrastructure collapses entirely. When autonomous agents operate using these exact same systems, they generate an exponential number of pull requests across an unlimited number of repositories. Teams already scaling AI agents through GitHub workflows have documented this spike in commits, alongside a massive divergence between lines of code added versus deleted.

When an agent attempts to pull the same codebase in a thousand different directions simultaneously through short-lived branches, merging these versions becomes a chaotic, unmanageable process.

The problem isn't just volume - it's the fundamental incompatibility of the PR itself. The pull request was designed as a discrete handoff for delayed human feedback. It assumes that a reviewer will eventually look at the code, provide notes, and send the developer back into a slow, methodical loop. When you replace the human developer with a machine capable of instantaneous iteration, forcing it to wait for human bottlenecks neutralizes the value of the automation.

Merge queues as high-performance ledgers

As the rate of change increases dramatically, the act of merging code begins to look less like a collaborative human review and more like a high-performance database problem.

In a highly autonomous environment, your Git repository acts as a single ledger. Every time a change needs to be committed, the system essentially has to lock the database to ensure serialization. When changes are submitted by humans, the time between these locks is vast. When thousands of machine-generated commits are vying for inclusion simultaneously, the opportunity to merge shrinks to milliseconds.

Industry leaders like Mitchell Hashimoto, the former founder of HashiCorp, have pointed out that platforms like GitHub must evolve to serve AI and agentic users first, or they will simply fail to function. The infrastructure required to process this volume necessitates ingress shaping, aggressive rate limiting, and hardware/software co-design where the cache itself becomes the orchestration layer.

If tests take fifteen to forty-five minutes to run, the entire inner loop of the agent is stalled. Validation must move directly into the agent's workflow, executed in seconds rather than minutes, fundamentally shifting how we think about CI/CD.

The new architecture: stateful continuous compute for AI coding agents

To survive this transition, engineering teams are abandoning the concept of the pull request entirely. The new workflow starts with intent and a plan - a specification written in a Linear ticket or a Slack message - which is then passed to an agent harness.

This agent enters an isolated, stateful loop. It checks out a well-known commit, begins writing code, and immediately executes internal validation. It builds and tests its own changes using the assets existing within the repository.

However, for this to work, agents cannot start from scratch every time a loop initiates. They require continuous, stateful environments with persistent memory. Dropping an agent into a stateless, cold environment forces it to re-establish context, severely delaying the compute cycle and wasting expensive inference cycles.

This is where the architecture of the agent layer becomes paramount. Agents are company infrastructure, not just workflow glue or localized API scripts. They require production-grade hosting that is scheduled, audited, and recoverable.

Organizations building autonomous AI agent workflows are already proving this model works - achieving 25x deployment frequency increases by treating agents as persistent infrastructure rather than ephemeral tools.

Agent-to-agent validation and the pre-merge queue

Even with highly optimized internal validation, the loop eventually hits an external barrier: approval. If humans cannot physically review thousands of pull requests, how do organizations maintain code quality and security invariants?

The answer is agent-to-agent validation. External validation is moving away from human engineers and toward specialized AI models.

Within the continuous compute loop, a security-focused LLM might evaluate the code for vulnerabilities, while an API conformance LLM ensures the new services match internal architectural standards. These agents provide instantaneous, continuous feedback directly into the primary coding agent's harness, allowing it to incorporate changes and retry without ever pinging a human. Companies already deploying intelligent code review agents are seeing this pattern yield faster and more consistent reviews than traditional peer feedback.

Because there are too many concurrent changes to merge directly into the repository, successful code moves into a "pre-merge" queue. This queue reconciles the parallel branches to ensure serializability.

It is only at this pre-merge stage that the human re-enters the loop. However, the human is no longer reviewing line-by-line syntax. They are reviewing semantic outcomes. The human evaluates whether the intent matched the result - perhaps by watching an auto-generated video of the feature working, or by reviewing the final security audit log produced by the evaluating agents. The human simply says "continue," and the ledger is updated.

Governing the continuous compute multiverse

As inference speeds continue to accelerate in the coming months, we will see the emergence of what engineering leaders refer to as the multiverse of commits.

Because the tip of the ledger is constantly moving, agents will no longer work on a single static starting point. They will simultaneously explore multiple commit candidates in parallel to address the same plan. Resource usage will naturally blow up as the system computes these parallel realities to find the optimal path to the intended feature.

Governing this multiverse requires a radical shift in how CTOs provision infrastructure. You cannot run parallel, autonomous systems making deep codebase changes through shadow AI or ungoverned vendor APIs. The operational layer beneath this framework must be strictly controlled, highly observable, and fully sovereign.

The key requirement is a single sovereign instance that the entire company can operate from - passing procurement with rigid role-based access controls, comprehensive audit logs, and per-agent permissions. It must provide the isolation of a managed instance while delivering the continuous compute power required to maintain efficiency and governance across thousands of parallel agent loops.

Rethinking software validation for the AI era

CI/CD is not disappearing; it is being digested by the agentic loop. The principles of validation - ensuring code works, preventing regressions, and enforcing compliance - are no longer isolated phases managed by a DevOps pipeline. They are continuous invariants enforced directly within the agent's harness at machine speed.

Engineering leaders who fail to adapt their infrastructure will soon find their human teams entirely paralyzed by the output of their own coding tools. The future of development relies on recognizing that agents are a new class of synthetic labor, and they require a new class of infrastructure to operate.

By moving away from discrete human handoffs and adopting stateful, governed continuous compute environments, organizations can safely harness the exponential velocity of AI coding agents without sacrificing security, compliance, or operational sanity. The time to architect your infrastructure for machine speed is now - before your merge queues lock up for good.