💻 computer science

AI Agent Pull Requests on GitHub: Frequency, Structure, and Merge Conflict Rates

Dit artikel analyseert empirisch de AIDev-pop dataset om aan te tonen dat gelijktijdige inzendingen van AI-agents zeer prevalent zijn, voornamelijk dezelfde agent betreffen, en resulteren in aanzienlijk hogere merge-conflicts voor cross-agent paren vergeleken met intra-agent paren.

Oorspronkelijke auteurs: George Xu, Arjun Subramanian, Nithilan Karthik

Gepubliceerd 2026-07-08

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: George Xu, Arjun Subramanian, Nithilan Karthik

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je een enorme, drukke bouwplaats voor waar, in plaats van menselijke arbeiders, tientallen hooggeschoolde, onafhankelijke robots (AI-code-agenten) allemaal tegelijkertijd aan hetzelfde huis proberen te bouwen en het te repareren.

Dit artikel is een rapportcijfer voor wat er gebeurt wanneer deze robots proberen samen te werken zonder met elkaar te praten. De onderzoekers hebben duizenden echte projecten op GitHub bekeken om te zien hoe vaak deze robots botsen, hoe hun gevechten eruitzien en hoe rommelig de resultaten worden.

Hier is de uitsplitsing van hun bevindingen met behulp van eenvoudige analogieën:

1. De "Verkeersopstopping" van Robots

De eerste grote vraag was: Hoe vaak werken deze robots tegelijkertijd aan hetzelfde huis?

Het antwoord is: Bijna altijd.

De Bevinding: In ongeveer 40% van de projecten waren twee robots op exact hetzelfde moment actief aan het werk aan het huis. Als je ze een beetje meer tijd geeft (een venster van één week), stijgt dat aantal naar bijna 95%.
De Analogie: Stel je een drukke keuken voor waar 9 op de 10 chefs tegelijkertijd op dezelfde snijplank groenten aan het snijden zijn. Het is chaotisch, maar dat is de norm.
Wie vecht er? Verrassend genoeg is het zelden een gevecht tussen verschillende soorten robots (zoals een "Devin"-robot die vecht met een "Copilot"-robot). Het is bijna altijd dezelfde soort robot die met zichzelf vecht. In 99,5% van de gevallen is het conflict tussen twee instanties van hetzelfde AI-model die parallel werken. Het is alsoal je twee identieke tweelingen hebt die proberen dezelfde muur te schilderen zonder af te stemmen.

2. De "Botsing" (Merge Conflicts)

Wanneer twee robots proberen hun wijzigingen naar hetzelfde bestand op te slaan, moet de computer beslissen welke versie behouden moet worden. Dit wordt een "merge" genoemd. Als ze dezelfde regels hebben gewijzigd, raakt de computer in de war en geeft een "Conflict"-vlag af.

De onderzoekers simuleerden deze merges om te zien hoe vaak er dingen kapot gingen:

Zelfde Robot vs. Zelfde Robot: Wanneer twee instanties van dezelfde AI probeerden te mergen, botsten ze in 20% van de gevallen.
Verschillende Robots vs. Verschillende Robots: Wanneer twee verschillende soorten AI probeerden te mergen, botsten ze in 42% van de gevallen.
De Conclusie: Verschillende robots zijn twee keer zo snel geneigd om met elkaar te botsen als identieke robots. Echter, aangezien identieke robots het vaakst samenwerken, wordt de algemene chaos voornelijk door hen veroorzaakt.

3. Waar vechten ze over?

Wanneer de robots botsen, wat is dan de aard van het gevecht?

De Locatie: De meeste gevechten vinden plaats in de broncode (de eigenlijke instructies van de software), en niet in de "boodschappenlijstjes" (dependency-bestanden) of documentatie. Ongeveer 84% van de conflicten bevond zich in de code zelf.
Het Type Gevecht:
- Inhoudelijke Gevechten (58%): Beide robots probeerden dezelfde zin in dezelfde paragraaf te wijzigen.
- Structurele Gevechten (42%): Dit is het vreemdste deel. De ene robot besloot een bestand te verwijderen, terwijl de andere besloot het bestand te wijzigen. Of beide robots probeerden een nieuw bestand te maken met dezelfde naam maar verschillende inhoud.
- De Analogie: Het is alsof de ene robot zegt: "Ik sloop de keuken," terwijl de andere zegt: "Ik renoveer de keuken," en een derde zegt: "Ik bouw hier een nieuwe keuken." Ze kunnen niet allemaal gelijk hebben.

4. Waarom doet dit ertoe? (De Verborgen Kosten)

Het artikel merkt op dat hoewel we alleen de "tekstuele" gevechten hebben gemeten (de coderegels), de werkelijke kosten veel hoger zijn.

