# CI/CD Is Dead, Agents Need Continuous Compute and Computers

Hugo Santos, Namespace & Madison Faulkner, NEA | AI Engineer Europe 2026 | 18:37

Source: https://www.youtube.com/watch?v=VktrqzQgytY
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/ci-cd-is-dead-agents-need-continuous-compute-and-computers
Published: 2026-05-13
Tags: coding-agents, harness-engineering, human-in-the-loop, software-factories, testing

## TL;DR
- Autonomous agents create far more branches and changes than traditional CI/CD was designed to handle, making verification and merging the main bottlenecks.
- Development is moving toward intent-and-plan workflows where stateful agent loops build and validate changes continuously.
- Human reviewers will increasingly assess the intended outcome and evidence in a pre-merge queue, while agents handle code-level validation and reconciliation.

## Summary
Madison Faulkner and Hugo Santos argue that traditional CI/CD assumes human developers submit a small number of diffs and wait through relatively slow review and validation steps. Autonomous agents change that pattern by producing many short-lived branches and changes at once. This creates cache contention, slow builds, overloaded reviewers, and a merge queue that behaves like a serialized database ledger. Their proposed architecture starts with an intent and plan instead of a pull request. An agent harness checks out a known commit, implements the plan, and runs fast internal validation. Other agents can provide security or API-conformance feedback. The environment must preserve memory and state so each iteration does not start from scratch. Finished changes enter a pre-merge queue, where humans review the intent and result, possibly across several commits. CI remains, but its checks move into every iteration of the agent loop.

