Codex levou a infraestrutura Git da OpenAI ao limite: 5 mudanças em cadeia por trás do crescimento projetado de 2.442% nos commits trimestrais

Nota do autor: a OpenAI apresentou o Pando, seu novo backend para Git. Com o Codex, o volume trimestral de commits no monorepositório deve crescer 2442% em relação ao primeiro trimestre de 2024. Este artigo mostra como os efeitos da programação com IA se propagam da geração de código para o Git, a CI e a revisão de código.

Em 2 de novembro de 2026, a OpenAI publicou o artigo técnico “Scaling Git at OpenAI”. Um gráfico do artigo mostra que o volume trimestral de commits no monorepositório da OpenAI deve crescer 2442% no quarto trimestre de 2026 em relação ao primeiro trimestre de 2024. Para lidar com a pressão do desenvolvimento paralelo impulsionado pelo Codex, a OpenAI criou um novo backend para Git, chamado Pando.

Isso não é um boato nem um slogan de marketing sobre “a IA multiplicar o volume de código por 24”. Os dados vêm do blog oficial de engenharia da OpenAI, em um artigo assinado por Aaron Friel, Taylor Blau e Ted Nyman. Vale esclarecer dois pontos: os 2442% são uma projeção, já que o quarto trimestre ainda não terminou; e a métrica é o número de commits incorporados à branch master, não o número de linhas de código, muito menos a produtividade.

O que você vai entender: como o Codex está mudando a escala do desenvolvimento de software na OpenAI por meio de tarefas paralelas, por que isso pressiona a infraestrutura do Git e para onde os gargalos do desenvolvimento estão migrando.

Codex e a infraestrutura Git da OpenAI: resumo das informações

Vamos começar com uma tabela dos fatos. Todas as informações abaixo foram divulgadas oficialmente pela OpenAI; o que não foi informado está indicado.

Panorama do crescimento trimestral de commits impulsionado pelo Codex

Muitas notícias citam apenas o crescimento de 2.442%. A sequência trimestral completa ajuda a entender melhor o cenário. A tabela abaixo usa o primeiro trimestre de 2024 como base e contabiliza os commits incorporados à branch master do monorepositório da OpenAI a cada trimestre.

Esses dados mostram três coisas. Primeiro, o crescimento já vinha acontecendo entre 2024 e 2025, então não dá para atribuí-lo inteiramente ao Codex. Segundo, a curva fica claramente mais íngreme entre os +264% do quarto trimestre de 2025 e os +1.378% do terceiro trimestre de 2026. Essa aceleração é compatível com a tendência de desenvolvimento paralelo com agentes descrita pela OpenAI. Terceiro, a empresa divulgou apenas as taxas de crescimento relativo, sem informar o número absoluto de commits por trimestre.

Outro conjunto de dados, medido de forma diferente, aponta na mesma direção. Em 20 de julho de 2026, ao apresentar o Codex Code Review, o blog de desenvolvedores da OpenAI informou que o número semanal de pull requests internos havia mais que dobrado em relação ao quarto trimestre anterior. Como os critérios e períodos de medição são diferentes dos usados para o crescimento trimestral de commits, os números não podem ser somados nem convertidos entre si. Ainda assim, ambos indicam uma rápida expansão das atividades de alteração de código.

Como o Codex transfere pressão para a infraestrutura Git

À primeira vista, “a IA escreve código mais rápido” parece afetar apenas o próprio desenvolvedor. Mas a explicação da OpenAI aponta para outra dimensão: o Codex aumenta a quantidade de tarefas executadas simultaneamente em todo o sistema de engenharia. Um engenheiro pode colocar vários agentes para trabalhar ao mesmo tempo em funcionalidades independentes. Cada agente gera branches, commits e pushes, que, por sua vez, acionam uma série de leituras automatizadas.

A tabela abaixo resume essa cadeia de causa e efeito com base na descrição oficial da OpenAI.

Um cenário ilustrativo de amplificação de carga

