💻 computer science

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

Este artigo analisa empiricamente o conjunto de dados AIDev-pop para revelar que submissões simultâneas de agentes de IA são altamente prevalentes, envolvem predominantemente o mesmo agente e resultam em taxas de conflito de mesclagem significativamente maiores para pares entre agentes diferentes em comparação com os intra-agente.

Autores originais: George Xu, Arjun Subramanian, Nithilan Karthik

Publicado 2026-07-08

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: George Xu, Arjun Subramanian, Nithilan Karthik

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine um canteiro de obras massivo e movimentado onde, em vez de trabalhadores humanos, você tem dezenas de robôs altamente qualificados e independentes (agentes de codificação de IA) todos tentando construir ou consertar a mesma casa ao mesmo tempo.

Este artigo é um boletim de notas sobre o que acontece quando esses robôs tentam trabalhar juntos sem conversarem entre si. Os pesquisadores analisaram milhares de projetos reais no GitHub para ver com que frequência esses robôs colidem, como são suas brigas e o quão bagunçados ficam os resultados.

Aqui está o detalhamento de suas descobertas usando analogias simples:

1. O "Engarrafamento" de Robôs

A primeira grande questão era: Com que frequência esses robôs estão trabalhando na mesma casa ao mesmo tempo?

A resposta é: Quase sempre.

A Descoberta: Em cerca de 40% dos projetos, dois robôs estavam trabalhando ativamente na casa no exato mesmo segundo. Se você der a eles um pouco mais de tempo (uma janela de uma semana), esse número salta para quase 95%.
A Analogia: Imagine uma cozinha movimentada onde 9 em cada 10 chefs estão picando vegetais na mesma tábua de cortar ao mesmo tempo. É caótico, mas é a norma.
Quem está brigando? Surpreendentemente, raramente é uma briga entre diferentes tipos de robôs (como um robô "Devin" brigando com um robô "Copilot"). É quase sempre o mesmo tipo de robô brigando consigo mesmo. Em 99,5% dos casos, o conflito é entre duas instâncias do mesmo modelo de IA trabalhando em paralelo. É como ter dois gêmeos idênticos tentando pintar a mesma parede sem coordenação.

2. O "Conflito" (Merge Conflicts)

Quando dois robôs tentam salvar suas alterações no mesmo arquivo, o computador precisa decidir qual versão manter. Isso é chamado de "merge" (fusão). Se eles alteraram as mesmas linhas, o computador fica confuso e lança um aviso de "Conflito".

Os pesquisadores simularam esses merges para ver com que frequência as coisas quebravam:

Mesmo Robô vs. Mesmo Robô: Quando duas instâncias do mesmo IA tentaram fazer o merge, elas colidiram cerca de 20% das vezes.
Robôs Diferentes vs. Robôs Diferentes: Quando dois diferentes tipos de IA tentaram fazer o merge, elas colidiram cerca de 42% das vezes.
A Conclusão: Robôs diferentes têm o dobro de probabilidade de discordar entre si do que robôs idênticos. No entanto, como robôs idênticos são os que trabalham juntos com mais frequência, a bagunça geral é causada principalmente por eles.

3. Sobre o que eles estão brigando?

Quando os robôs colidem, qual é a natureza da briga?

O Local: A maioria das brigas acontece no código-fonte (as instruções reais do software), não nas "listas de compras" (arquivos de dependência) ou na documentação. Cerca de 84% dos conflitos foram no próprio código.
O Tipo de Briga:
- Brigas de Conteúdo (58%): Ambos os robôs tentaram alterar a mesma frase no mesmo parágrafo.
- Brigas Estruturais (42%): Esta é a parte mais estranha. Um robô decidiu deletar um arquivo, enquanto o outro decidiu modificá-lo. Ou, ambos os robôs tentaram criar um arquivo novo com o mesmo nome, mas conteúdos diferentes.
- A Analogia: É como um robô dizendo: "Eu vou derrubar a cozinha", enquanto o outro diz: "Eu vou reformar a cozinha", e um terceiro diz: "Eu vou construir uma nova cozinha bem aqui". Eles não podem estar todos certos.

4. Por que isso importa? (Os Custos Escondidos)

O artigo observa que, embora tenhamos medido apenas as brigas "textuais" (linhas de código), o custo real é muito maior.

