In plain terms
AI agents can now write code far faster than people can check it. The bigger risk isn’t any one agent’s code quality; it’s hundreds of agents working without a shared plan. They duplicate each other’s work, collide with each other, and overwhelm the reviewers. This model works like city building permits: split the job into small permits, approve each one before work starts, keep one register so two crews don’t dig up the same street, and inspect at the end against the agreed plan.
Setting the scene
Writing code used to be the slow, expensive step in software. AI coding agents have changed that. Google says 75% of its new code is now AI-generated (Business Insider), and at Anthropic, changes merged per day rose from about 2,500 in May 2026 to more than 30,000 by September (Anthropic).
Checking that work has not kept pace. Across 22,000 developers, Faros AI found that as teams moved from low to high AI adoption, median time in review rose 441.5% and PRs merged with no review at all rose 31.3% (Faros AI, 2026). As Anthropic put it, “The bottleneck, now, is all of the developer infrastructure built for human scale.”
Volume is only half the problem. When many agents work in the same codebase at once, their changes collide: researchers replaying more than 107,000 agent-authored PRs found merge conflicts in about 28% of them (AgenticFlict). Two changes can also pass their own checks and still break the product once combined.
This matters because the speed gains do not reach the business. Agent time goes into work that is duplicated or thrown away, reviewers become the queue every change waits in, and changes that slip through unreviewed or badly combined reach production. And when something does go wrong, teams need to show why a change exists, what it was allowed to change, and who approved it, a record that is hard to reconstruct after the fact.
Reviewing harder will not fix this, because the problem is when and how review happens: today it starts once code exists, and it judges each PR on its own.
Core thesis – Move the most important review decisions before code is written, and judge changes as a connected set rather than one at a time.
Break each request down, level by level, into the smallest changes that can be reviewed on their own, checking every level against work already proposed or underway. The result is a connected map of planned changes, so duplicates, dependencies, and conflicts surface before anyone writes code. Approve each change’s purpose and limits up front; at merge, check that the work stayed within them and combines safely with everything else.
The model draws on four recent research efforts, summarized in Research foundation.
Proposed control model
The model rests on three pieces. An Intent PR is a draft PR that records what a change is for and the limits it must stay within, before any code is written. Its task envelope is the approved set of limits for that change: what it may touch, how large it may grow, and what evidence it must provide. The Dynamic Integration Ledger is a live map of every proposed and active change and how they relate to one another.
Stable authority and changing context
The task envelope answers, “What may this execution and PR change?”
The Dynamic Integration Ledger answers, “How does this proposed or active work relate to everything else currently in flight?”
The recursive decomposer connects these two forms of control. It reads the ledger at every level of decomposition and contributes candidate intents, lineage, and proposed relationships back to it. The decomposition tree explains how an abstract request becomes atomic work; the ledger relates that work to other proposed, active, and recently integrated changes. As the ledger changes, the decomposer may reuse, split, defer, reorder, or eliminate candidate work before authority is granted.
The envelope remains stable from approved dispatch through merge. The ledger changes as requests, PRs, checks, reviews, merges, and target branches change. Ledger evidence may pause work or return it to planning, but it does not silently expand an envelope.
Evaluations support both admissions with versioned deterministic, LLM, and human evidence. They inform policy and accountable judgment; they do not independently authorize execution or merge.
The resulting lifecycle is:
Plan → admit intent → implement → coordinate → validate → promote
Four invariants make the model enforceable:
- No implementation begins before intent approval.
- One atomic PR executes under one approved envelope.
- Queue relationships may change; authorized scope cannot change silently.
- Composition, admission, and promotion are separate decisions.
1. Approve the PR before code exists
Recursive decomposition
An abstract request may be too broad for one safe, reviewable PR. A read-only planner recursively decomposes it into candidate intents, consulting the repository and the current ledger at every level. Existing work may satisfy part of the request, alter its boundaries, introduce a dependency, or make a proposed intent unnecessary.