De "Verloren Tijd" Kost: Omdat de robots niet weten dat anderen aan het werk zijn, verspillen ze tijd aan het bouwen van functies die nooit gecombineerd kunnen worden.
De "Menselijke Opruim" Kost: Uiteindelijk moet een mens ingrijpen om de puinhoop op te ruimen. Zij moeten beslissen welke robot gelijk had, welk bestand behouden moet blijven en hoe zaken die verwijderd zijn, weer teruggebracht kunnen worden. Dit doet het doel van het laten doen van het werk door robots teniet.

Samenvatting

Het artikel concludeert dat AI-code-agenten op dit moment lijken op eenzame genieën die in een gedeelde kamer werken. Ze zijn individueel ongelooflijk productief, maar omdat ze niet met elkaar praten (zelfs wanneer het om hetzelfde model gaat), struikelen ze constant over hun eigen voeten.

Frequentie: Ze zijn bijna altijd gelijktijdig aan het werk.
Conflictpercentage: Ze botsen in 20% van de gevallen (dezelfde robot) en 42% van de gevallen (verschillende robots).
De Bende: De gevechten gaan vooral over de codestructuur (bestanden verwijderen versus toevoegen) in plaats van alleen maar eenvoudige typefouten.

De onderzoekers suggereren dat voor AI echt kan helpen bij het bouwen van software, we deze robots moeten leren hoe ze hun schema's kunnen coördineren en met elkaar kunnen praten voordat ze beginnen te hameren op dezelfde code.

Technische Samenvatting: AI-agent Pull Requests op GitHub

Probleemstelling

