Scout: Agent Integration Costs: Merge Conflicts, Review Overhead, and Coordination Patterns

Summary

Three empirical studies published in the same week quantify what practitioners have felt but couldn’t prove: agent-generated code is cheap to produce and expensive to integrate. AgenticFlict analyzed 142K+ agent-authored pull requests and found a 27.67% merge conflict rate — meaning roughly one in four agent PRs creates integration work that someone must resolve. A companion study on PR cross-references found that agent-referenced PRs have substantially longer review lifespans than isolated PRs, revealing an emerging pattern where humans integrate and agents fix. A third paper tested the industry claim that code review agents (CRAs) handle review autonomously and found a 23-percentage-point merge rate gap between CRA-only and human-reviewed PRs, with 92% of CRAs producing feedback with signal-to-noise ratios below 60%. The root cause across all three findings is the same: stateless agents generating code in parallel without shared contracts, coordination protocols, or architectural awareness. The mitigation patterns are emerging — shared specs, worktree isolation, file-level locking, interface ownership — but remain early and unevenly adopted.

Key Findings

1. The 28% Conflict Rate: Scale Reveals the Problem

The AgenticFlict dataset represents the first large-scale empirical measurement of merge conflicts in agent-generated contributions [1]. The numbers are stark:

• 142,000+ agent-authored PRs collected across 59,000+ repositories
• 107,000+ successfully processed through deterministic merge simulation
• 29,000+ PRs exhibiting merge conflicts — a 27.67% conflict rate
• 336,000+ fine-grained conflict regions extracted

For context, typical human-authored conflict rates in active projects range from 10-15%. A near-28% rate means agent-generated code creates roughly twice the merge overhead of human-generated code, and with notable variation across different AI agents — some tools produce substantially more conflicting contributions than others.

The root cause is structural. Current coding agents are stateless within and across sessions. They don’t know what other agents (or humans) are working on. They don’t check for in-flight changes to files they’re modifying. They generate patches against a snapshot of HEAD that may be stale before the PR is even opened. At the scale of a single developer using one agent, this is manageable. At the scale of teams running multiple agents in parallel — what practitioners are now calling “agentmaxxing” — the conflict rate becomes a binding constraint on throughput.

2. The Review Tax: Cross-Referenced PRs Are More Expensive

The “Humans Integrate, Agents Fix” study analyzed agent-authored PR references from the AIDev dataset and identified a clear division of labor [2]:

• Humans initiate most references to agent-authored PRs, primarily to build new features
• Agents reference PRs primarily to fix errors in their own or other agents’ prior work
• Referenced PRs have substantially longer lifespans and review times compared to isolated PRs

This finding inverts the productivity narrative. Agent-generated PRs that exist in isolation (simple, self-contained changes) are fast to review and merge. But the moment a PR references or is referenced by other PRs — which happens increasingly as agents tackle larger features — the review burden grows. The study reveals “meta-collaborative workflows” where humans spend time not just reviewing code, but understanding the relationships between agent-generated changes.

Separate research on 33,707 agent-authored PRs found a bimodal outcome pattern: 28.3% of agent PRs merge instantly (narrow, well-scoped tasks), but when iterative refinement is needed, agents frequently abandon the effort, yielding a 3.8% “ghosting rate” when faced with subjective feedback [3]. The implication: agents excel at one-shot tasks but create a hidden “attention tax” on maintainers when work requires coordination.

3. Code Review Agents: The Signal-to-Noise Problem

The “From Industry Claims to Empirical Reality” study is the most methodologically rigorous assessment of CRA performance to date [4]. Analyzing 3,109 PRs and 19,450 review comments across 13 CRAs:

The signal-to-noise analysis is damning: 60.2% of closed CRA-only PRs fell into the 0-30% signal range (predominantly noisy feedback), and 12 of 13 CRAs (92.31%) exhibited average signal ratios below 60%. Individual CRA performance varied dramatically — from Copilot at 19.79% average signal to one niche CRA achieving 100% on a single PR.

The practical conclusion: CRAs configured for general-purpose review generate more noise than signal, increasing developer cognitive load and PR abandonment. CRAs configured for narrow, specific checks (security scanning, style enforcement) perform better but are not substitutes for human review judgment. The study’s Chi-squared test (p < 0.001) confirms the merge rate difference is statistically significant, not noise.

4. Root Causes: Why Agents Create Integration Debt

The empirical data converges on three structural root causes:

Statelessness. Current coding agents operate without persistent memory of what other agents or developers are doing. Each agent generates code against its own snapshot of the codebase, creating a combinatorial explosion of potential conflicts as the number of concurrent agents grows. CodeCRDT research demonstrated that observation-driven coordination (agents monitoring shared state) can help, but incurs its own costs — up to 39.4% slowdown on some tasks while achieving up to 21.1% speedup on others [5].

