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

Summary

In this presentation, Madison and Hugo discuss why traditional CI/CD pipelines are becoming obsolete in the age of agentic software and propose 'continuous compute' as the next evolution. They explain how the surge in automated code generation and autonomous agents overwhelms human-centric CI/CD processes, creating bottlenecks in testing, merging, and validation. By shifting to a stateful, agent-driven loop with rapid internal and external validation, the development cycle becomes faster, more efficient, and scalable. This approach integrates hardware-software co-design, pre-merge queues, and multi-agent orchestration, maintaining governance while enabling high-performance, continuous development in modern software ecosystems.

Takeaways

• 💡 Traditional CI/CD is becoming insufficient for modern, agent-driven software development due to human-centric workflows and slow PR processes.
• 🤖 Agentic software generates high volumes of code changes, which overwhelm traditional CI/CD pipelines and make merging extremely complex.
• ⚡ Continuous compute is proposed as the next evolution, where fast, stateful loops handle code generation, validation, and merging automatically.
• 🧩 The new architecture emphasizes agent-driven loops with internal validation, caching, and orchestration layers to maintain efficiency.
• 📊 Merge queues resemble high-performance ledgers, requiring serialization and careful coordination to handle parallel agent contributions.
• ⏱ Speed is critical: builds, tests, and merges must be extremely fast to support continuous, agentic iteration without bottlenecks.
• 🔄 External validation shifts from humans reviewing code to humans approving intent, with specialized agents checking compliance, security, and API conformance.
• 🗂 Pre-merge queues organize multiple agent-generated changes semantically, allowing humans to manage the overall result rather than individual commits.
• -
• 🏗 CI principles are not gone but integrated continuously into the loop, ensuring code correctness, compliance, and invariant enforcement at every iteration.
• -
• 🌐 Future systems may operate in a 'multiverse' mode, where agents explore multiple candidate commits simultaneously to achieve the intended plan quickly.
• -
• 💾 Statefulness is essential: preserving context avoids redundant work and accelerates iterative development cycles for both internal and external validation.

Q & A

Why do the speakers believe traditional CI/CD is becoming inadequate?

Traditional CI/CD pipelines are designed for human-scale development, with a limited number of pull requests and manageable review loops. With agentic software generating massive numbers of automated PRs and repositories, these pipelines struggle to handle the volume, leading to delays and merge conflicts.

What is 'agentic software' as described in the transcript?

Agentic software refers to systems where autonomous agents, often powered by AI or LLMs, perform coding, testing, and deployment tasks. These agents act continuously, executing software development at scale and reducing the reliance on human developers for routine tasks.

How does the life cycle of software development change in an agentic world?

The life cycle becomes fragmented and accelerated. Instead of slow human-led PRs and review cycles, autonomous agents generate numerous changes in parallel, requiring continuous orchestration, validation, and merging, often in a stateful and incremental manner.

What role does caching play in the proposed continuous compute approach?

Caching acts as a critical orchestration layer, allowing repeated builds and tests to reuse prior computations. This reduces redundant work, speeds up validation loops, and ensures agents can work efficiently at scale without starting from scratch each time.

What is a 'pre-merge queue' and why is it necessary?

A pre-merge queue is a staging area where multiple agent-generated changes are reconciled and organized before being committed to the main repository. It ensures serializability, prevents conflicts, and allows humans to review aggregated results rather than individual PRs.

How does internal and external validation work in the new system?

Internal validation is automated within the loop, using builds and tests to ensure changes meet invariants. External validation involves other agents, such as security or API conformance LLMs, providing feedback before human approval, eliminating the bottleneck of human review.

What does 'statefulness' mean in the context of continuous compute?

Statefulness refers to maintaining context and memory across iterations of agentic loops. By keeping track of previous results, builds, and intermediate states, the system avoids redundant computation and accelerates the development process.

Why do the speakers argue that CI hasn’t disappeared but evolved?

CI principles—validating code correctness, enforcing invariants, and ensuring compliance—remain essential, but they are now integrated continuously into agentic loops rather than as a separate phase. Validation happens with every iteration automatically.

What challenges arise when multiple agents work on the same repository simultaneously?

Simultaneous agent activity can lead to conflicts, redundant work, and complexity in merging changes. To address this, continuous compute systems use pre-merge queues, serializability mechanisms, and orchestration strategies to ensure consistent and conflict-free integration.

How does continuous compute propose to handle the acceleration of development and high volume of changes?

Continuous compute leverages high-performance infrastructure, agent harnesses, stateful loops, caching, and automated validation to process large volumes of changes quickly. By reducing human bottlenecks and enabling parallel agent workflows, it maintains efficiency at scale.