The atomic-and-evaluable gate is an Intent Quality evaluation, not an unsupported planner assertion. It can combine deterministic structural checks with LLM and human judgment. A failed evaluation returns the candidate to decomposition; any revised proposal must be evaluated again.
Passing evaluation makes the candidate visible in the ledger, but does not reserve scope or grant authority. After human approval, the workflow refreshes the ledger and atomically admits the intent only if it remains compatible with current inflight work. A material queue change returns the proposal to planning rather than relying on stale approval.
Decomposition stops when each leaf represents one coherent outcome with bounded scope, measurable acceptance criteria, explicit relationships, and a credible validation plan. The leaves should collectively cover the parent request without unexplained gaps or duplication. Only approved leaf intents receive task envelopes and become Intent PRs; related leaves may still form a dependency chain or all-or-none integration group.

The example deliberately stops different branches at different depths. Defining the budget contract is already atomic, while the operator experience requires another decomposition before each leaf can receive its own envelope.
Intent admission
Before proposing a new PR, planning evaluates each candidate intent against the repository and the current ledger. Published candidates or approved Intent PRs may already satisfy, duplicate, depend on, conflict with, or otherwise affect it. Planning may therefore attach the request to existing work, defer it, split it, establish a dependency, or conclude that no new PR is required.
When new work is warranted, intent evaluation and review consider:
- the intended outcome and acceptance criteria;
- whether the intent is atomic and appropriately sized;
- the files or areas likely to change;
- an approximate size budget;
- relevant dependencies and queue relationships;
- required QA and validation;
- risk and approval requirements.
A human approves the proposed intent, evaluation requirements, and boundaries. The workflow then refreshes the ledger. If the intent remains compatible with current inflight work, one admission step reserves its scope, opens a draft Intent PR that records its approved purpose, and binds its task envelope before implementation begins.
At this point, half of the PR has already been reviewed: why it exists, what it may change, how large it may become, and how success will be judged. Final review should not rediscover whether the PR is necessary, atomic, or appropriately scoped.
2. Execute within immutable authority
The task envelope gives the authoring agent a stable description of what its PR is expected and permitted to change. If implementation requires materially broader scope, the work returns to planning and approval rather than expanding silently.
An atomic PR represents one coherent intent and one envelope. Atomic does not always mean independently mergeable: a PR may have an explicit prerequisite or belong to an all-or-none integration group.
3. Treat the PR queue as a graph, not a list
As implementation develops, the ledger compares observed impact with planned impact and refreshes relationships across the queue. It may detect dependencies, conflicts, duplication, supersession, all-or-none groups, policy rejection, or work that remains independent.
The ledger may change continuously, but an approved envelope does not. New relationship evidence can change review routing, integration grouping, or merge order. Work that requires broader execution authority returns to planning and approval.
“Dynamic Integration Ledger” is a working term, not terminology used by the papers. Its closest source is BulkPR-Bench’s “persistent, revisable typed relation ledger” (see Research foundation).

The same budget example becomes a graph once concurrent work is considered. Its budget PRs form a dependency tree, while duplicate intent, conflicting storage work, a superseded schema, an all-or-none migration, and unrelated documentation connect, or remain disconnected, according to current evidence.
4. Prove correctness at three scales
Merge admission asks whether implementation faithfully realized the approved intent and whether the resulting composition is safe. This is not one test; validation occurs at three nested scales:
| Scale | Subject | Question |
|---|---|---|
| Atomic PR | One leaf intent and envelope | Did this PR correctly implement its bounded intent? |
| Original request | All ordered leaf PRs descended from one request | Did the leaves collectively achieve the requested outcome? |
| Repository integration | A selected safe subset applied to the latest target revision | Is the exact combined change safe for the codebase now? |
Atomic validation checks envelope conformance, leaf acceptance criteria, and focused quality, security, and test evidence. Request-level validation composes related leaves and tests root acceptance criteria, end-to-end behavior, and contracts between them. Repository-level validation tests the selected merge group against the latest target branch for cross-request composition, regression, migration, configuration, security, and other policy risks.
Each result must be bound to the exact revisions and composition tested. A passing leaf does not prove its parent request succeeded, and a passing request does not prove that it composes safely with the current repository. Every successful promotion changes the target base, potentially making evidence for the remaining queue stale.
Tests and evaluations play different roles
Tests establish deterministic technical behavior. Evaluations judge intent satisfaction, evidence sufficiency, and policy. Humans retain responsibility for high-risk, ambiguous, or accountable decisions.