O exemplo a seguir serve apenas para facilitar o entendimento; os números não são medições reais da OpenAI. Suponha que um push acione 6 tarefas de CI, cada uma fazendo um fetch do código. Nesse caso, 100 pushes podem gerar cerca de 600 leituras de código. Se os agentes multiplicarem o número de pushes, o volume de leituras também crescerá na mesma proporção.

O volume real de solicitações depende do cache de CI, do reaproveitamento de tarefas e da arquitetura de compilação, mas a tendência é clara: o aumento das gravações é amplificado no lado das leituras. É justamente aí que o servidor Git começa a sentir a pressão. O texto da OpenAI também destaca que um mesmo commit pode ser buscado repetidamente por várias tarefas de CI, projetos de pesquisa e ambientes de desenvolvimento.

O que deu errado no antigo sistema Git da OpenAI

A OpenAI revelou que, a partir do fim de 2025, os sistemas que sustentavam seu monorepositório passaram a ter cada vez mais dificuldade para lidar com a nova carga. Entre os sintomas estavam operações de Git Fetch e Push mais lentas, falhas de Merge e uma confiabilidade da infraestrutura que, em alguns períodos, ficou abaixo de 90%.

É importante entender o que significa “abaixo de 90%”. O número descreve a confiabilidade do sistema em determinados períodos; os critérios exatos de medição e a série temporal completa não foram divulgados. Isso não significa que “10% do código tinha defeitos” nem que “mais de 10% dos commits da OpenAI falharam”.

Do ponto de vista técnico, a arquitetura antiga tinha dois gargalos estruturais:

• Atualizações de branches exigiam coordenação global: muitos serviços Git distribuídos tradicionais precisam manter um estado consistente de todas as referências do repositório. Mesmo quando dois agentes modificam branches sem nenhuma relação entre si, eles podem acabar disputando o mesmo fluxo de coordenação.
• Pacotes de download eram calculados repetidamente: como cada cliente já possui um histórico Git diferente, o servidor muitas vezes precisa percorrer objetos, empacotá-los e compactá-los separadamente para cada cliente. Quando vários agentes leem a mesma versão, esse trabalho custoso é repetido.

Na época em que engenheiros humanos dominavam o fluxo de trabalho, esses problemas ainda eram toleráveis. Mas, quando um grande número de agentes e tarefas de CI passou a chegar ao mesmo tempo, eles se tornaram gargalos para o sistema.

Como o Pando responde à pressão que o Codex impõe ao Git

A OpenAI não abandonou o Git. O Pando continua usando o protocolo e os clientes Git padrão, e os comandos e fluxos de trabalho dos engenheiros permanecem praticamente iguais. O que mudou foi a forma como o servidor armazena dados, atualiza referências e entrega conteúdo. A tabela abaixo compara as principais diferenças entre a solução anterior e o Pando.

As duas ideias centrais do Pando

A primeira é a concorrência na escrita. O Pando deixa de manter um snapshot consistente de todo o repositório em um único momento e passa a gerenciar as versões de cada branch de forma independente. Os Pushes para branches diferentes podem ocorrer em paralelo, e só as requisições que alteram a mesma Ref precisam resolver conflitos. A contrapartida é que, ao ler várias branches de uma vez, o cliente pode ver versões de momentos diferentes. A OpenAI considera essa troca adequada para seu cenário.

A segunda é a reutilização na leitura. O Pando armazena o Packfile recebido em cada Push como dados imutáveis em um Blob Store. Quando outro cliente faz Fetch, o servidor seleciona e entrega Packfiles já existentes com base nos Commits que o cliente tem e nos que deseja receber, em vez de empacotá-los novamente. Em segundo plano, muitos Packfiles pequenos também são mesclados em conjuntos maiores, em camadas, para evitar que clientes desatualizados há muito tempo precisem baixar arquivos demais.

Os dados de produção divulgados incluem: queda de quase 80% na mediana da latência de Push; entrega de quase 1 PB de dados Git por dia; e pico de entrega de Packfiles superior a 57 TB em uma única hora. Vale lembrar que 1 PB é o volume entregue: leituras repetidas dos mesmos dados também entram na conta. Isso não significa que 1 PB de código novo seja produzido diariamente.