## Key ideas
### Agent-generated changes overwhelm workflows designed for occasional human diffs
[02:27](https://www.youtube.com/watch?v=VktrqzQgytY&t=147s)
Traditional CI/CD assumes that a human submits one or two diffs a week. Reviewers inspect the pull request, GitHub Actions runs build, test, and deploy steps, and the developer fixes failures. Agents use the same systems while producing an unbounded number of pull requests across many repositories. Santos describes thousands of short-lived branches pulling the same codebase in different directions. Local caches that stay warm for a human workflow become difficult to manage, and merging the resulting versions can become impossible.

### The first replacement step is faster compute and cache-aware orchestration
[04:08](https://www.youtube.com/watch?v=VktrqzQgytY&t=248s)
Faulkner proposes starting by accelerating the existing CI/CD stack instead of replacing every component at once. Slow build, test, and deploy times already delay agent loops, so the infrastructure needs faster execution over GitHub Actions and similar systems. She describes the cache becoming an orchestration layer that routes work to the right infrastructure. The design also includes ingress shaping, rate limiting, agent identity for software, and retries at scale. She frames hardware and software co-design as necessary for this system.

### Humans already operate as agents through repeated development loops
[07:27](https://www.youtube.com/watch?v=VktrqzQgytY&t=447s)
Santos explains that a human developer starts with an objective, changes code, submits a pull request, responds to formatting feedback, fixes test failures, handles reviewer comments, and may repeat the loop when the merge queue changes. Humans hide machine latency because they produce changes relatively slowly. As code generation gets cheaper and work becomes continuous, evaluation has to move into the inner loop. The time between making a change and committing it becomes more important because the rate of change rises.

### Pull requests become a poor unit of work when feedback must be continuous
[08:50](https://www.youtube.com/watch?v=VktrqzQgytY&t=530s)
A pull request was designed for delayed human review and handoffs between a developer and a reviewer. CI checks for regressions, builds from a known source, detects conflicts, and enforces whether a change is allowed. At agent scale, the merge operation begins to resemble a high-performance database commit. Each change must enter a single ledger, and the merge queue effectively locks that ledger. Santos says the lock takes a long time with humans, while machines can create changes faster, so merge time becomes a serious constraint.

### Intent and plan replace the pull request as the starting point
[10:09](https://www.youtube.com/watch?v=VktrqzQgytY&t=609s)
The proposed workflow begins with a written goal, which may live in a Linear ticket, Slack, or another specification. That intent and plan enters an agent harness such as Claude Code, Amp, Cursor, or Factory. The harness checks out a well-known commit and works through the plan. Internal validation uses the repository's existing build and test assets. The agent then asks the human whether the result looks right or whether it should continue, with Santos saying that "continue" is already a common instruction on his team.

### Agent loops need fast stateful validation and machine-based external review
[11:58](https://www.youtube.com/watch?v=VktrqzQgytY&t=718s)
Santos expects code generation and inference to become faster over the coming weeks and months. Builds and tests cannot take 15 or 45 minutes because that delay affects the entire loop. External review can move to specialized agents, such as a security-focused language model or an API-conformance model, whose feedback is incorporated by the main harness. These loops need memory and state. Recreating the environment from scratch for every iteration would add too much delay. The harness also needs to react when the plan changes or another person lands a change.

### A pre-merge queue lets humans review intent and outcome after agents reconcile changes
[13:49](https://www.youtube.com/watch?v=VktrqzQgytY&t=829s)
Completed work does not immediately enter the repository. It first enters a pre-merge queue that reconciles many changes operating on the same code. The queue preserves serializability before changes enter the repository ledger. Human review happens there, and the reviewer examines the original intent and the result rather than every line of code. Evidence might include a video of the feature working or the output of a security-focused model. Multiple commits or independent agent changes can be grouped into one reviewable result.

### Parallel agents may explore several repository states for one plan
[15:20](https://www.youtube.com/watch?v=VktrqzQgytY&t=920s)
If the inner loop becomes fast enough, agents may apply one intent and plan to several commits at the same time. The repository tip is moving, and there may be multiple plausible starting points. This creates a multiverse of candidate implementations that can be reconciled later. Santos warns that resource usage will rise because the system explores more candidates in parallel. He argues that efficiency will depend on incremental work, persistent environments, and avoiding repeated setup from scratch.

### CI remains, while coordination and governance move into the agent harness
[16:49](https://www.youtube.com/watch?v=VktrqzQgytY&t=1009s)
Santos does not expect CI to disappear. Its checks move into every iteration of the agent loop, so questions such as whether the code works are answered continuously. Invariants still matter, including starting from a known checkout and preventing unvetted code from entering the process. Coordination no longer belongs mainly to CI's commit gates. Governance moves into the harness, which guides changes according to the team's codified rules.

## Notable quotes
- "The PR is kind of used as the unit of work." (08:50)
- "There are no PRs. We start with intent and plan." (10:09)
- "Memory is important. State is important because if you're starting things from scratch all the time, you're just going to delay things even further." (13:10)
- "The time to merge really matters." (08:47)
- "CI still matters, but it's just shifted because the principles of, well, for example, does the code actually work? No longer is a separate phase, but it's just part of this loop." (16:49)

## Tools & references mentioned
- Namespace
- NEA
- Google
- GitHub Actions
- GitHub
- GitHub Copilot
- HashiCorp
- Mitchell Hashimoto
- Fall
- Zed
- Ramp
- Claude Code
- Amp
- Cursor
- Factory
- Linear

## Who should watch
- You run CI/CD for repositories where automated agents are creating many branches or pull requests and the merge queue is becoming the main delay.
- Your team is moving from pull-request-driven development toward agent harnesses and needs a model for validation, state, and human approval.
- You design compute or developer infrastructure and need to think about cache orchestration, persistent environments, and parallel candidate execution.

## Editor's note

From the pack [Software factories](https://aietalks.com/packs/software-factories):

Horthy's factory lost track of what its own code meant. Snyder needs real production cases, and Klaassen improves his process by studying what each run got wrong. Kitaru records those runs so a team can replay selected cases after changing a model, tool or workflow and check the new behavior before the factory sends it back into production.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46)
- [Don't get one-shotted: Use AI to test, review, merge, and deploy code](https://aietalks.com/talks/dont-get-one-shotted-use-ai-to-test-review-merge-and-deploy-code) (Tomas Reimers, Graphite, 05:45)
- [How Coding Agents Change Software Development Forever](https://aietalks.com/talks/how-coding-agents-change-software-development-forever) (Hailong Zhang, 08:50)
- [Containing Agent Chaos](https://aietalks.com/talks/containing-agent-chaos) (Solomon Hykes, Dagger, 23:48)
- [Making Codebases Agent Ready](https://aietalks.com/talks/making-codebases-agent-ready) (Eno Reyes, Factory AI, 15:33)