5. Separate validation from merge authority
Composition is not promotion. The integration workflow may create speculative merge trees and gather evidence without having permission to change a protected branch:
- compose: construct the exact candidate tree for testing;
- admit: determine that the tested tree satisfies current policy;
- promote: merge that admitted tree into the protected branch.
Organizations that prohibit agent merges can require an accountable human to approve the exact tested tree before the Git provider’s protected merge queue promotes it. Organizations permitting limited automation can delegate eligible low-risk promotions to a separate, narrowly privileged integration controller. The authoring agent should not merge its own work in either model.
Organizational authority remains explicit
Agent-authored code can be composed and validated automatically without granting coding agents protected-branch permission. Branch rules, required checks, human approval policy, and exact-revision verification remain authoritative.
Research foundation
Four sources provide complementary ideas for this direction.
Review as an end-to-end lifecycle
Rethinking Code Review in the Age of AI: A Vision for Agentic Code Review argues that isolated tools do not address failures between review stages. It connects PR creation, augmentation, reviewer selection, AI-assisted review, and retrospective learning.
Specialized agents gather alignment, risk, impact, runtime, and review evidence. Humans supervise the agents and retain accountable decisions. The paper supplies the lifecycle framing, but it does not define how to constrain author agents or coordinate a queue of interacting PRs.
Constrain each agent from dispatch through merge
Capability-Scoped Task Envelopes with Reserved-File Token Broker for Concurrent AI Coding Agents proposes a machine-checkable envelope containing path and size limits, dependency permissions, required checks, risk and approval requirements, reserved files, and task dependencies.
Its central property is dispatch-equals-merge identity: the envelope approved before implementation remains associated with the resulting PR through merge. This provides a stable contract between intent and implementation. The source is a defensive publication rather than an evaluated research result.
Enforce intent before mutation
Claim Plane: Enforceable Change Intents and Dynamic Scope for Parallel Coding Agents separates probabilistic planning from deterministic authority. Versioned change intents declare committed and contingent operations, while atomic admission determines whether their mutation authority may coexist. Runtime scope promotion allows predeclared contingent work to become active only after re-admission against current work.
Claim Plane assumes candidate tasks already exist and does not address recursive decomposition. Its initial six-pair evaluation is preliminary. A 30-pair companion study supports conservative pre-write admission as a reliability mechanism but finds that useful selective concurrency remains unresolved.
Govern the PR queue as a connected system
BulkPR-Bench: Benchmarking Queue-Level Governance of Interacting Pull Requests changes the question from:
Is this PR safe?
to:
Which subset of the current PR queue is safe, and in what order can it be integrated?
It models dependencies, conflicts, duplicates, superseding PRs, all-or-none groups, and must-reject changes. Its results caution against autonomous LLM queue management: only 8 of 324 evaluated runs completed a queue exactly.
Synthesis
| Source | Contribution to the direction |
|---|---|
| Rethinking Code Review | Review begins before implementation and continues through integration |
| Capability-scoped envelopes | Approved intent becomes stable authority for one bounded PR |
| Claim Plane | Approved intent becomes enforceable mutation authority through deterministic admission and dynamic scope promotion |
| BulkPR-Bench | Intent and merge decisions consider other inflight work |
Together they support the two-stage model described above: an immutable task envelope, a dynamic view of the PR queue, and evaluation evidence at both admission points.
Research next step
Shadow-mode evaluation
Observe an existing PR queue without controlling implementation or merges. Test whether the model:
- detects duplicate or interacting work before implementation;
- reduces final-review effort by settling purpose and scope earlier; and
- proposes safe integration groups without increasing escaped defects or unnecessary re-planning.
The direction is worth pursuing only if those benefits survive comparison with the existing review process.