Vale mencionar que o próprio Pando é resultado de um desenvolvimento com participação de agentes. Segundo a OpenAI, sua arquitetura central foi projetada por um engenheiro, e várias equipes de agentes participaram da implementação. A validação contou com uma suíte de testes de compatibilidade com Git e testes de simulação determinística. A empresa, porém, não afirmou que todo o código foi escrito por IA.

Análise do impacto da programação com IA: o gargalo está deixando de ser a escrita de código

Impacto para desenvolvedores e equipes

O que realmente chama a atenção na história do Pando não é o fato de a OpenAI ter criado seu próprio backend para o Git, mas o padrão que ela revela: a programação com IA reduz o custo de gerar código, transferindo a pressão para as etapas seguintes do fluxo de engenharia. O Git foi apenas o primeiro ponto em que isso ficou evidente; revisão de código, testes e integração também estão sob pressão.

No artigo sobre o Codex Code Review, a OpenAI reconhece que cada vez mais PRs aguardam revisão. Para quem revisa, é difícil entender a tempo as restrições históricas e avaliar os riscos de compatibilidade de API. Por isso, o Codex Code Review consegue ler as regras de revisão definidas no AGENTS.md do repositório. Elas ajudam a proteger contratos de API existentes, identificar logs que possam vazar dados de clientes e evitar a quebra de integrações com serviços já existentes.

Para equipes de desenvolvimento que usam IA, isso significa fazer alguns ajustes práticos:

• Documentar as regras de revisão: registre as restrições implícitas da equipe em arquivos de regras como o AGENTS.md, para que a revisão por IA tenha uma base.
• Reservar capacidade para a CI: com a execução de agentes em paralelo, o número de jobs de CI pode crescer antes dos custos de pessoal. Avalie com antecedência o cache e as cotas de concorrência.
• Rever as métricas: não acompanhe apenas o número de commits ou PRs; observe também o tempo de entrega e a taxa de falhas nas mudanças.
• Priorizar a capacidade de validação: cobertura de testes, testes com simulações e testes de compatibilidade determinam se o código produzido pelos agentes pode ser integrado com segurança.

Exemplo mínimo de revisão de código com vários modelos de IA

Se você quiser experimentar no seu repositório um fluxo de revisão de Diff baseado em regras, pode criar um protótipo rapidamente usando uma interface compatível com a OpenAI. O exemplo abaixo lê o Diff local e pede ao modelo que faça a revisão conforme as regras:

import openai, subprocess

client = openai.OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")
diff = subprocess.run(["git", "diff", "HEAD~1"], capture_output=True, text=True).stdout

resp = client.chat.completions.create(
    model="YOUR_MODEL",  # Substitua por um modelo de programação disponível na plataforma
    messages=[{"role": "user", "content": f"请审查以下改动，重点关注 API 兼容性和日志泄露风险：\n{diff}"}],
)
print(resp.choices[0].message.content)

import subprocess
from pathlib import Path
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1",  # Uma única chave para acessar modelos de vários provedores
)

def load_rules(path: str = "AGENTS.md") -> str:
    """Lê as regras de revisão do repositório ou retorna regras padrão se o arquivo não existir"""
    p = Path(path)
    if p.exists():
        return p.read_text(encoding="utf-8")
    return "1. 不得破坏已有 API 契约\n2. 日志中不得输出客户数据\n3. 不得破坏已有服务集成"

def get_diff(base: str = "HEAD~1") -> str:
    """Obtém o Diff a ser revisado"""
    return subprocess.run(
        ["git", "diff", base], capture_output=True, text=True
    ).stdout

def review(diff: str, rules: str, model: str) -> str:
    """Chama o modelo para revisar as alterações de código conforme as regras"""
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": f"你是严格的代码审查者，请依据以下仓库规则审查：\n{rules}"},
            {"role": "user", "content": f"待审查 Diff：\n{diff}\n请逐条列出风险点和修改建议。"},
        ],
        max_tokens=1500,
    )
    return resp.choices[0].message.content

if __name__ == "__main__":
    rules, diff = load_rules(), get_diff()
    # Substitua pelos nomes dos modelos que deseja comparar e observe as diferenças entre as revisões
    for model in ["MODEL_A", "MODEL_B"]:
        print(f"===== {model} =====")
        print(review(diff, rules, model))