O Custo de "Tempo Perdido": Como os robôs não sabem que os outros estão trabalhando, eles perdem tempo construindo funcionalidades que nunca poderão ser combinadas.
O Custo de "Limpeza Humana": Eventualmente, um humano precisa intervir para consertar a bagunça. Ele tem que decidir qual robô estava certo, qual arquivo manter e como desfazer as deleções. Isso anula o propósito de ter robôs fazendo o trabalho em primeiro lugar.

Resumo

O artigo conclui que, no momento, os agentes de codificação de IA são como gênios solitários trabalhando em uma sala compartilhada. Eles são incrivelmente produtivos individualmente, mas, como não conversam entre si (mesmo sendo o mesmo modelo), eles constantemente tropeçam nos próprios pés.

Frequência: Eles estão quase sempre trabalhando simultaneamente.
Taxa de Conflito: Eles colidem cerca de 20% das vezes (mesmo robô) e 42% das vezes (robôs diferentes).
A Bagunça: As brigas são principalmente sobre a estrutura do código (deletar vs. adicionar arquivos) e não apenas sobre erros de digitação simples.

Os pesquisadores sugerem que, para a IA realmente ajudar a construir software, precisamos ensinar esses robôs a coordenar seus cronogramas e conversar entre si antes de começarem a martelar o mesmo código.

Resumo Técnico: Pull Requests de Agentes de IA no GitHub

Declaração do Problema

Embora os agentes de codificação por IA tenham evoluído para operar de forma independente — avaliando problemas, escrevendo correções e enviando Pull Requests (PRs) autonomamente — existe uma lacuna crítica na compreensão das implicações da atividade concorrente de agentes. Pesquisas anteriores focaram na qualidade das saídas individuais de um agente ou nos conflitos entre o PR de um único agente e sua branch base. No entanto, não há um exame empírico do que acontece quando múltiplos agentes (ou múltiplas instâncias do mesmo agente) trabalham no mesmo repositório simultaneamente. Especificamente, a literatura carece de dados sobre:

A frequência de fluxos de trabalho agênticos simultâneos no GitHub.
A probabilidade de que esses fluxos de trabalho simultâneos entrem em conflito entre si.
A natureza estrutural desses conflitos (ex: texto vs. semântica).

Este artigo aborda a "lacuna de coordenação" entre arquitetura e texto no desenvolvimento autônomo, observando que, embora as ferramentas de controle de versão possam detectar conflitos de texto em nível de linha, elas não podem inerentemente resolver intenções conflitantes entre múltiplos desenvolvedores autônomos.

Metodologia

O estudo utiliza o dataset AIDev-pop, composto por 33.596 PRs em 2.807 repositórios. Os autores empregam uma abordagem empírica de quatro partes:

Formalização de Coatividade: Os autores definem PRs "coativos" com base na sobreposição temporal. Um PR $P_i$ é definido por seu repositório, agente autor, tempo de abertura ( $T_{open}$ ) e tempo de fechamento ( $T_{close}$ ). Dois PRs são considerados coativos se suas janelas de atividade $[T_{open} - k, T_{close} + k]$ se sobreporem. O estudo analisa isso através de quatro limiares de preenchimento de tempo ( $k \in \{0, 1, 3, 7\}$ dias).
Amostragem Estratificada: Para evitar o viés de resultados de repositórios altamente ativos, os autores criaram uma amostra estratificada para o replay de merge:
- Estrato A (Intra-agente): 625 repositórios, cada um contribuindo com um par de PRs do mesmo agente.
- Estrato B (Cross-agent): Todos os 122 repositórios que exibem atividade cross-agent, cada um contribuindo com um par de PRs de diferentes agentes.
- Amostra Total: 747 pares coativos únicos.
Replay de Merge em Larga Escala: Os autores desenvolveram um processo automatizado e multithread usando funcionalidade de git merge-tree headless. Isso simula um merge de três vias na memória sem tocar no diretório de trabalho. O processo busca os commits de topo de ambos os PRs, identifica o ancestral comum e tenta um merge.
- Detecção de Conflito: Um código de retorno de 1 indica um conflito textual. O sistema extrai caminhos de arquivos conflitantes e tipos de conflito (ex: content, modify/delete, add/add).
- Escopo: O estudo foca estritamente em conflitos textuais (Camada 1). Os autores observam que isso fornece um "limite inferior conservador" para o atrito total do sistema, pois conflitos de build (Camada 2) e semânticos (Camada 3) não podem ocorrer sem um merge textual bem-sucedido.
Análise de Taxonomia: Os conflitos são categorizados por tipo de arquivo (código fonte, dependências, configuração, etc.) e tipo estrutural (sobreposição de conteúdo vs. mudanças estruturais como exclusão de arquivo).