Hoewel AI-coderingsagenten zijn geëvolueerd om onafhankelijk te opereren—door problemen te beoordelen, fixes te schrijven en autonoom Pull Requests (PR's) in te dienen—bestaat er een kritieke kloof in het begrijpen van de implicaties van gelijktijdige agentactiviteit. Voorgaand onderzoek heeft zich gericht op de kwaliteit van individuele agent-outputs of conflicten tussen de PR van een enkele agent en de base branch. Er is echter geen empirische examinatie van wat er gebeurt wanneer meerdere agenten (of meerdere instanties van dezelfde agent) gelijktijdig aan hetzelfde repository werken. Specifiek ontbreken gegevens in de literatuur over:

De frequentie van gelijktijdige agentic workflows op GitHub.
De waarschijnlijkheid dat deze gelijktijdige workflows met elkaar zullen conflicteren.
De structurele aard van deze conflicten (bijv. tekstueel versus semantisch).

Dit artikel behandelt de "coördinatiekloof" tussen architectuur en tekst in autonome ontwikkeling, waarbij wordt opgemerkt dat hoewel versiebeheertools tekstuele conflicten op regelniveau kunnen detecteren, ze niet inherent in staat zijn om conflicterende intenties tussen meerdere autonome ontwikkelaars op te lossen.

Methodologie

De studie maakt gebruik van de AIDev-pop dataset, bestaande uit 33.596 PR's verspreid over 2.807 repositories. De auteurs hanteren een vierdelige empirische aanpak:

Formalisering van Co-activiteit: De auteurs definiëren "co-actieve" PR's op basis van temporele overlap. Een PR $P_i$ wordt gedefinieerd door de repository, de verwerkende agent, de openingstijd ( $T_{open}$ ) en de sluitingstijd ( $T_{close}$ ). Twee PR's worden als co-actief beschouwd als hun activiteitsvensters $[T_{open} - k, T_{close} + k]$ overlappen. De studie analyseert dit over vier tijd-padding drempelwaarden ( $k \in \{0, 1, 3, 7\}$ dagen).
Gestreifieerde Steekproef: Om te voorkomen dat de resultaten worden vertekend door zeer actieve repositories, hebben de auteurs een gestratificeerde steekproef gemaakt voor merge-replay:
- Stratum A (Intra-agent): 625 repositories, elk met één paar PR's van dezelfde agent.
- Stratum B (Cross-agent): Alle 122 repositories die cross-agent activiteit vertonen, elk met één paar PR's van verschillende agenten.
- Totaal Sample: 747 unieke co-actieve paren.
Grootschalige Merge Replay: De auteurs hebben een geautomatiseerd, multi-threaded proces ontwikkeld met behulp van headless git merge-tree functionaliteit. Dit simuleert een drie-weg merge in het geheugen zonder de werkmap aan te tasten. Het proces haalt de head commits van beide PR's op, identificeert de gemeenschappelijke voorouder (common ancestor) en probeert een merge uit te voeren.
- Conflict Detectie: Een return code van 1 duidt op een tekstueel conflict. Het systeem extraheert conflicterende bestandspaden en conflicttypen (bijv. content, modify/delete, add/add).
- Scope: De studie richt zich strikt op tekstuele conflicten (Laag 1). De auteurs merken op dat dit een "conservatieve ondergrens" biedt voor de totale systeemfrictie, aangezien build- (Laag 2) en semantische (Laag 3) conflicten niet kunnen optreden zonder een succesvolle tekstuele merge.
Taxonomie Analyse: Conflicten worden gecategoriseerd op bestandstype (broncode, dependencies, config, etc.) en structureel type (content overlap versus structurele wijzigingen zoals bestandsverwijdering).

Belangrijkste Bijdragen en Resultaten

1. Frequentie van Gelijktijdigheid (RQ1)

Gelijktijdige agentactiviteit is wijdverspreid.

Strikte Overlap ( $k=0$ ): 40,2% van de repositories bevat ten minste één paar co-actieve PR's.
PR-niveau Prevalentie: 79,4% van alle door agenten gegenereerde PR's is gelijktijdig met een andere agent-PR geopend.
Uitgebreide Vensters: Wanneer een venster van ±7 dagen wordt toegestaan, vertonen 53,4% van de repositories en 95,0% van de PR's co-activiteit.

2. Samenstelling van Co-activiteit (RQ2)

De overgrote meerderheid van de gelijktijdigheid is intra-agent, niet cross-agent.

Intra-agent: 99,5% van de co-actieve paren is geschreven door dezelfde agent-model.
Cross-agent: Slechts 0,5% van de paren betreft verschillende agenten, voorkomend in slechts 122 van de 2.807 repositories (ongeveer 4,3%).
Dominantie: OpenAI Codex is de primaire drijfveer van gelijktijdigheid en fungeert als de "meerderheidsanker" voor cross-agent interacties vanwege het hoge volume.

3. Merge Conflict Ratio's (RQ3)

Er is aanzienlijke frictie bij het mergen van gelijktijdige agent-PR's, met een duidelijk onderscheid tussen intra- en cross-agent scenario's:

Intra-agent Conflict Ratio: 19,8% (119/601 paren).
Cross-agent Conflict Ratio: 41,7% (48/115 paren).
Statistische Significantie: De 95% betrouwbaarheidsintervallen voor deze ratio's overlappen niet, wat wijst op een duidelijk onderscheid in de waarschijnlijkheid van conflicten tussen de twee categorieën.

4. Conflictstructuur en Taxonomie

De aard van de conflicten onthult diepe coördinatiefouten:

Bestandstypes: 84,4% van de geconflicteerde bestanden is broncode, wat de aanname tegenspreekt dat manifestaties in dependencies de primaire bron van conflict zijn.
Structureel vs. Content:
- 57,6% zijn content-conflicten (verschillende updates aan dezelfde regels).
- 41,9% zijn structurele conflicten (26,8% modify/delete en 15,1% add/add).
Implicatie: Agents verschillen vaak van mening over de vraag of een bestand überhaupt moet bestaan, of creëren onafhankelijk van elkaar versies van hetzelfde nieuwe bestand, wat duidt op een gebrek aan bewustzijn van parallelle operaties.

5. Associaties (RQ4)

Doorvoersnelheid (Throughput): PR-niveau co-activiteit neemt toe met de repository-doorvoersnelheid (van ~53% in laag-doorvoersnelheid repos naar ~90% in hoog-doorvoersnelheid repos).
Agents: Devin (82,5%) en OpenAI Codex (80,9%) vertonen de hoogste PR-niveau co-activiteitsratio's.
Talen: Go (92%) en Ruby (87%) repositories vertonen de hoogste co-activiteitsratio's, terwijl C++ (56%) en HTML (44%) de laagste vertonen.

Betekenis en Claims

Het artikel beweert de eerste empirische examinatie van gelijktijdige agent-inzendingen te bieden. De primaire betekenis ligt in het uitdagen van de theoretische aanname dat multi-agent orchestratie momenteel een probleem is van heterogene vendor-coördinatie. In plaats daarvan onthullen de gegevens dat de dominante operationele kwestie het beheer is van de hoogfrequente output van een enkel agent-framework.

De auteurs stellen dat:

Gebrek aan Bewustzijn: Huidige agents opereren in isolatie zonder "horizontaal bewustzijn" van andere agents (zelfs van hetzelfde type) die dezelfde bestanden wijzigen.
Conservatieve Schattingen: De gerapporteerde conflictratio's (19,8% en 41,7%) zijn conservatieve ondergrenzen. Ze vertegenwoordigen alleen tekstuele conflicten; de werkelijke kosten omvatten ongemeten build-fouten, semantische tegenstrijdigheden, CI/CD rekenkrachtverspilling en het uitputten van token-budgetten.
Structurele Onenigheid: De hoge mate van structurele conflicten (modify/delete, add/add) suggereert dat agents niet alleen regels bewerken, maar fundamenteel van mening verschillen over de structuur van de repository, een probleem dat eenvoudige code review niet gemakkelijk kan oplossen.

De studie concludeert dat ongecoördineerde reactieve ontwikkelingsparadigma's onvoldoende zijn voor moderne autonome engineering en dat toekomstig onderzoek zich moet richten op programmatische orchestratie en live workspace communicatieprotocollen om deze integratiefricties te mitigeren.