No shared contracts. Agents lack shared interface definitions or architectural constraints. When two agents independently modify the same API surface, they make incompatible assumptions. The CMU Cursor adoption study found that code complexity increased 41% and static analysis warnings increased 30% after AI tool adoption — even controlling for velocity increases — suggesting the complexity growth is inherent to how agents generate code, not merely a volume effect [6].

Parallel generation without coordination. The DORA 2025 report found that 90% AI adoption correlated with negative software delivery stability, not because agents write worse code, but because increased change volume exposes coordination weaknesses downstream [7]. Nicole Forsgren’s QCon presentation framed this as “the AI productivity paradox” — generating code faster makes deployment bottlenecks more expensive.

5. Post-Merge Quality: The Cost Doesn’t End at Integration

Even after merge conflicts are resolved and PRs are accepted, agent-generated code carries ongoing costs. A study analyzing 1,210 merged bug-fix PRs from five AI coding agents across 206 Python repositories found [8]:

• Code smells dominate: 212 instances of duplicated string literals, 157 instances of excessive cognitive complexity, 114 unused function parameters
• Bugs are infrequent but severe: 23 instances of incorrect function argument counts (BLOCKER severity), 15 instances of misused non-iterables
• Apparent quality differences between agents disappear after normalizing by code churn — higher issue counts are primarily driven by larger PRs, not inherently worse agents

The maintenance implication: unmanaged AI-generated code can drive maintenance costs to 4x traditional levels by the second year as technical debt compounds [9]. The post-merge quality problem compounds the integration cost problem — teams pay twice, first to integrate and then to maintain.

6. Mitigation Patterns: From Coordination Avoidance to Coordination Infrastructure

Three tiers of mitigation have emerged, ordered from simplest to most sophisticated:

Tier 1: Isolation (avoid the problem). Git worktree isolation gives each agent a separate working directory and index while sharing a single .git object database. Conflicts are deferred to intentional merge points [10]. This is now the baseline practice — Claude Code supports built-in worktree isolation for subagents, Codex App provides conflict-free worktrees, and tools like Parallel Code automate worktree creation per agent task [11]. The practical ceiling is 5-7 concurrent agents before rate limits, merge conflicts, and review bottleneck eat the gains.

Tier 2: Ownership (partition the problem). File-level locking and task assignment prevent agents from touching the same files. Agent-MCP implements this as a coordination primitive: when an agent requests work, the system finds the next available task with no blocking dependencies or file conflicts, locks relevant files, and routes other agents to different work [12]. Designating one agent as owner of shared files (like route definitions) and having other agents add through import-based extension is a common pattern [13]. The limitation: ownership partitioning requires decomposition granularity that maps to file boundaries, which isn’t always natural.

Tier 3: Shared specification (coordinate the problem). The most sophisticated approach uses living specifications as the coordination mechanism. Routa implements this as “workspace-first multi-agent coordination” — shared specs with acceptance criteria, Kanban-based orchestration, and protocol support (MCP/ACP/A2A) — where a Coordinator agent plans work, writes specs, and delegates to specialists but never writes code itself [14]. Augment Code’s guide prescribes “one shared spec with acceptance criteria, one worktree per agent, and quality gates that block unsafe merges” as non-negotiable coordination rules [13]. Spec-driven development (SDD) research shows this approach eliminates the coordination overhead that kills enterprise velocity by making specifications the alignment mechanism [15].

The tradeoff across tiers is clear: Tier 1 is cheap to adopt but doesn’t scale. Tier 2 scales better but requires upfront task decomposition. Tier 3 scales best but demands investment in specification infrastructure that many teams don’t yet have. Most teams today are at Tier 1, which is why the 28% conflict rate exists.

Practical Implications

Measure integration cost, not just generation speed. The headline metric for agent-assisted development should include merge conflict rate, review cycle time, and post-merge defect density — not just “lines generated” or “PRs opened.” A team generating 4x more PRs but with a 28% conflict rate and 2x review time may be net-negative on throughput.

Default to worktree isolation immediately. If you’re running more than one agent concurrently and not using worktrees, you’re generating avoidable merge conflicts. This is table-stakes infrastructure that every major agent CLI now supports.

Scope agent tasks to file-disjoint units. The single most effective conflict prevention strategy is ensuring concurrent agents don’t touch the same files. This requires upfront decomposition work — which is itself a form of the specification investment that Tier 3 demands. The payoff is immediate: zero-conflict parallel execution.

Configure CRAs for narrow checks, not general review. General-purpose code review agents generate more noise than signal (60% of CRA-reviewed PRs had below 30% signal). Configure them for specific checks — security scanning, style enforcement, dependency auditing — and require human approval before merge.