🚀 Dica para começar: ao criar um protótipo de AI Review, você pode obter créditos gratuitos para testes pela APIYI em apiyi.com. Com a mesma chave API, é possível acessar modelos como OpenAI, Claude e Gemini e comparar a qualidade das revisões de acordo com as regras do seu repositório.

Impacto no setor

Em sua cobertura, o The New Stack avalia que a OpenAI adotou o Agent Coding cedo e em larga escala. A pressão sobre sua infraestrutura pode antecipar problemas que outras grandes empresas e plataformas de hospedagem de código enfrentarão no futuro. Essa é uma avaliação de tendência da imprensa, não uma prova de que GitHub e GitLab já tenham enfrentado as mesmas falhas.

A comunidade de desenvolvedores também está dividida. Os otimistas acreditam que a redução do custo de programação tornará viáveis muitos projetos pequenos que antes não compensavam. Já os críticos apontam que mais commits não significam maior valor de software: se a revisão e os testes não acompanharem o ritmo, a entrega pode não ficar mais rápida. Outros comentários lembram que os problemas de escala em grandes monorepos não surgiram com a era da IA.

Entendendo os dados do Codex: cinco métricas que não devem ser confundidas

Ao discutir os resultados da programação com IA, um erro comum é misturar métricas diferentes. A tabela abaixo ajuda a entender o que cada dado pode ou não demonstrar.

O caso Pando mostra que a carga de trabalho de desenvolvimento de código da OpenAI cresceu significativamente e que a infraestrutura Git existente encontrou gargalos. Ele não demonstra que a qualidade do software ou a produtividade dos desenvolvedores cresceram na mesma proporção, nem permite estimar quantos engenheiros o Codex substituiu.

Além disso, o Harness Engineering, publicado pela OpenAI em fevereiro de 2026, é outro experimento independente: a partir de um repositório vazio, um projeto da ordem de um milhão de linhas foi concluído em cerca de cinco meses, com aproximadamente 1.500 PRs acumulados. Esses dados são de outro projeto e não têm relação com o Pando, mas também refletem uma tendência: o foco do trabalho dos engenheiros está migrando para arquitetura, cadeia de ferramentas, ciclos de feedback e aceitação de código.

💡 Sugestão: se sua equipe também está adotando um Coding Agent, comece comparando em pequena escala o desempenho de diferentes modelos na geração e revisão de código. A interface unificada da APIYI apiyi.com permite alternar rapidamente entre modelos e avaliá-los com o mesmo conjunto de testes antes de escolher o principal.

Perguntas frequentes (FAQ)

Codex e as mudanças na infraestrutura Git: principais pontos

• A métrica precisa estar correta: 2442% é o crescimento projetado no número de commits trimestrais para o 4º trimestre de 2026, não nas linhas de código.
• O crescimento acelerou bastante: a curva ficou mais íngreme após o 4º trimestre de 2025, mas já vinha crescendo desde 2024.
• A pressão vem da concorrência: o Codex aumentou o paralelismo das tarefas, e o crescimento das gravações é amplificado pelas leituras de CI.
• O sistema antigo deixou de dar conta: desde o fim de 2025, Push e Fetch ficaram mais lentos, e a confiabilidade às vezes caía abaixo de 90%.
• A solução Pando: gravações independentes por branch, reutilização de Packfiles e cache reduziram a latência mediana de Push em quase 80%.
• O gargalo mudou de lugar: revisão de código, testes, integração e entrega se tornaram os novos fatores limitantes.
• Por onde começar: use a interface unificada da APIYI em apiyi.com para criar rapidamente um protótipo de revisão com vários modelos.

Resumo

O impacto do Codex na OpenAI pode ser resumido em três pontos:

