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

Hugo Santos, Namespace · Madison Faulkner, New Enterprise Associates (NEA)

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/VktrqzQgytY-ci-cd-is-dead-agents-need-continuous) · [Video](https://www.youtube.com/watch?v=VktrqzQgytY)

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

When agents generate changes faster than teams can validate and merge them, development needs persistent compute, faster feedback, and a new way to reconcile concurrent work.

Familiarity with Git commits, pull requests, build and test pipelines, and coding agents will help you follow the architecture.

### What happens when code generation outruns CI?

[0:18](https://www.youtube.com/watch?v=VktrqzQgytY&t=18s)

What happens to build, test, and deploy infrastructure when the developers producing changes are agents? The proposal behind continuous compute is that faster code generation changes the shape of the development workflow, not just the number of jobs its runners must execute. Madison Faulkner introduces that proposal as an NEA partner focused on infrastructure and developer tools, describing her earlier work as a Meta AI researcher leading data and AI teams. Her co-presenter, Hugo Santos, is CEO of Namespace, which builds high-performance compute infrastructure; he previously led microservices at Google.

The starting architecture treats an LLM as one monolithic engine. As agents take on distinct responsibilities, that architecture begins to resemble microservices: multiple agents participate in software development rather than one model doing everything. They enter an already fragmented lifecycle containing planning tools, IDEs, autonomous engineering systems, traditional DevOps, and separate build, test, and deployment systems. Accelerating one participant does not automatically accelerate the connections between them.

![Slide titled “Software Development Lifecycle Now,” with tool logos grouped into six boxes and a horizontal arrow through the middle.](https://ai.engineer/api/talk-essay-media/10d727ec0b1ccb195493395b297eaa781efa7e75bdfbcf60b6ca7430dc71327a)

The software development lifecycle spans planning, testing, deployment, monitoring, IDEs, and autonomous agents.

### More branches, the same verification bottleneck

[2:20](https://www.youtube.com/watch?v=VktrqzQgytY&t=140s)

The familiar pipeline starts with a human submitting a diff. Colleagues review the pull request, GitHub Actions runs build, test, and deployment steps, and a failed test sends the developer back to revise the change. Faulkner's illustrative human baseline is one or two diffs per week. Replace the human with agents producing N pull requests across potentially N repositories, and verification still takes roughly the same time unless the review process changes too. Review bots can help, but they introduce another moving part.

| Workload | Human development | Agent development |
|---|---|---|
| Work pattern | Relatively predictable | Many short-lived branches |
| Cached state | Often warm locally | Harder to preserve across branches |
| Integration | Fewer concurrent changes | Many changes pulling shared code in different directions |

The difficulty is not simply provisioning more runners. Thousands of short-lived branches can compete over the same codebase, making their eventual reconciliation increasingly difficult.

![Two charts contrast steady human read/write activity with spiky agent activity. Bullets describe predictable queues and warm local caches versus short-lived branches, runner queues, and cache misses.](https://ai.engineer/api/talk-essay-media/e1ed038e7e0d2ccf7454ee9b51ee3152f2ff7b5eb55e5b74b26ac203aceedf38)

Human and agent workloads produce different cache read/write patterns.

Faulkner points to a GitHub activity chart as a sign of this pressure: a white line represents commits, alongside lines added and deleted, with a pronounced recent spike. She gives no numeric magnitude for it. The architectural question is how to absorb bursts of generated work without turning validation and merging into an ever-growing backlog.

### Start with acceleration, then change orchestration

[4:01](https://www.youtube.com/watch?v=VktrqzQgytY&t=241s)

The first step is incremental: accelerate the build, test, and deployment infrastructure underneath existing workflows, including GitHub Actions. In Faulkner's proposed architecture, **the cache becomes an orchestration layer**. Hardware and software must be designed together so work can reach the infrastructure that can execute it efficiently.

That path introduces several responsibilities in sequence:

1. **Shape intake.** Apply ingress shaping and rate limiting before bursts overwhelm the system.
2. **Route through cached state.** Use the cache when deciding which infrastructure should receive the work.
3. **Manage agent identity and retries.** Extend orchestration to identify agentic software and handle repeated attempts at scale.

These are responsibilities around the execution loop, not merely faster versions of individual CI steps.

The pressure extends to code hosting. Faulkner cites a proposal she attributes to HashiCorp founder Mitchell Hashimoto for fixing GitHub. In her account, it includes shutting down Copilot, adapting GitHub to the cloud era, and enabling inference at scale. She connects that criticism to calls for services that prioritize agent users and more agent-friendly code storage. Existing CI/CD frustration is the starting point for a broader infrastructure redesign.

### Human latency used to hide machine latency

[6:11](https://www.youtube.com/watch?v=VktrqzQgytY&t=371s)

Santos grounds the transition in Namespace's work with companies including fal, Zed, and Ramp. Looking back roughly six months from the talk, he describes a workflow in which people wrote code, packaged changes into pull requests, and waited for validation. Slow machines were tolerable because their latency was hidden behind the time humans spent writing and reviewing. As code generation becomes cheap and work becomes continuous, validation has to move into the inner loop.

The human was already acting as the agent: holding an objective in mind and carrying it through repeated feedback cycles. A pull request fails the team's formatting requirements, so the developer revises it. Tests fail, requiring another edit. A reviewer requests a different API, sending the developer around again. Finally, another contributor merges first, and the merge queue forces another pass. Each round prolongs the interval between starting work and integrating it.

At human speed, that interval can be relatively long because there are only so many concurrent changes. As the rate of change increases, the **opportunity to merge** becomes a central constraint: the repository continues moving while each candidate change is being prepared.

### Keep validation; rethink the unit of work

[8:43](https://www.youtube.com/watch?v=VktrqzQgytY&t=523s)

A pull request is a unit of work designed for human review. It assumes delayed feedback and discrete handoffs: send the change to a reviewer, wait, and receive it back. CI performs necessary checks within that arrangement: whether the change introduces regressions, whether it builds from a known source, whether concurrent changes conflict, and whether the change is allowed. Those requirements survive even if the pull request stops organizing the process.

With reviewers overwhelmed, merging starts to resemble a high-performance database problem. Santos uses a single ledger and a lock required to commit as an analogy for serialized integration. Machine-paced development needs a much shorter integration window than human-paced development. The analogy concerns ordering changes into shared history; it does not establish that GitHub holds a database lock throughout validation.

### From a written goal to a validated change

[10:00](https://www.youtube.com/watch?v=VktrqzQgytY&t=600s)

Santos describes a workflow his team and other early adopters already use without pull requests as the organizing unit. It begins with **intent and plan**: write down the goal as a specification, perhaps in a Linear ticket or Slack message. Feed that specification into an agent harness such as Claude Code, Amp, Cursor, or Factory. Namespace often uses Amp. The harness checks out the repository and starts implementing the plan.

The checkout must begin at a well-known commit. The agent then uses the repository's existing build and test assets for **internal validation**. A minimal shell boundary for a repository with a Makefile can make that sequence explicit:

```bash
#!/usr/bin/env bash
set -euo pipefail

: "${BASE_COMMIT:?Set BASE_COMMIT to the vetted starting commit}"
: "${WORK_DIR:?Set WORK_DIR to a new worktree path}"

base=$(git rev-parse --verify "${BASE_COMMIT}^{commit}")
git worktree add --detach "$WORK_DIR" "$base"
printf 'Starting commit: %s\n' "$base"

cd "$WORK_DIR"
"${EDITOR:-vi}" .
make build
make test
```

Here the editing step stands where the harness applies the plan; the build and test commands use repository-defined targets. Resolving `BASE_COMMIT` identifies the starting revision—it does not itself establish that the revision was vetted.

After internal validation, the agent asks the human whether the result looks right or needs further work. Approval or another instruction sends it forward or around the loop again; Santos describes “continue” as a frequent response. Eventually, completed work enters the merge queue and then the Git repository, which serves as the ledger.

![Diagram titled “today: human in the loop,” showing Intent + Plan entering a circular flow of Code, Internal Validation, and External Validation, with Invariants above Code and an exit toward Merge and Ledger.](https://ai.engineer/api/talk-essay-media/cc3683ceae1a212247cd6721cec28d720a538842ab1787a38299bf34ce92bf45)

A human-in-the-loop workflow connects intent, code, validation, merge, and a ledger.

This arrangement is faster, but human **external validation** remains on the critical path. That remaining delay motivates the next architecture.

### Validators inside a persistent working environment

[11:59](https://www.youtube.com/watch?v=VktrqzQgytY&t=719s)

Santos forecasts the next transition over weeks to months from the talk, rather than years. Faster inference makes slow validation increasingly expensive because the entire generation-and-feedback loop waits for it. He uses 15-minute and 45-minute test runs as examples of unacceptable loop delays, not measured Namespace results.

In this proposed loop, other agents take over external validation:

- **Security evaluation:** a security-focused LLM examines the change and returns findings.
- **API conformance:** an LLM checks whether the implementation follows the required API contract.

The main harness incorporates their feedback into the code and iterates. The evaluators become active participants in development instead of reviewers waiting at a later handoff.

**Persistent state makes rapid iteration possible.** Starting the environment from scratch on every attempt adds delay, so the loop needs memory and retained working state. It also receives signals from outside: the plan changes, or another contributor commits a change. The harness adapts its intent and plan, then begins another cycle. Even when implementation is complete, the result does not immediately enter the repository; the team has not yet accepted it.

### Reconcile parallel work before asking for approval

[13:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=827s)

Completed changes enter a proposed **pre-merge queue**: work that could otherwise have merged waits while the system reconciles concurrent edits. Many agents may have modified the same parts of the codebase. Their individually completed results must become a sequence that can enter the repository ledger coherently. Santos frames that requirement as **serializability**. The pre-merge layer is a proposed architecture, not an established product feature in this account.

Human approval comes after that reconciliation and focuses on intent and result rather than inspecting every code change. Evidence might be a video of a working feature or the output of a security evaluator. The approval unit can span several commits or independently developed features, grouped semantically into something a person can assess.

Santos reports that his team's volume of work equivalent to former pull requests is four times its previous level. That is an internal work-volume observation, not a measured productivity gain; he supplies no baseline period or counting method. Its practical consequence for his team is that a human reviewer cannot inspect every former PR-sized unit individually.

### The same plan against several possible futures

[15:21](https://www.youtube.com/watch?v=VktrqzQgytY&t=921s)

Further out, Santos imagines a “multiverse” of candidate repository states. If the ledger tip moves quickly enough, the latest commit may no longer be the only useful starting point. Agents could apply the same intent and plan to multiple candidate commits simultaneously, exploring implementations against several possible integration states. This remains a forecast.

That exploration requires extremely fast inner loops and substantially more capacity: each additional candidate consumes resources. Efficiency therefore depends on avoiding unnecessary work, preserving state instead of restarting, and making incremental progress much as engineers do during a working session. Persistent compute is especially consequential when several candidate futures are being developed at once.

### CI's guarantees become continuous

[16:49](https://www.youtube.com/watch?v=VktrqzQgytY&t=1009s)

**CI does not disappear; validation becomes part of every iteration.** Checking whether the code works moves from a separate phase into the ongoing development loop. Provenance requirements remain too: for compliance, a checkout must begin from a known revision rather than from unvetted code that someone inside the company happened to introduce. Those invariants need continuous enforcement.

Coordination moves out of a separate CI process and into the overall loop, where changes and their passing tests are managed together. Governance also remains, but more of it lives in the harness: the harness steers each change toward the requirements the team has codified. Continuous compute changes where these guarantees are enforced and how quickly feedback arrives, while retaining the obligations to validate, control provenance, and govern the resulting software.

![Slide titled “Why CI matters mattered,” with “matters” struck through. A white panel lists validation, enforcing invariants, coordination, and governance; coordination is crossed out and the other three have thumbs-up symbols.](https://ai.engineer/api/talk-essay-media/c6053cb0032bb764626dcd1988c18a885652b12ab65f1171f575e2a44efa45ab)

Validation, enforcing invariants, and governance remain; coordination is crossed out.

## Resources

- [Namespace: CI/CD is Dead, Agents Need Computers](https://www.nea.com/blog/namespace-cicd-is-dead-agents-need-computers) — Madison Faulkner and colleagues explain the agent-compute thesis, incremental builds, and integration with existing development tooling in NEA's investment announcement.
- [Namespace Documentation](https://namespace.so/docs) — Current guides for agent development environments, GitHub Actions runners, compute, and caching infrastructure.
- [Managing a merge queue](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue) — GitHub's guide to validating queued changes together, configuring concurrent checks, and connecting merge queues to CI.
- [Introducing Namespace](https://namespace.so/blog/introducing-namespace) — Hugo Santos's 2022 account of Namespace's origins, with a notice explaining its subsequent shift toward specialized developer compute.

## Slides

### AI Engineer Europe

[0:00](https://www.youtube.com/watch?v=VktrqzQgytY&t=0s) [AI Engineer Europe logo in white on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/099222ed3a40508baa117281b8765de70d74bc7dbd514791aa20e7c7d38d1c4f.webp)

AI Engineer
EUROPE

### Presenting sponsor

Google DeepMind is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=VktrqzQgytY&t=5s) [Google DeepMind presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/0a32cbb58b6822e295ab4c136bd2ae5d36bfdb8508b821c9872d22ee4223761d.webp)

PRESENTING SPONSOR

Google DeepMind

### Platinum sponsors

Braintrust, WorkOS and OpenAI are the platinum sponsors.

[0:10](https://www.youtube.com/watch?v=VktrqzQgytY&t=10s) [Platinum sponsor logos for Braintrust, WorkOS and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/068db942bae916ee114ab74a77bcd605b2490722dfb792b2cfe6c14d73f1e10e.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Madison Faulkner and Hugo Santos

Madison Faulkner is an NEA partner focused on infrastructure and developer tools and a former Meta AI researcher. Hugo Santos is CEO of Namespace, which builds high-performance compute infrastructure.

[0:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=47s) [Speaker introductions with portraits of Madison Faulkner and Hugo Santos and their affiliation logos.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b231dedb7806271375d89c9156a60de7630c06cc7e5d63ae70ff24ec15b4db3.webp)

Madison Faulkner
NEA   Meta   Stanford University

Hugo Santos
N_   Google

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
Google DeepMind

### Agentic Software is Breaking Traditional CI/CD

The talk introduces why agentic software is breaking traditional CI/CD.

[1:26](https://www.youtube.com/watch?v=VktrqzQgytY&t=86s) [Title slide introducing agentic software and traditional CI/CD.](https://assets.ai.engineer/sites/aiecode2025/sha256/38973caaca0f5e684095080eb71ccc14da1db0b381e92b2f5aa4a49e772cae1b.webp)

Agentic Software is
Breaking Traditional CI/CD

namespace
AI Engineer EUROPE

Interface text:
AIE
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Foundation models are decomposing into agents

The slide contrasts a monolithic agent, where the LLM drives the workflow, with a microservice model that assigns subtasks to agents and uses LLMs as tools. An orchestration layer coordinates the work and collects results.

[1:32](https://www.youtube.com/watch?v=VktrqzQgytY&t=92s) [Flowcharts compare monolithic agents using an LLM as the engine with microservice agents using an LLM as a tool.](https://assets.ai.engineer/sites/aiecode2025/sha256/868744fd1161c3a2a32e5c03459ada0dd542ce8aab93b04d0661d549c51f7d3a.webp)

Foundation models are decomposing into agents

Model 1: Monolithic Agents
(LLM as the engine)

User Query
System receives a complex query or task

LLM Query Understanding
LLM analyzes query to determine steps

Query Planning
A sequence of actions is planned to address the query

Tool Selection
Appropriate data services/tools are chosen

Execution
Plan is carried out, interacting with various tools as needed

Data
Structured
Unstructured

Result Synthesis
LLM Results from multiple steps are combined into a response

LLM Response Generation
User Response

Memory Update
The interaction is stored for future context

Model 2: Microservice Agents
(LLM as a tool)

Aggregate & Respond
Orchestration layer combines outputs and delivers the completed task result

Client
Human or agent

Query / Task
System receives a complex task or query

Orchestration Layer
Break down the task

Assign Subtasks
Relevant agents are identified and tasked concurrently

Control Plane
Monitor & Manage

Message Queue
Agents share results

Collect Results

Deliver Subtasks
Relevant agents are identified and tasked

Data
Tools (incl. LLMs)
Return Results

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025
4

Interface text:
AIE
AI Engineer Europe
AI Engineer Europe 2026

### Software Development Lifecycle Now

The software lifecycle spans planning, building, deployment and monitoring, with DevOps across the middle. New IDEs and autonomous agents add to what the speaker describes as a fragmented landscape.

[1:56](https://www.youtube.com/watch?v=VktrqzQgytY&t=116s) [A landscape of software tools across planning, building, deployment, monitoring, IDEs, autonomous agents and DevOps.](https://assets.ai.engineer/sites/aiecode2025/sha256/5912b7d683e552ede7061f18e26ac8b25f4615e73c5240968895a0ae30a56db7.webp)

Software Development Lifecycle Now

Plan & Code
ATLASSIAN
Bitbucket
GitHub
Linear

Build, Test, & Integrate
Dagger
BrowserStack
POSTMAN
bauplan
E2B
Daytona
snyk
Entire
ARCADE
Composio
NEON
namespace

Release & Deploy
LaunchDarkly
harness
STATSIG
TENSORZERO

DevOps
GitHub Actions
GitLab
Microsoft Azure
harness
namespace
armory
circleci
EARTHLY
depot

Operate & Monitor
DATADOG
dynatrace
new relic
PagerDuty
splunk>
sumo logic

IDE
Windsurf
CURSOR
Claude
warp

Autonomous Agent
FACTORY
Cognition
Augment

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
AI Engineer EUROPE 2026

### Explain to me why CI/CD is dead

The speakers introduce their case that CI/CD is dead, starting with how pipelines work today.

[2:21](https://www.youtube.com/watch?v=VktrqzQgytY&t=141s) [A section slide asks why CI/CD is dead.](https://assets.ai.engineer/sites/aiecode2025/sha256/52f98bb8ce540a5de06170a375b55b0ed5cd5f7f62cb2dc72b8c1aff6dd8490b.webp)

Explain to me why CI/CD is dead

namespace
AI Engineer EUROPE

### How CI/CD pipelines work today

A developer submits roughly one diff a day to one repo. GitHub Actions runners build, test and deploy the changes, returning failures to the developer. The slide estimates ~10 minutes to verify each PR.

[2:25](https://www.youtube.com/watch?v=VktrqzQgytY&t=145s) [A developer submits changes to a repository, which uses a runner for build, test and deployment; failed tests return to the developer.](https://assets.ai.engineer/sites/aiecode2025/sha256/d73667b211769d344477af6cd1396dd51650b9833f6116e82293d1c67c4997c5.webp)

How CI/CD pipelines work today

Human developer with repo permissions submits ~1 diff a day to 1 repo

1 Repo

Each PR takes ~10 minutes to verify

Runner

Human developer addresses failed test cases

GitHub Actions uses runners to run build, test, and deploy steps

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE

### Where CI/CD fails at agent scale

Agents submit PRs across multiple repositories and correct failed pipeline cases. Each PR still takes about 10 minutes to verify, while GitHub Actions runners build, test, and deploy the changes.

[2:50](https://www.youtube.com/watch?v=VktrqzQgytY&t=170s) [Agents submit pull requests to multiple repositories, which use runners to build, test and deploy changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/5de7775084b741c20eeede3a2be45a8e47d352581149af34ef99da52984878c0.webp)

Where CI/CD fails at agent scale

Human manages agents with repo permissions which submit N PRs to N repos

Each PR takes ~10 minutes to verify

Repo
Repo
Repo
Repo

Runner
Runner
Runner
Runner

Agents correct failed cases in CI/CD pipelines

GitHub Actions uses runners to run build, test, and deploy steps

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
Engineering the future of AI

### Bursts, fan-out, and ephemerality affect cache activity

Human read/write activity stays relatively steady and local caches are often warm. Agent activity is bursty: thousands of short-lived branches or PRs queue runners, and cache miss rates spike.

[3:14](https://www.youtube.com/watch?v=VktrqzQgytY&t=194s) [Charts contrast steady human read and write activity with bursty agent activity and list their effects on queues and caches.](https://assets.ai.engineer/sites/aiecode2025/sha256/a9b9d76cfa5b6a898fdf677b72b241ef941f6f768678af33b2b1bf7ac3ab644a.webp)

Bursts, fan-out, and ephemerality have material impact on cache read/writes and hit rate over time

# of Read/Writes
Time

Human
▪ One PR/day
▪ Predictable queues
▪ Local caches often warm

# of Read/Writes
Time

Agent
▪ Thousands of short-lived branches/PRs
▪ Runners queue; cache miss rates spike

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
Engineering the future of AI

### GitHub activity over the last three months

Over roughly three months, the white commit line climbs sharply, especially in March. Bars show lines added and deleted alongside it.

[3:41](https://www.youtube.com/watch?v=VktrqzQgytY&t=221s) [A chart shows rising commits alongside lines added and deleted over roughly three months.](https://assets.ai.engineer/sites/aiecode2025/sha256/312b63c6d00d87c019c9f2dce1a213aa59eb6e92380442e4785041c5af428606.webp)

Github activity over the last 3 mos (white line = commits)

Activity Over Time

Left-axis ticks: 800M, 400M, 0, 400M, 800M
Right-axis ticks: 400K, 300K, 200K, 100K, 0
Timeline: Dec 29, Jan 16, Feb 2, Feb 19, Mar 8, Mar 25
Legend: Commits, Lines Added, Lines Deleted

namespace
AI Engineer EUROPE

Interface text:
AIE
AI Engineer EUROPE
Engineering the future of AI

### CI/CD acceleration is the starting point

The proposed agent cache sits between agents and repositories connected to CI/CD runners. The speaker suggests first speeding up existing build, test, and deploy infrastructure.

[4:03](https://www.youtube.com/watch?v=VktrqzQgytY&t=243s) [A diagram places an agent cache between agents and repositories connected to CI/CD runners.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2bc462436d953f3b444a8a929ef3dd1f2fd2218bc316207cb836a8046736190.webp)

CI/CD acceleration is the starting point

Human manages agents with repo permissions which submit N PRs an hour to N repo

Agent Cache

Repo
Repo
Repo
Repo

Runner
Runner
Runner
Runner

Agents correct failed cases in CI/CD pipelines

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
AI Engineer EUROPE 2026

### Caching and orchestration expand into agent identity & more

The proposed workflow shapes incoming requests, caches build artifacts and routes work to suitable runners. It also extends to short-lived agent credentials and retries that fix known failures or surface root-cause hints.

[4:39](https://www.youtube.com/watch?v=VktrqzQgytY&t=279s) [Five columns describe intake, cache, orchestration, identity, and retries for agent workflows.](https://assets.ai.engineer/sites/aiecode2025/sha256/d13995911cf80cfd511b359b0719a90cc6ac5ef31305098cd10c76c51b71b9bf.webp)

Caching and orchestration expand into agent identity & more

Intake
• Ingress shaping & de-dupe code
• Rate-limit upstream calls; coalesce near-duplicate PRs before they hit GitHub/GitLab

Cache
• Global cache orchestration
• Content-addressed caches for dependencies, Docker layers, compiled outputs, test results

Orchestration
• Route to the right runners (self-hosted/cloud, Intel/ARM, GPU) with warm caches
• Avoid emulation for multi-arch (native Intel & Arm speedups)

Identity
• Short-lived creds for agents becoming the Okta for agents
• Pre-flight checks at the edge

Retries
• Parse logs
• Auto-fix known classes (flaky tests, missing cache seeds), otherwise surface RCA hints (GitLab Duo demonstrates AI-RCA).

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025

Interface text:
AIE
AI Engineer EUROPE
2026

### Okay... so is this real?

Public posts debate GitHub’s future as agentic coding infrastructure. Mitchell Hashimoto proposes shutting down Copilot, buying Pierre, and making GitHub a platform for agent interactions.

[5:10](https://www.youtube.com/watch?v=VktrqzQgytY&t=310s) [Public posts discuss GitHub's future as infrastructure for agentic coding.](https://assets.ai.engineer/sites/aiecode2025/sha256/2fec1926b36db6b003e15767b4e3b82e0298d93aaca588cd45c332e18747f924.webp)

Okay... so is this real?

Mat Velloso @matvelloso · Mar 26
I only see two possible futures for GitHub:
1-It becomes the first cloud provider made to serve AI users, riding the Jevons Paradox exponentially.
2-It dies

Mitchell Hashimoto @mitchellh
AI friendly code storage is a GitHub alternative. This is what's going to kill GitHub (whether it's Pierre or something else), because its going to be the critical infrastructure for the next GH which is likely going to be provided by the agentic coding providers.

Gergely Orosz @GergelyOrosz
Outside Microsoft, this news won’t mean much.

Inside MS, I heard Julia was one of those who REALLY cared and knew how to build and run dev tools (that devs love)

There’s a sense that those with “dev tools DNA” at Microsoft’s dev tools division are disappearing. W/o backfill

Tom Warren @tomwarren · 21h
scoop: another veteran Microsoft executive is leaving the company. Julia Liuson, head of Microsoft's developer division (DevDiv), is resigning from the software giant after 34 years. Full details 👇 theverge.com/tech/908793/[illegible]

Mitchell Hashimoto @mitchellh
Here’s what I’d do if I was in charge of GitHub, in order:

1. Establish a North Star plan around being critical infrastructure for agentic code lifecycles and determine a set of ways to measure that.
2. Fire everyone who works on or advocates for copilot and shut it down. It’s not about the people, Im sure theres many talented people, youre just working at the wrong company.
3. Buy Pierre and launch agentic repo hosting as the first agentic product. Repos would be separate from the legacy web product to start since they’re likely burdened with legacy cross product interactions.
4. Re-evaluate all product lines and initiatives against the new North Star. I suspect 50% get cut (to make room for different ones).

The big idea is all agentic interactions should critically rely on GitHub APIs. Code review should be agentic but the labs should be building that into GH (not bolted in through GHA like today, real first class platform primitives). GH should absolutely launch an agent chat primitive, agent mailboxes are obviously good. Etc. GH should be a platform and not an agent itself.

NEA
Proprietary and Confidential / Trade Secrets © NEA 2025
14

Interface text:
AI Engineer Europe
Engineering the future of AI

### CI/CD is dead (it's all agents now)

Hugo Santos introduces his view of CI/CD’s future: “agents all the way down.”

[6:10](https://www.youtube.com/watch?v=VktrqzQgytY&t=370s) [Title slide reading “CI/CD is dead” and “it's all agents now.”](https://assets.ai.engineer/sites/aiecode2025/sha256/72cae6ba4f3657842f53e999de9ca12390dc287767f86519fac83f5313029f3c.webp)

CI/CD is dead
(it’s all agents now)

N_ namespace
AI Engineer EUROPE

Interface text:
AIE
AI Engineer EUROPE

## Full transcript

[0:00](https://www.youtube.com/watch?v=VktrqzQgytY&t=0s) [upbeat music] All right.

[0:16](https://www.youtube.com/watch?v=VktrqzQgytY&t=16s) Can you all hear me?

[0:17](https://www.youtube.com/watch?v=VktrqzQgytY&t=17s) Yes.

[0:18](https://www.youtube.com/watch?v=VktrqzQgytY&t=18s) Great. There we go. All right. Well, we're only thirty-five to forty minutes late, but thank you for sticking around. [chuckles] Um, we're gonna talk about why CI/CD is dead, and we're gonna propose that continuous compute is gonna be the next thing.

[0:38](https://www.youtube.com/watch?v=VktrqzQgytY&t=38s) Maybe. All right. So just quick introduction. We're gonna have two speakers. One's already-- one's getting mic'd up. Um, my name's Madison, and I'm a partner at NEA investing in technology.

[0:52](https://www.youtube.com/watch?v=VktrqzQgytY&t=52s) Uh, I do focus in infra and dev tools, and I formerly used to be a Meta AI researcher. Uh, so I used to lead data and AI teams. I got really frustrated by the state of infrastructure, and so I jumped into venture to do something about it from the top down.

[1:07](https://www.youtube.com/watch?v=VktrqzQgytY&t=67s) And then I'm also gonna, uh, introduce on behalf of my, uh, partner here, Hugo Santos. So he's the CEO of Namespace, which is building high-performance compute infrastructure, and at this point, what we believe is going to eclipse the new CI/CD wave.

[1:22](https://www.youtube.com/watch?v=VktrqzQgytY&t=82s) He also formerly led microservices at Google.

[1:26](https://www.youtube.com/watch?v=VktrqzQgytY&t=86s) Yeah. Uh, great to be here with you folks.

[1:28](https://www.youtube.com/watch?v=VktrqzQgytY&t=88s) So we're gonna talk about why agentic software is breaking traditional CI/CD.

[1:34](https://www.youtube.com/watch?v=VktrqzQgytY&t=94s) Obviously, we're not gonna get through this today, but [chuckles] the point is, on the left side, what started off in, in agentic software was really monolithic agents. Uh, we were really using the LLM as one engine.

[1:48](https://www.youtube.com/watch?v=VktrqzQgytY&t=108s) But now we're moving into the right side, which is microservices, uh, with agents, and that's how we really need to think about software development in an agentic world.

[1:59](https://www.youtube.com/watch?v=VktrqzQgytY&t=119s) So the life cycle, um, is very fragmented. This is quite a mess, right? We've, we've really kind of brought together all these traditional CI/CD systems, build, test, deploy, DevOps, um, but we also now have new IDEs, we have autonomous agentic engineering solutions, um, and then we have our traditional DevOps in the middle, which we believe is really

[2:20](https://www.youtube.com/watch?v=VktrqzQgytY&t=140s) going to innovate in the next year. So let's explain why we think it's dead. So first, how does CI/CD pipelines work today? Well, we all know, human developers are currently submitting one, maybe a, maybe a couple of diffs when they're just writing it themselves, and those PRs then take your colleagues a bunch of time to review.

[2:41](https://www.youtube.com/watch?v=VktrqzQgytY&t=161s) Then you have to go through GitHub Actions and run, build, test, and deploy steps. And then finally, you're addressing this failed test case, and maybe you're iterating on the diff.

[2:49](https://www.youtube.com/watch?v=VktrqzQgytY&t=169s) So in that, in that scenario, it was really, uh, just one or two a week. So now, how do we think of this at agent scale? You've got agents using the exact same systems, but they have, you know, N number of PRs, maybe N number of repos.

[3:05](https://www.youtube.com/watch?v=VktrqzQgytY&t=185s) Still takes a similar amount of time to verify, unless you're using review bots, which gets a little crazy. Um, and then we correct those failed cases just like we did in the p-past scenario.

[3:16](https://www.youtube.com/watch?v=VktrqzQgytY&t=196s) So what ends up happening? With a human, pretty predictable. Um, and you've got local caches, which are often warm. With an agent, this starts to get really complicated. You have thousands of short-lived branches.

[3:29](https://www.youtube.com/watch?v=VktrqzQgytY&t=209s) It's all trying to pull the same code base in a few different directions. You start to get to a point where merging all these different versions together is really impossible, and that is where we start to have a huge problem.

[3:43](https://www.youtube.com/watch?v=VktrqzQgytY&t=223s) So let's look at, in real time, GitHub activity has gotten absolutely crazy. The white line here is the actual number of commits in the last couple of months, and then the number of, uh, lines added versus deleted.

[3:56](https://www.youtube.com/watch?v=VktrqzQgytY&t=236s) I mean, this is just an unbelievable spike.

[4:01](https://www.youtube.com/watch?v=VktrqzQgytY&t=241s) So how do we start with replacing CI/CD? Well, the starting point should be at the acceleration. So obviously, right now, I know a lot of you are struggling with very slow build, test, and deploy times for your CI/CD solutions.

[4:16](https://www.youtube.com/watch?v=VktrqzQgytY&t=256s) This is a very common problem. Um, but where we're headed is being able to first speed that up by inserting over the existing GitHub Actions and other, um, underlying infrastructure for CI/CD.

[4:30](https://www.youtube.com/watch?v=VktrqzQgytY&t=270s) So that cache is really gonna become the orchestration layer in this scenario, and this is really critical to do through a hardware and software co-design.

[4:41](https://www.youtube.com/watch?v=VktrqzQgytY&t=281s) So what does this start to look like, and how does this start to e-eclipse previous CI/CD? So first, we have our intake, um, which requires ingress shaping and rate limiting.

[4:54](https://www.youtube.com/watch?v=VktrqzQgytY&t=294s) Then we move to our cache, and this is the next big step. Um, how do we think about orchestrating and making sure we're routing to the right infrastructure? Uh, from there we can even move into agentic identity for software and thinking about, uh, retries at scale.

[5:13](https://www.youtube.com/watch?v=VktrqzQgytY&t=313s) And then if you don't believe me, let's ask the experts. So Mitchell Hashimoto, one of, you know, the, the, uh, coolest DevRel at scale, he's also the former founder of HashiCorp, uh, wrote exactly what he would do to fix GitHub today.

[5:29](https://www.youtube.com/watch?v=VktrqzQgytY&t=329s) And a lot of this, uh, has to do with even shutting down Copilot, thinking about how do you actually just evolve GitHub to be first in the cloud era, but second, um, actually really enabling, um, inference at scale.

[5:43](https://www.youtube.com/watch?v=VktrqzQgytY&t=343s) And then we've got a number of other data points on the left-hand side, um, that we need to be able to serve AI and agentic users first, um, or we die. [chuckles]

[5:54](https://www.youtube.com/watch?v=VktrqzQgytY&t=354s) And thinking about friendly code storage, uh, solutions that may also help. So there, there's a lot of frustration around existing CI/CD, but this is really just the starting point.

[6:04](https://www.youtube.com/watch?v=VktrqzQgytY&t=364s) We've only just started to see agentic software take over. So now I'm gonna pass it to Hugo to talk more about what a real solution could look like.

[6:11](https://www.youtube.com/watch?v=VktrqzQgytY&t=371s) Yeah. So, um, I'm fortunate, and me and my team, we, we spend a lot of time with companies today that are going from how traditional CI/CD look like into how we think it's going to look at-- into the future.

[6:25](https://www.youtube.com/watch?v=VktrqzQgytY&t=385s) And, uh, giving a little bit of a hint, it's, it's agents all the way down.

[6:30](https://www.youtube.com/watch?v=VktrqzQgytY&t=390s) So we work with, with companies like fal and, uh, Zed and Ramp and many others that are really at the forefront of, uh, everything around development. And you, you probably recognize yourselves, uh, in between these two, um, bits where, uh, up to six months, humans were writing all the code very slowly, uh, and some of them actually

[6:51](https://www.youtube.com/watch?v=VktrqzQgytY&t=411s) fairly quickly, but in hindsight, fairly s- slowly. We package, uh, all these changes in PRs. We do validation as part of those PRs. And, uh, behind the scenes, um, the machines are a little bit slow, but all of that is hidden behind the human latency.

[7:07](https://www.youtube.com/watch?v=VktrqzQgytY&t=427s) And, uh, many of you might already be seeing a bit of what's happening today, where code generation is very cheap, work is much more continuous, and, and that kind of forces the validation to go into the inner loop.

[7:19](https://www.youtube.com/watch?v=VktrqzQgytY&t=439s) It's okay. Um, so what you might not realize is up to this point, uh, you as a human, you are the agent. Uh, you have a stop of mind, "Here's what I'm trying to accomplish, and then I'm going through all of these phases."

[7:36](https://www.youtube.com/watch?v=VktrqzQgytY&t=456s) Uh, okay, I start the pull request. Uh, the pull request within your team says, "Well, you didn't quite follow the right format, so go back to the beginning." You're in a loop.

[7:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=467s) Uh, now your changes, uh, are in the PR. The tests are running, they fail. You need to go and change something in the code. You're back to the loop.

[7:56](https://www.youtube.com/watch?v=VktrqzQgytY&t=476s) Uh, a human reviewer comes back and says, "Well, you know, you didn't quite use the right API. Please go and change it." You're back in the loop. And then when you go and get your code, you're, you're finally done, and you go and merge it, uh, the merge queue says, "Well, you know, some- another colleague managed to

[8:12](https://www.youtube.com/watch?v=VktrqzQgytY&t=492s) get some code ahead of you," and you have to go back in the loop.

[8:17](https://www.youtube.com/watch?v=VktrqzQgytY&t=497s) And, uh, when you're at your human scale, this opportunity to merge, the time that you go from when you're working the code until the code goes into, into the repository, um, can be large, because there's only so many changes that you're doing at the same time.

[8:32](https://www.youtube.com/watch?v=VktrqzQgytY&t=512s) But as you accelerate, this opportunity to merge is really, really important because the rate of change increases dramatically.

[8:43](https://www.youtube.com/watch?v=VktrqzQgytY&t=523s) So, uh, we talked a, a little bit about this. Like, the, a PR, um, is, is kind of used as the unit of work, and, uh, that's what really designed for human review.

[8:53](https://www.youtube.com/watch?v=VktrqzQgytY&t=533s) It's, it's, it's, uh, it, it expects a bit of delayed feedback. It's, it's expected to, to go into kind of discrete handoffs, where you send it over to the reviewer, and then it comes back.

[9:04](https://www.youtube.com/watch?v=VktrqzQgytY&t=544s) Uh, CI matters because it's kind of validating the work that you're doing. Uh, it's doing things like, well, are you introducing a regression? Uh, are you compiling y- and building your code from a well-known source?

[9:17](https://www.youtube.com/watch?v=VktrqzQgytY&t=557s) Uh, are there other changes that are going on that would be conflicting with this change? Uh, is this change allowed? So all of that is kind of part of this validation process that is automated.

[9:27](https://www.youtube.com/watch?v=VktrqzQgytY&t=567s) Um, human reviewers are overwhelmed. Um, you've heard this many times. I don't have to repeat it. And the interesting thing is that this, the, the act of merging, um, is starting to look a lot like, um, high-performance, uh, uh, database problems, where you have serialization, and you have a single ledger where every single change needs to go

[9:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=587s) in, and you need to lock the, the database in or- in order to be able to commit. And the time that you have to lock when there are humans is large, but when there's machines, it's short.

[10:00](https://www.youtube.com/watch?v=VktrqzQgytY&t=600s) So the time to merge really matters. We need a new architecture. Uh, this is already how our team is working today and how we see a lot of the companies working today already, uh, that are at the forefront.

[10:13](https://www.youtube.com/watch?v=VktrqzQgytY&t=613s) Uh, there are no PRs. Uh, we start with intent and plan. This is what we want to achieve, and we codify it. That's a spec. Someone writes it down.

[10:25](https://www.youtube.com/watch?v=VktrqzQgytY&t=625s) It might be in a Linear ticket. It might be on Slack. It's somewhere. Somewhere you have written down what is the goal, what are you trying to achieve. That goes into a loop, and this loop is a typical agent harness.

[10:39](https://www.youtube.com/watch?v=VktrqzQgytY&t=639s) So it might be your, might be your Claude Code, might be... We're, we're a big Amp fl- fan, so in our case, it's often Amp. Uh, it might be Cursor.

[10:48](https://www.youtube.com/watch?v=VktrqzQgytY&t=648s) It might be Factory. Uh, you, you go into a loop, and here, uh, the agent will check out your code, and we'll start kind of moving towards the im- and implementing your plan.

[10:59](https://www.youtube.com/watch?v=VktrqzQgytY&t=659s) Uh, very importantly, already makes use of some of these invariants. Well, it checks out a well-known commit, so it doesn't just start from, from anything, for example. Then intern- what is internal validation?

[11:12](https://www.youtube.com/watch?v=VktrqzQgytY&t=672s) Well, it goes and uses the assets that exist in the repository to actually validate that the change is correct. So it builds it. It test- tests it. Then it comes back and tells you as a human, uh, "Hey, I've just finished.

[11:25](https://www.youtube.com/watch?v=VktrqzQgytY&t=685s) Does it look good? Should I change something else?" And you say yes, or you say continue, like continue is probably the word that we use the most nowadays, and, and then it just goes back and continues through the plan.

[11:37](https://www.youtube.com/watch?v=VktrqzQgytY&t=697s) Eventually, you're done, and you go into the merge queue, and, and then it goes into the ledger. So your repository, your Git repository is, is kind of like a ledger.

[11:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=707s) Uh, this is fast, but it's not fast enough because in this external validation, you still have a human in the loop.

[11:59](https://www.youtube.com/watch?v=VktrqzQgytY&t=719s) Uh, so where do we think we're kind of moving towards? And this is in the span of weeks to months, not years. W- It's, it's a world where

[12:11](https://www.youtube.com/watch?v=VktrqzQgytY&t=731s) generating code becomes much faster. It's already fast, but inference will only get faster. Uh, internal validation, so running your builds and tests need to be extremely fast as well, and that's where you cannot go and spend fifteen minutes running your tests or forty-five minutes or any sort of minutes because you are delaying the whole loop.

[12:32](https://www.youtube.com/watch?v=VktrqzQgytY&t=752s) And external validation no longer has humans. We have other agents that are evaluating the changes. So you may have, um, a security, uh, focused LLM. You may have an, um, uh, API conformance, uh, based LLM that is providing feedback within the loop to the changes that your main harness is then, uh, incorporating

[12:57](https://www.youtube.com/watch?v=VktrqzQgytY&t=777s) back into the code, and it's doing this very quickly.

[13:03](https://www.youtube.com/watch?v=VktrqzQgytY&t=783s) Um, when it's done... And in order to do it very quickly, it actually needs to be running in a stateful environment. 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:17](https://www.youtube.com/watch?v=VktrqzQgytY&t=797s) So the statefulness of it is really important within this loop. Um, you are getting world signals from time to time, things like, well, the plan changed, or someone else got a, a change in.

[13:28](https://www.youtube.com/watch?v=VktrqzQgytY&t=808s) So the harness is also adapting its intent and plan, which then creates a new loop. And then when you're done, because there are so many changes going on, uh, and you haven't yet really, as a human, the team hasn't accepted this change, you don't go directly into the repository.

[13:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=827s) You go into a pre-queue, which we're starting to call a pre-merge, where there's a queue of changes that are done, that it would have been merged, uh, if w- if the process of merging was fast enough.

[14:01](https://www.youtube.com/watch?v=VktrqzQgytY&t=841s) But the reality is that you will have so many of these running in parallel and operating on the same parts of the code base that you need a process that reconciles them so that you can have serializ- serializability, so that you actually can guarantee that all the changes go back to back into the, into, into your ledger,

[14:20](https://www.youtube.com/watch?v=VktrqzQgytY&t=860s) into your repository. And that's the point where you get external approval. That's where the human comes in, where looks at not the code, but that the, this was the intent and this was the result.

[14:34](https://www.youtube.com/watch?v=VktrqzQgytY&t=874s) And the result might be, here's the video of the feature working. It might be, uh, here's the o- uh, the output of the security-focused LLM on, on this particular change.

[14:47](https://www.youtube.com/watch?v=VktrqzQgytY&t=887s) And it's not on one commit or one PR. It might actually be on multiple of them. So you may even have multiple agents, uh, independently working on features that go into this pre-merge queue and semantically get grouped into something that you as a human can manage because there's going to be way too many.

[15:06](https://www.youtube.com/watch?v=VktrqzQgytY&t=906s) We already see that today where within our team, where our, our volume of what we would call PRs from in, from the past is four times as big as before.

[15:16](https://www.youtube.com/watch?v=VktrqzQgytY&t=916s) It's impossible for a human reviewer to look at every single PR.

[15:21](https://www.youtube.com/watch?v=VktrqzQgytY&t=921s) Um, and if we think a little bit more into the future after this,

[15:28](https://www.youtube.com/watch?v=VktrqzQgytY&t=928s) if this process is extremely quick, one thing that may end up happening is that you may have to step into the multiverse where, uh, the starting point where the intent and plan gets applied is not the tip of the ledger.

[15:46](https://www.youtube.com/watch?v=VktrqzQgytY&t=946s) It's not the latest commit, uh, that... of your repository because that is moving. There's many candidates. So the agents may actually be working on multiple commits at the same time to address the same plan.

[16:00](https://www.youtube.com/watch?v=VktrqzQgytY&t=960s) And in order to get that, uh, to get there, this inner loop needs to be extremely quickly, uh, ex-extremely quick, and, um, it adds up in terms of capacity.

[16:09](https://www.youtube.com/watch?v=VktrqzQgytY&t=969s) So resource usage will also blow up because of all of the candidates that you're going to be exploring at the same time. This is the world that we think that we're moving towards.

[16:19](https://www.youtube.com/watch?v=VktrqzQgytY&t=979s) Uh, we're, uh, obsessed about performance and efficiency, so we're, uh, spending a lot of energy finding ways to maintain efficiency within this loop, and part of it is, uh, well, don't do work that is not necessary.

[16:33](https://www.youtube.com/watch?v=VktrqzQgytY&t=993s) Don't start things from scratch all the time. Uh, have agents work a lot more as we did as engineers that in our own work sessions that were much more incremental, and, and that's kind of the world that we're moving towards.

[16:49](https://www.youtube.com/watch?v=VktrqzQgytY&t=1009s) Uh, did CI go away? Well, CI still matters, but it's just shifted because the principles of, uh, well, for example, does, does the code actually work, no longer is a separate phase, but it's just part of this loop.

[17:06](https://www.youtube.com/watch?v=VktrqzQgytY&t=1026s) Every single iteration is going through validation now. It's still going through enforcing those invariants as well. Like you still ha- want to have, for example, for compliance reasons, you still want to have guarantees that you're starting from a well-known, uh, checkout, that you don't have someone in the, in the, in your company that came in and added

[17:26](https://www.youtube.com/watch?v=VktrqzQgytY&t=1046s) other code that was never vetted, and you're starting from there. So those invariants need to still be enforced, but they're enforced on a continuous basis. Coordination moves away from CI.

[17:37](https://www.youtube.com/watch?v=VktrqzQgytY&t=1057s) So CI no longer has to, uh, kind of guide different changes and making sure that different tests are passing in order for changes to be committed. That needs to be part of the overall loop.

[17:48](https://www.youtube.com/watch?v=VktrqzQgytY&t=1068s) And governance is still important, uh, but it also gets much more lifted into the harness and how the harness is, uh, uh, coercing the change towards following everything that your team has codified, um, within these processes.

[18:03](https://www.youtube.com/watch?v=VktrqzQgytY&t=1083s) And that's it. This is where we, we, we believe that the world is moving towards. Um, if you're interested about this topic, uh, us at Namespace, um, uh, spend a lot of time thinking about it.

[18:12](https://www.youtube.com/watch?v=VktrqzQgytY&t=1092s) Uh, there's other folks in the industry as well. Uh, it's a crazy world, and we need to be ready for it. Uh, thank you, and, uh, yeah, let's go for lunch. [audience applauding] [upbeat music]