Contribuições Principais e Resultados

1. Frequência de Concorrência (RQ1)

A atividade concorrente de agentes é onipresente.

Sobreposição Estrita ( $k=0$ ): 40,2% dos repositórios contêm pelo menos um par de PRs coativos.
Prevalência ao Nível de PR: 79,4% de todos os PRs autoria de agentes são abertos concorrentemente com outro PR de agente.
Janelas Expandidas: Ao permitir uma janela de ±7 dias, 53,4% dos repositórios e 95,0% dos PRs exibem coatividade.

2. Composição da Coatividade (RQ2)

A grande maioria da concorrência é intra-agente, não cross-agent.

Intra-agente: 99,5% dos pares coativos são autoria do mesmo modelo de agente.
Cross-agent: Apenas 0,5% dos pares envolvem agentes diferentes, ocorrendo em apenas 122 dos 2.807 repositórios (aprox. 4,3%).
Dominância: O OpenAI Codex é o principal motor da concorrência, atuando como a "âncora majoritária" para interações cross-agent devido ao seu alto volume.

3. Taxas de Conflito de Merge (RQ3)

Existe um atrito significativo ao mesclar PRs de agentes concorrentes, com uma distinção clara entre cenários intra e cross-agente:

Taxa de Conflito Intra-agente: 19,8% (119/601 pares).
Taxa de Conflito Cross-agent: 41,7% (48/115 pares).
Significância Estatística: Os intervalos de confiança de 95% para essas taxas não se sobrepõem, indicando uma distinção clara na probabilidade de conflito entre as duas categorias.

4. Estrutura de Conflito e Taxonomia

A natureza dos conflitos revela falhas profundas de coordenação:

Tipos de Arquivo: 84,4% dos arquivos conflitantes são código fonte, contradizendo a suposição de que manifestos de dependências são a principal fonte de conflito.
Estrutural vs. Conteúdo:
- 57,6% são conflitos de conteúdo (atualizações diferentes nas mesmas linhas).
- 41,9% são conflitos estruturais (26,8% modify/delete e 15,1% add/add).
Implicação: Agentes frequentemente discordam sobre se um arquivo deve existir ou criam versões independentes do mesmo novo arquivo, indicando uma falta de consciência de operações paralelas.

5. Associações (RQ4)

Throughput: A coatividade ao nível de PR aumenta com o throughput do repositório (de ~53% em repositórios de baixo throughput para ~90% em repositórios de alto throughput).
Agentes: Devin (82,5%) e OpenAI Codex (80,9%) apresentam as maiores taxas de coatividade ao nível de PR.
Linguagens: Repositórios de Go (92%) e Ruby (87%) apresentam as maiores taxas de coatividade, enquanto C++ (56%) e HTML (44%) apresentam as menores.

Significância e Alegações

O artigo afirma fornecer o primeiro exame empírico de submissões de agentes concorrentes. Sua principal significância reside em desafiar a suposição teórica de que a orquestração multi-agente é atualmente um problema de coordenação entre fornecedores heterogêneos. Em vez disso, os dados revelam que o problema operacional dominante é o gerenciamento do alto volume de saída de um único framework de agente.

Os autores afirmam que:

Falta de Consciência: Os agentes atuais operam isoladamente, sem "consciência horizontal" de outros agentes (mesmo do mesmo tipo) modificando os mesmos arquivos.
Estimativas Conservadoras: As taxas de conflito relatadas (19,8% e 41,7%) são limites inferiores conservadores. Elas representam apenas conflitos textuais; o custo real inclui falhas de build não mensuradas, contradições semânticas, desperdício de computação de CI/CD e depleção de orçamento de tokens.
Desacordo Estrutural: A alta taxa de conflitos estruturais (modify/delete, add/add) sugere que os agentes não estão apenas editando linhas, mas discordando fundamentalmente da estrutura do repositório, um problema que o simples code review não consegue resolver facilmente.

O estudo conclui que paradigmas de desenvolvimento reativo não coordenados são insuficientes para a engenharia autônoma moderna e que pesquisas futuras devem focar em orquestração programática e protocolos de comunicação de workspace ao vivo para mitigar esses atritos de integração.