1. Escala: o número de commits trimestrais no monorepo deve crescer 2442% em relação ao 1º trimestre de 2024, e o número de PRs também está dobrando. A atividade de alteração de código aumentou significativamente.
2. Infraestrutura: agentes trabalhando em paralelo geram mais branches, operações de Push e leituras de CI. O backend Git antigo passou a apresentar problemas de desempenho e confiabilidade, e a OpenAI levou cerca de 10 semanas para criar o Pando como resposta.
3. Processo de engenharia: escrever código já não é a etapa mais lenta. A capacidade de revisar, testar e entregar determina se a programação com IA pode realmente gerar valor.

Para a maioria das equipes, em vez de perseguir o número de commits, vale mais fortalecer primeiro os processos de aceitação e revisão e depois aumentar gradualmente o paralelismo dos agentes. Se você quer validar rapidamente um fluxo de revisão com IA ou de agentes de programação, a recomendação é usar os créditos gratuitos da APIYI em apiyi.com para comparar o desempenho real de vários modelos.

📚 Referências

1. Scaling Git at OpenAI: artigo técnico oficial da OpenAI sobre o Pando (2026-11-02)
2. Link: openai.com/index/scaling-git-at-openai

3. Descrição: principal fonte dos fatos apresentados e dos dados de crescimento trimestral de commits

4. Custom Code Review rules for Codex: blog de desenvolvedores da OpenAI (2026-07-20)

5. Link: developers.openai.com/blog/custom-code-review-rules-for-codex

6. Descrição: fonte da informação sobre a duplicação semanal do número de PRs e das regras de revisão em AGENTS.md

7. Harness engineering: experimento independente da OpenAI sobre desenvolvimento com agentes (2026-02-11)

8. Link: openai.com/index/harness-engineering

9. Descrição: caso independente para entender a mudança no papel dos engenheiros, sem relação com o projeto Pando

10. OpenAI Git Fork: repositório público do cliente Git mantido pela OpenAI

11. Link: github.com/openai/git

12. Descrição: consulte as melhorias no cliente, como o packfile-uri

13. Cobertura do The New Stack: análise do Pando pela imprensa especializada (2026-11-02)

14. Link: thenewstack.io
15. Descrição: referência para a análise de tendências do setor

Autor: equipe técnica da APIYI
Troca de ideias sobre tecnologia: entre em contato conosco pela página inicial do site oficial da APIYI. Para mais materiais sobre integração de modelos, acesse a central de documentação em docs.apiyi.com

Artigos relacionados

• GPT-6.2 Astra revelado gradualmente: 5 sinais, 3 dúvidas, a bomba atômica chegou?: Retrospectiva do lançamento gradual do GPT-6.2 Astra de 31/10 a 02/11/2026: cronologia, 5 sinais, 3 pontos suspeitos, classificação das evidências dos vazamentos, ritmo dos concorrentes e lista de preparativos que os desenvolvedores já podem realizar.
• OpenAI publica dados de uso do ChatGPT cobrindo 165 tipos de atividades de trabalho: 5 principais descobertas de 7 trimestres e quase 100 países: Interprete os dados de uso do ChatGPT nas 165 categorias de atividades de trabalho divulgados pelo OpenAI Signals v3.0, esclareça que “atividade de trabalho não equivale a profissão” e analise o impacto para desenvolvedores das mudanças, como a alta do design visual e a queda da proporção de programação.
• Erro da OpenAI: modelo não encontrado? GPT-5.5 foi removido do ChatGPT em 14 de outubro: 5 etapas de diagnóstico e alternativas: Em 14 de outubro de 2026, o GPT-5.5 será totalmente descontinuado no ChatGPT, ChatGPT Work e Codex, mas a API da OpenAI não será afetada; este artigo resume as últimas novidades de 15 de outubro, explica as cinco principais causas do erro “model not found” da OpenAI, soluções para cada cenário e alternativas como GPT-5.6 Sol, Terra, Luna e GPT-6 Astra.
• 3 maneiras de iniciar o Codex CLI ignorando as permissões: codex –yolo é o equivalente ao –dangerously-skip-permissions do Claude Code: Na linha de comando do Codex, o equivalente a claude –dangerously-skip-permissions do Claude Code é codex –yolo; este artigo explica as diferenças de permissões, os casos de uso e a lista de verificação de segurança dos três modos de inicialização, além de apresentar um exemplo de configuração com a APIYI.