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

Key Concepts

• Agentic Software: Software development driven by autonomous AI agents rather than manual human coding.
• Continuous Compute: A proposed paradigm shift where infrastructure focuses on high-performance, stateful, and rapid execution of agentic tasks, replacing traditional CI/CD.
• Inner Loop: The iterative cycle of coding, testing, and validating that occurs before a change is finalized.
• Pre-merge Queue: A staging area where multiple agent-generated changes are reconciled and grouped before final human approval.
• Hardware/Software Co-design: Optimizing infrastructure specifically to handle the high-concurrency, stateful demands of AI agents.
• Multiverse Development: A future state where agents work on multiple potential commit versions simultaneously to achieve a goal.

---

1. The Obsolescence of Traditional CI/CD

The speakers argue that traditional CI/CD (Continuous Integration/Continuous Deployment) is breaking under the weight of agentic software.

• The Problem: Traditional CI/CD was designed for human-scale throughput (one or two PRs per week). Agents generate thousands of short-lived branches and commits, leading to "merge hell" and overwhelming human reviewers.
• The Bottleneck: Current systems rely on human-in-the-loop reviews and slow, serialized build/test/deploy pipelines that cannot keep pace with the rapid rate of change introduced by AI.
• Data Point: GitHub activity shows an exponential spike in commits and lines of code added/deleted, proving that human-centric workflows are no longer sufficient.

2. The Proposed Framework: Continuous Compute

The speakers propose a shift from CI/CD to "Continuous Compute," which treats the codebase as a ledger and the development process as a high-performance database problem.

Step-by-Step Methodology:

1. Intent and Planning: Instead of starting with a PR, the process begins with a codified "intent" or "spec" (e.g., a ticket or Slack message).
2. Agentic Harness: An agent (using tools like Cursor or custom harnesses) checks out a well-known commit and begins implementing the plan.
3. Internal Validation: The agent uses existing repository assets to build and test the code incrementally.
4. Continuous Feedback: The agent asks the human for "continue" signals, keeping the human in a supervisory role rather than a manual coding role.
5. Pre-merge Queue: Completed tasks enter a queue where they are semantically grouped and reconciled to ensure serializability.
6. External Approval: Humans review the result (e.g., a video of the feature working or security audit logs) rather than the raw code.

3. Key Arguments and Perspectives

• Hardware/Software Co-design: To support this, infrastructure must move away from generic cloud setups toward specialized, stateful environments. Caching must become the primary orchestration layer.
• Shift in Governance: Governance is no longer a "gate" at the end of a pipeline; it is "lifted" into the agentic harness itself, ensuring compliance and security invariants are enforced continuously during the loop.
• The "Multiverse" Future: As inference speeds increase, agents will eventually work on multiple versions of the codebase simultaneously to find the optimal path to the desired intent.

4. Notable Quotes

• Madison: "We need to be able to serve AI and agentic users first—or we die."
• Hugo Santos: "The act of merging is starting to look a lot like high-performance database problems where you have serialization and you have a single ledger."
• Hugo Santos: "CI no longer has to guide different changes... that needs to be part of the overall loop."

5. Synthesis and Conclusion

The transition to agentic software necessitates a fundamental redesign of the software development lifecycle. The "PR" as a unit of work is becoming obsolete, replaced by continuous, agent-driven loops that prioritize speed, statefulness, and automated validation. While CI/CD principles (like testing and compliance) remain vital, they must be integrated directly into the development loop rather than acting as external, slow-moving gates. The future of development lies in high-performance compute infrastructure that can handle the massive concurrency and rapid iteration cycles of autonomous agents.