Invest in living specifications as coordination infrastructure. The “velocity without alignment is negative productivity” thesis from Edition 5 gets its strongest empirical support this week. Teams that treat specifications as first-class, machine-readable coordination artifacts — not just documentation for humans — will be the ones that scale agent-assisted development without drowning in integration debt. CLAUDE.md, AGENTS.md, and architecture specs are not optional nice-to-haves; they’re the coordination layer.

Adopt merge-early practices for agent branches. Don’t let agent branches diverge for days. Merge the first completed branch into main, then rebase remaining branches before they finish. Short-lived branches with frequent integration are the established practice for human teams; they’re even more critical when agents are generating code at higher velocity.

Open Questions

What is the conflict rate breakdown by agent? AgenticFlict reports “noticeable variation across agents” but the abstract doesn’t publish per-agent conflict rates. The full dataset (Zenodo DOI: 10.5281/zenodo.19396917) likely contains this breakdown — understanding which agents produce more conflicts would be immediately actionable for tool selection.

Does spec-driven coordination actually reduce conflict rates? The theoretical case for shared specs as coordination infrastructure is strong, but no study has yet measured conflict rates before and after SDD adoption. The Kitchen Loop paper reports 1,094+ merged PRs with zero regressions, but that’s a single-agent workflow — the multi-agent coordination case remains unproven empirically.

How do conflict patterns differ by language and project structure? The 28% average likely masks significant variation by language (dynamic vs. static types), project structure (monorepo vs. polyrepo), and architecture (modular vs. monolithic). Teams need granular data to calibrate their mitigation strategies.

Can agents learn project conventions well enough to reduce integration friction? The “Learning to Commit” paper showed agents get rejected for violating project conventions, not for writing broken code. If agents could internalize a project’s change patterns — file ownership norms, API surface conventions, test structure — the integration cost might drop substantially. This is the skills layer opportunity: encoding coordination conventions as agent context.

What is the optimal number of concurrent agents? Practitioners report 5-7 concurrent agents as the practical ceiling. But this number is likely sensitive to project structure, task granularity, and coordination infrastructure. No study has systematically explored the scaling curve.

Sources

1. Ogenrwot, D. & Businge, J. “AgenticFlict: A Large-Scale Dataset of Merge Conflicts in AI Coding Agent Pull Requests on GitHub.” arXiv:2604.03551, April 2026. Link
2. Khemissi, I. et al. “Humans Integrate, Agents Fix: How Agent-Authored Pull Requests Are Referenced in Practice.” arXiv:2604.04059, April 2026. Link
3. “Early-Stage Prediction of Review Effort in AI-Generated Pull Requests.” arXiv:2601.00753, January 2026. Link
4. Chowdhury, K. et al. “From Industry Claims to Empirical Reality: An Empirical Study of Code Review Agents in Pull Requests.” MSR 2026. arXiv:2604.03196, April 2026. Link
5. “CodeCRDT: Observation-Driven Coordination for Multi-Agent LLM Code Generation.” arXiv:2510.18893. Link
6. “Speed at the Cost of Quality: How Cursor AI Increases Short-Term Velocity but Degrades Code Quality.” CMU, MSR 2026. arXiv:2511.04427. Link
7. Google DORA. “State of AI-Assisted Software Development 2025.” Link
8. “Beyond Bug Fixes: An Empirical Investigation of Post-Merge Code Quality Issues in Agent-Generated Pull Requests.” arXiv:2601.20109. Link
9. Sandelin, M. “Your AI Agent Teams Are Burning Money. Here’s the Math.” Medium, February 2026. Link
10. “What is Worktree Isolation in AI Agents?” BSWEN, March 2026. Link
11. “Git Worktree Conflicts with Multiple AI Agents: Diagnosis and Fixes.” Termdock. Link
12. Agent-MCP Framework. GitHub. Link
13. “How to Run a Multi-Agent Coding Workspace (2026).” Augment Code. Link
14. Routa: Workspace-First Multi-Agent Coordination Platform. GitHub. Link
15. “Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants.” arXiv:2602.00180. Link
16. Mason, M. “AI Coding Agents in 2026: Coherence Through Orchestration, Not Autonomy.” January 2026. Link
17. “Merge Hell: How AI Tools Are Adding Chaos to Collaborative Coding.” Geeky Gadgets. Link
18. Forsgren, N. “DevEx Highlights.” QCon presentation. Link
19. Multi-Agent Coordination MCP Server. GitHub. Link
20. “Agentmaxxing: Run Multiple AI Agents in Parallel (2026).” Link
21. “Where Do AI Coding Agents Fail? An Empirical Study of Failed Agentic Pull Requests in GitHub.” arXiv:2601.15195. Link
22. “When AI Agents Collide: Multi-Agent Orchestration Failure Playbook for 2026.” Cogent. Link
23. HubSpot Sidekick: Multi-Model AI Code Review. InfoQ, March 2026. Link
24. “The Artificer’s Grimoire — Edition 5.” March 29, 2026. Link