CI/CD Is Dead, Agents Need Continuous Compute and Computers — Hugo Santos and Madison Faulkner

The Breaking Point: Why Agentic Software Kills Traditional CI/CD

Traditional CI/CD pipelines were designed for a human-centric workflow, where developers submit one or two pull requests (PRs) per week. This model, with its slow feedback loops involving human reviews and sequential build-test-deploy steps, is fundamentally incompatible with the scale of agentic software development.

When thousands of autonomous agents continuously open PRs, the system collapses. This leads to several critical failures:

• Runner Saturation: The sheer volume of jobs overwhelms the available CI runners.
• Cache Thrashing: With thousands of short-lived branches, caches are constantly invalidated, leading to slow, cold Docker builds for nearly every change.
• Merge Queue Bottleneck: The merge queue, intended to serialize commits, transforms into a high-contention database lock. The “time-to-commit” becomes the primary bottleneck, dramatically slowing down the rate of change for the entire repository.

The recent spike in GitHub activity, with a massive increase in commits and lines of code added, is a clear indicator that this breaking point has already been reached for many teams.

A New Architecture: From Pull Requests to Intent-Driven Loops

To adapt, development must shift from a PR-based model to one centered on “Continuous Compute.” This new architecture begins by eliminating the PR as the primary unit of work.

1. Intent and Plan: The process starts with a codified goal—the “intent and plan.” This could be a spec, a ticket, or a simple description of the desired outcome.
2. The Agent Loop: This intent is fed into an agent harness (e.g., Aider, Cursor, Factory). The agent enters a tight, iterative loop where it checks out the code, implements a part of the plan, and immediately validates its own work.
3. Fast, Stateful Inner-Loop Validation: This “internal validation” (running builds and tests) must be extremely fast and stateful. Waiting minutes for feedback is unacceptable, as it delays the entire agentic process. The environment must retain state (like a developer’s local workstation) to avoid starting from scratch with every iteration.

In this model, the human’s role evolves from a line-by-line code reviewer to a high-level guide who provides simple directives like “continue” to keep the agent moving toward the goal.

The Next Evolution: Pre-Merge Queues and Agentic Review

The next phase of this evolution introduces agents into the review process and changes how code is integrated.

• Agentic External Validation: Human reviewers in the loop are replaced by other specialized agents. For example, a security-focused LLM can provide feedback on vulnerabilities, or an API conformance LLM can check for correctness, all within the agent’s primary loop.
• The Pre-Merge Queue: Fully validated changes do not go directly to the main branch. Instead, they land in a pre-merge queue. This is a staging layer for completed work that is ready for human sign-off.
• Reviewing Intent + Outcome: In the pre-merge stage, humans no longer review diffs. They review the original intent against the final outcome. The outcome could be a video of the new feature working or a report from the security LLM. This allows humans to semantically group multiple changes and approve them in batches, managing the high volume effectively.
• Reconciliation and Serializability: The pre-merge layer is where the system reconciles multiple, parallel changes that may operate on the same parts of the codebase, ensuring they can be serialized correctly back into the Git repository (the “ledger”).

The Future: The Multiverse and the New Role of CI

Looking further ahead, the concept of a single “tip” of the repository will dissolve.

• The Multiverse: Because the main branch will be a constantly moving target with so many changes landing, agents will need to work on multiple candidate commits in parallel to achieve a single plan. This creates a “multiverse” of potential development paths that are explored simultaneously.
• Resource Explosion: This parallel exploration will cause a massive increase in compute resource usage, making performance and efficiency of the inner loop paramount.
• CI Principles Shift Left: CI/CD doesn’t disappear; its principles are integrated directly into the agent’s continuous, inner-loop validation. Governance, compliance, and correctness guarantees (e.g., starting from a well-known, vetted commit) are enforced continuously by the agent harness itself, rather than in a separate, delayed CI phase.

• Tags:
• AI Agents
• Software Development
• Devops
• CI/CD
• Agentic Workflows
• Continuous Compute
• Merge Queue