Post-Agent CI Flows
Continuous integration, as most of us run it today, hangs off of the pull request. A pull request gets opened, or gets a new push, and that is the event that kicks off linting, type checks, rule evaluation, and the test suite. I’ve been operating under the assumption for a while now that the pull request, as GitHub popularized it, isn’t the right shape for software changes when agents are writing a large share of the code. If that’s true, it leaves an awkward question behind it: if we move away from the pull request, where does CI hook in? Put another way, what does the agentic Software Development Lifecycle (aSDLC) look like, and where does CI sit in it?
This is specifically about CI: the checks that decide whether a change is acceptable. Builds and deploys are a different conversation, and I’m going to leave them alone here.
What the Pull Request Was Actually Doing#
It’s worth being precise about what CI attaches to today, because it’s not really the pull request.
Check results on GitHub are already keyed to a commit SHA. Every commit CI ran on keeps its own results, and the pull request just shows you the ones for whatever commit is currently at the head of the branch. Required checks work the same way: they have to pass on the latest commit, and results from earlier commits don’t count.1 The evidence has always been pinned. What isn’t pinned is the approval. A review is recorded against a commit,2 but the pull request tracks a branch, and unless you’ve turned on stale-approval dismissal, an approval quietly floats forward onto every commit pushed after it.3
So the pull request is doing a couple of jobs at once. It’s a record that says “I would like this to land” (a head commit, a stated intent, an owner, and a ready/draft bit), and it’s the thing that reviewers and approvals hang off of. CI attached to it because it was the record that existed, not because a human clicked a button.
There’s a second thing that one CI run has been quietly doing: serving two different readers. It gives the author fast feedback (does this compile, did I break a test), and it gives the merge gate evidence (is it safe for this to land). Those two jobs got merged into one run because human attention was the expensive resource, and one signal in one place was worth the imprecision.
An agent author pulls those apart. Author feedback belongs inside the agent’s own loop, on the machine the agent is already running on; lint, types, and the affected unit tests, as often as it wants, notifying nobody. Gate evidence has to stay outside, on infrastructure the agent can’t touch. The value of a green check was never really “the tests passed”. It was “the tests passed on a machine the author doesn’t control”, and that property matters more now, not less. The agent likely wrote the tests, and “make the checks green” has a cheap wrong answer: delete the test, skip it, or loosen the assertion. A person who does that tends to feel a bit of shame about it. An agent won’t.
That means one check that used to be a nice-to-have becomes load-bearing: the change in the check surface itself. No new skips, coverage not lower, mutation score not lower. The result of the suite matters, but so does whether the suite you ran is the same suite you had yesterday.
The Review Request#
My proposal is to replace the pull request with something I’ll call a Review Request, and the important part of it is that it’s pinned to a single commit SHA (and the tree hash under it), not to a branch.
The pull request fused two separate acts into one click. “I’m submitting this” and “please look at this” happened together, because one human was doing both. The Review Request pulls them back apart. Opening one against a SHA doesn’t create a review. It starts an admission workflow, and the review only gets created if admission passes.
Walking through it:
- The agent produces a tree. Its in-loop checks already ran, and they count for nothing here.
- It opens a Review Request against SHA X, with a declared intent.
- The admission workflow first checks whether signed evidence already exists for that tree. If it does, there’s nothing to run.
- Otherwise it runs on a clean checkout: build, lint, types, the affected unit tests, and the check-surface delta. If the change touches CI configuration, an owner review joins the DAG.
- On failure, no review exists. The request goes back to the author, and no human is notified.
- On success, the review is created, and that is the first moment anyone is notified.
Today a failed check paints a red mark on a review that already exists, and has already cost somebody some attention. In this model, the review never exists at all. Reviewers learned a long time ago to wait for green before they look; that’s an informal protocol compensating for a bad ordering. This just encodes it.
CI stops being a check on a review. It becomes a precondition for the review existing at all.
Pinning to a SHA has a cost that’s worth naming. “Address the feedback” stops meaning “push more commits”, and starts meaning “open a new Review Request against a new SHA”. Agents won’t care about that ceremony, but humans will; you lose comment continuity, and re-reviewing from zero is exactly the thing reviewers resent. The chain of requests needs a supersedes link and a diff-of-diffs view to be tolerable. That’s real work, and it’s the part of this I’m least sure how to make pleasant.
Approval Is Just Another Check#
Once the review exists, the next question is what the review actually is. My answer is that “Needs Human Review” is simply a check, and approval is a node in the CI DAG like any other.
This is explicitly not how GitHub pull requests treat approvals today. Required reviews and required status checks are two separate rules;4 approvals don’t live in the CI graph at all, and nothing in that graph can decide whether one is needed. What you can configure is a number of approving reviews, code owners who are requested when a change touches files matching a pattern in a CODEOWNERS file,5 and specific teams who have to approve when certain files or directories change.4 It’s a static rule on a branch, keyed to file paths, with no intelligence behind it. You can’t say “require a human only under these conditions”, because the rule has nowhere to read conditions from. As a node in the DAG, whether a human is required becomes a function of the change. An upstream node looks at the change and decides which review nodes exist at all.
There are a few properties of this that I think make it worth the effort.
The decision can be based on evidence, not size. Diff size and code area are the obvious inputs, but I’d argue the primary one should be how much automated evidence covers this change. A large change in a well-exercised module may need less human attention than a twelve line change in a module nobody has ever tested. I’m deliberately leaving the implementation of that measure open, and calling it an assurance score for now. It shouldn’t just be code coverage, and it has one property I think is non-negotiable: since the agent is writing the tests, any metric the agent can read will be optimized. So the signal has to be observed rather than authored: things like the historical escape rate for an area, incident density, and revert rate. No amount of generated tests moves those. As a nice side effect, the rate of changes that need human review becomes a number you can watch. If it climbs, your automated evidence is degrading.
Human nodes can be ordered. An architect review on an interface or schema change can come before a design review, so nobody spends design-review time on an approach the architect is going to reject. That ordering isn’t ceremony; it’s the difference between one wasted review and three. This does mean a human node can’t be a regular job. It has to suspend until someone responds, without holding a runner, and resume when they do. Nothing about a DAG-based CI system prevents that; it’s the same durable-execution shape I described in The Request Is Not the Unit Anymore.
Review has a third state. Pass and fail aren’t enough. A review often turns into a thread of questions that the author (human or agent) has to answer. That’s blocked on author, and it’s the only state whose timeout should be aimed at the author rather than the reviewer. If the author answers, the review continues. If the author changes the tree, that’s a new Review Request.
A rejection is a failure, and it sticks to the tree. A human rejection should fail the node, the same way an automated rejection would. And because results are keyed to the tree, a rejected tree stays rejected. An agent that reproduces the same tree gets refused instantly, and nobody is notified. A superseding request has to differ in its tree by construction. The caveat is that a tree can be rejected for a reason that later goes away (the blocker it was waiting on landed, for example), so rejections probably need a reason code, or an expiry, to avoid permanently poisoning trees for stale reasons.
Approvals are pinned, and promotion is explicit. Pinning approvals to a tree fixes the floating approval, but it creates the opposite problem: a trivial rebase would throw away a perfectly good review. So the review node needs a promotion step. Before asking a human, it checks whether an approval on a superseded tree can be carried forward, based on whether the changes in between touch the scope of that review. Cheap, general-purpose classifiers can make that call now. When it promotes, it records the promotion as its own result: approval A on tree T′ promoted to T, and why. Today the approval floats and you opt into dismissal. Here the approval is pinned, and you opt into promotion. It’s the same end state with the opposite default, and I think the default is the whole argument. Two rules go with it: tune the classifier toward false negatives (a missed promotion costs one re-review, a bad one lands unreviewed code), and never promote a rejection.
Inputs the Agent Must Not Control#
The same rule keeps showing up in different places, so it’s worth stating once. There are a handful of inputs to this system that the authoring agent must not be able to change:
- The CI configuration. An agent with write access to the workflow files can disable the gate. Changes to CI config need their own, stricter path, which is the owner review in the admission diagram.
- The forge rule. The forge should require exactly one check,
admission, and nothing else. All of the policy lives behind that node, and the rule itself has to be static and protected. A rule an agent can edit is not a rule. - The evidence and its cache key. Results should attach to SHAs, which git handles natively, with a note recording the tree hash the results came from, so that identical trees can share results. But git notes are refs like any other, and anything that can push them can forge a cache hit. GitHub’s rulesets only target branches and tags,6 so anyone with write access can push to
refs/notes/*. (Notes also aren’t pushed or fetched by default, so every consumer needs an explicit refspec.) So the note is a convenience index, not evidence. The evidence lives in an external system of record, signed by the system that produced it, which writes to git notes for convenience. Either it’s external, or something has to be checking signatures.
Tree-level reuse is where the economics get interesting. An amended message, a squash, or a rebase onto the same base all produce new commit SHAs with identical trees, and today each one pays for a full run. Keyed on the tree, they pay nothing. You could take this further and reuse results for subtrees, but that only holds if you can evaluate the full import closure of what’s being tested. Go, Rust, and Bazel-style builds make that closure computable; a language with dynamic imports mostly doesn’t. That’s a limit rather than a flaw. CI already differs between languages all the time for exactly these kinds of reasons.
Does Testing Every Commit Still Make Sense?#
I don’t think it does, and I’m not sure it ever did. An agent can produce a pile of commits in a few minutes, and most of them describe states nobody intends to land. The two things worth testing are the proposal (at admission) and the merge candidate (at integration). Bisectability is a property of main, not of every branch that ever existed.
The flip side is the idea of only running CI once a change has been approved, as a final check before merge, on the assumption that agents (or pre-commit hooks) already ran everything locally. I’d argue against that one on ordering, not cost. Review is the expensive judgment. It shouldn’t be spent on a change that doesn’t compile, and local checks the author controls aren’t evidence. The cheap automated gate goes first.
The full suite still runs, but it moves to the end, behind a merge operator.
Approved trees queue up behind a merge operator, and the full suite and integration tests run against a merge candidate: the tip of main plus the approved trees ahead of it. If a candidate fails, an agent bisects, the failing tree goes back to its author, and the rest are retried. Large organizations already run this way, for reasons I went into in Your Agents Will Not Complain, and I’m not going to re-argue it here.
This is Graydon Hoare’s “Not Rocket Science Rule”: “automatically maintain a repository of code that always passes all the tests”.7 It also gets you the one invariant I think is actually worth paying for: every commit on main was tested in the exact form it has on main. Pull request CI mostly doesn’t give you that. It tests a branch head or a preview merge, and neither of those is necessarily the commit that lands. That gap was tolerable when the number of changes in flight was low, and semantic conflicts were rare. It gets a lot less tolerable when agents push the number of changes in flight up sharply.
How you batch is a real trade-off, though. GitHub’s merge queue (with “only merge non-failing pull requests” on), GitLab merge trains, and Zuul all test every position in the queue: each change runs on main plus everything ahead of it, in parallel.89 That keeps the invariant for every commit, but it’s still one full run per change. bors took the other route, and ran the suite once on a single merge commit for the whole batch.10 That divides the cost of the suite across the batch, but only the tip of the batch is guaranteed to have been tested. Either way, the full suite moves to the end, behind admission and review, and only runs on trees that are already known to build.
One thread I haven’t pulled on: agents write a lot of tests, many of them low value. The suite grows at the same time the number of runs grows, so you pay twice. I suspect test suites are going to need a garbage collector, which is new; they used to grow slowly enough that nobody had to care.
What Exists Today#
Most of the individual pieces of this exist somewhere. What I haven’t found is a system that puts them together, and the specific gap is the relationship between code-review approval and the CI graph.
GitHub Actions makes conditional required checks surprisingly awkward. If a required workflow is skipped by a path or branch filter, its check sits in “Pending” and blocks the merge; GitHub’s own advice is to not filter required workflows. A job skipped via an if: condition reports success instead, which is why a common workaround is a single aggregator job as the only required check.111 Human gates inside a workflow exist through environments with required reviewers, and the job isn’t sent to a runner until someone approves (for up to 30 days),1213 but that’s built as a deployment gate, not a code review.
Jenkins can do essentially anything. The input step pauses a pipeline for a human, and with per-stage agents it can do so without holding an executor.14 But “anything” means you’re building and maintaining all of it yourself. Conditions are also part of the run, not something evaluated ahead of it. A when block is only checked once a build has been queued, numbered, and started, with the Pipeline’s Groovy running on the controller itself,15 and by default a stage’s agent is allocated before its condition is evaluated, unless you opt into beforeAgent.16 Compare that to a path filter in GitHub Actions, where a push that doesn’t match produces no run at all.17 Jenkins does keep builds off the controller if you configure it to,18 but the evaluation of what should run happens inside a run, on controller resources. It’s also old (work on what became Jenkins started in 2004),19 it’s a pain, and in my opinion it’s largely not what new deployments are being built on. The survey data I could find doesn’t measure new deployments directly, but it leans the same way: in JetBrains’ 2025 survey, GitHub Actions is ahead of Jenkins in organizations (33% to 28%), and well ahead for personal projects (39% to 13%).20
Buildkite has block steps, which pause a build until someone unblocks it and can be conditional, and dynamic pipelines that can generate those steps at runtime.21 It can read GitHub’s review state and trigger on review events, but approval still lives in the forge. The CI system reads it; it doesn’t own it.22
GitLab has the most built in: DAGs via needs:, path-conditional jobs, blocking manual jobs, deployment approvals, and merge trains. Approvals are reset by default when new changes are pushed, and GitLab compares patch IDs to decide whether a rebase should reset them, which is a quiet, automatic form of promotion.23
The closest prior art isn’t a CI system at all. Gerrit has immutable, per-commit patch sets, submit requirements that only apply under conditions, and copyCondition, which carries a vote from one patch set to the next when a query (like “this was only a trivial rebase”) matches.24 Zuul gates changes by testing each one “exactly as it is going to be merged”, along with the changes ahead of it in the queue.25 And Tekton has an approval task that runs as a node in a pipeline and fails the run if an approver rejects.26
Mapping the proposal against that:
| Piece of the proposal | Closest existing work | Status |
|---|---|---|
| Request pinned to a single commit | Gerrit patch sets; GitHub reviews record a commit, but the pull request follows the branch | Prior art |
| Admission before a review exists | Zuul check pipelines vote before approval, but humans can review at any time; GitHub doesn’t request code owners on a draft pull request until it’s marked ready,27 but that’s a manual flip, not a gate | New as an enforced ordering |
| Approval as a node in the CI DAG | Tekton approval task, GitHub environment reviewers, GitLab blocking manual jobs, Buildkite block steps, Jenkins input; all gate deploys or progress, not code review |
New as the code-review approval |
| Conditional human nodes | Gerrit applicableIf, Phabricator Herald, code owners, Buildkite if |
Prior art |
| Ordered human nodes | Any DAG engine can express it, but not as code-review approval; GitLab has an open request for sequential approvals,28 and Gerrit’s applicableIf can reference another label’s vote |
Partial |
| Suspend without holding a runner | GitHub environments, GitLab manual jobs (not queued for a runner until started),29 Tekton custom tasks (run by a controller rather than a pod),30 Jenkins per-stage agents, Temporal | Prior art |
| Pinned approval, explicit recorded promotion | Gerrit copyCondition, GitLab patch-id comparison; both implicit, neither recorded as its own result |
Partial; the recorded promotion is new |
| Rejection sticks to the tree | Gerrit can carry vetoes forward per change, not per tree; git-test remembers a tree as known-bad, but locally, for tests rather than review |
Mostly new |
| One required forge check | The aggregator-job workaround on GitHub; Zuul reporting a single vote to Gerrit | Prior art, as practice |
| Results cached by tree hash | git-test records results by tree in git notes;31 Git’s own CI skips trees that already passed;32 Bazel caches by input digest |
Prior art, not built into any forge CI |
| Signed evidence in an external record | SLSA provenance, in-toto test-result attestations, Sigstore; SLSA’s source track can attest that a review happened,33 but not approval as a node in the CI graph | Partial |
| Full suite on the merge candidate | Zuul, bors, GitHub merge queue, GitLab merge trains | Prior art |
The pieces marked new are really one idea, seen from a few angles: code-review approval is a CI result like any other, keyed to a tree, and nobody is asked to look at a tree until the machines have agreed it’s worth looking at.
Conclusion#
If the pull request goes away, CI doesn’t lose its hook in the aSDLC. It gets a better one. The Review Request gives it an immutable thing to attach to, admission puts the cheap automated gate ahead of the expensive human one, and treating approval as a node lets the policy about who needs to look live in the same graph as everything else. I don’t have every piece of this figured out; the assurance measure and the human side of immutable requests in particular are both open. But I think the ordering is right.
A review is a request for a person’s attention. It shouldn’t exist until the machines have agreed that the change deserves it.
A Postscript on the Delay#
I originally wrote this in September 2026, and it sat for a couple of months before going up. A fair amount has changed in that time. Most relevant here, both Anthropic and OpenAI have published posts about rebuilding source control for the volume of change their agents produce, and the Anthropic posts in particular give a closer look at how review is changing inside a company running agents at that scale.
Anthropic replaced Git for its monorepo with an in-house system called Scion, along with a code review tool called Antique.34 The scale is the headline: around 2,500 merged changes a day in May, and over 30,000 a day by September. On review, the post says engineers now examine the intent of a change rather than reading every line, that they make extensive use of adversarial review, and that their review tooling can “express complex semantic constraints on approvals”. That last part is close to what I was reaching for with approval as a node: whether a person is needed becomes a function of the change, not a static rule on a branch.
The part that cuts against this post is the merge queue. Anthropic says that “a proper merge queue, for example, doesn’t make much sense at agent scale”, and that they’ve invested in post-merge and pre-deploy testing instead, with Claude typically fixing the conflicts between concurrent changes. That’s a different answer from the merge operator I described above. It gives up the invariant that every commit on main was tested in the form it landed, in exchange for never serializing merges. At 30,000 merges a day, I can see why that trade looks attractive.
I don’t fully agree that a merge queue stops making sense, though I think a lot of that comes down to what each of us means by one, and what we expect it to do. The version Anthropic describes moving away from is built around a “global repository lock on the merge queue”, where every change waits its turn. That’s not really what I had in mind. The merge operator above tests merge candidates in parallel, or in batches, and only the trees that fail fall out of line. It still has a throughput ceiling, and at their volume it may well be the wrong trade, but it isn’t a single lock that every change waits behind.
Two days later, the Claude Code team published a post on how they review their own repositories, and it lines up with the proposal more closely than I expected.35 A classifier reads the change and picks a risk tier, and a second classifier asks whether this particular change needs a person even when its tier says it doesn’t; in their words, “the change sets the tier, not the author.” Low-risk changes need no human approval once automated review and security checks are green. CI workflow files, and any path owners have listed as sensitive, always need a person. Every pull request gets an agent review before a person looks, an agent’s approval never fills a slot that calls for a human, and “an approval covers one specific commit”. If new commits land that the system can’t vouch for, the approval has to be given again, which is close to pinned approval with promotion. They also count the person directing the agent as one of the required reviewers. What they didn’t do is drop the pull request. All of this is framed around pull requests, and their advice to other teams leans on code owners and branch protection.
OpenAI went a different direction. Rather than replacing Git, they built Pando, a new backend that sits behind the standard Git protocol and client, after Codex pushed parts of their monorepo workflow below 90% reliability at times.36 Pando orders updates to each branch independently, so a reader looking at several branches can see them at different points in time. Their post says much less about review. It mentions that the migration covered their tooling for change requests and code review, but not how that review works.
None of this settles the open questions above; the assurance measure and the human side of immutable requests are still open. But at least one of the largest users of coding agents has landed on the same ordering: automated review first, and a person only where the change calls for one.
-
Troubleshooting required status checks, GitHub Docs. ↩︎ ↩︎
-
REST API endpoints for pull request reviews, GitHub Docs. ↩︎
-
About protected branches, GitHub Docs. ↩︎
-
Available rules for rulesets, GitHub Docs. ↩︎ ↩︎
-
About code owners, GitHub Docs. ↩︎
-
About rulesets, GitHub Docs. ↩︎
-
“not rocket science” (the story of monotone and bors), Graydon Hoare, 2014. ↩︎
-
Managing a merge queue, GitHub Docs. ↩︎
-
Merge trains, GitLab Docs. ↩︎
-
alls-green, re-actors. ↩︎
-
Managing deployments, GitHub Docs. ↩︎
-
Deployment environments, GitHub Docs. ↩︎
-
What’s in Declarative, Jenkins blog. ↩︎
-
Pipeline best practices, Jenkins. ↩︎
-
Pipeline syntax, Jenkins. ↩︎
-
Workflow syntax for GitHub Actions, GitHub Docs. ↩︎
-
Controller isolation, Jenkins. ↩︎
-
Kohsuke Kawaguchi, Jenkins contributors. ↩︎
-
Best CI tools, JetBrains TeamCity blog, reporting the State of Developer Ecosystem 2025. ↩︎
-
Block step and dynamic pipelines, Buildkite Docs. ↩︎
-
Merge request approval settings, GitLab Docs. ↩︎
-
Review labels and submit requirements, Gerrit Code Review. ↩︎
-
Project gating and pipeline configuration, Zuul. ↩︎
-
Manual Approval Gate, OpenShift Pipelines. ↩︎
-
About pull requests, GitHub Docs. ↩︎
-
Add the ability to add sequential approvals for merge requests, GitLab issue. ↩︎
-
Pipelines: using custom tasks, Tekton. ↩︎
-
ci: skip GitHub workflow runs for already-tested commits/trees, git/git. ↩︎
-
Source requirements, SLSA v1.2. ↩︎
-
Redesigning source control at Anthropic, Anthropic Engineering, October 2026. ↩︎
-
How the Claude Code team does code review, Claude blog, October 2026. ↩︎
-
Scaling Git at OpenAI, OpenAI, November 2026. ↩︎