🤖 machine learning

CORVUS: Context Optimization and Reduction Via Underlying Synchronization for LLM Coding Agents

O CORVUS introduz uma nova arquitetura de trajetória para agentes de codificação de LLM que desacopla as ações de leitura de arquivos de suas observações ao manter um registro sincronizado dos conteúdos atuais dos arquivos, eliminando, assim, instantâneos obsoletos e releituras redundantes para reduzir significativamente o uso de tokens e os ciclos de raciocínio, mantendo o desempenho.

Autores originais: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

Publicado 2026-07-28

📖 7 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

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 mundo onde você tem um assistente robô superinteligente que pode escrever código de computador, corrigir bugs e construir programas inteiros de software apenas conversando com você. Isso não é ficção científica; é a realidade dos "agentes de codificação LLM". Estes são modelos de inteligência artificial que atuam como desenvolvedores juniores: eles pensam sobre um problema, analisam arquivos, fazem alterações e verificam seu próprio trabalho. Mas aqui está o problema: esses robôs têm um problema de memória de curto prazo. Para lembrar o que fizeram, eles mantêm um diário contínuo de cada pensamento, ação e resultado. Quanto mais complexo o trabalho, mais longo esse diário se torna. Eventualmente, o diário torna-se tão massivo que o robô fica confuso, esquece os detalhes mais importantes e começa a cometer erros bobos porque está tentando ler um livro de 500 páginas apenas para lembrar o que fez cinco minutos atrás. Esse fenômeno, onde o excesso de informação torna a IA mais burra, é chamado de "context rot" (deterioração de contexto).

Apresentamos o CORVUS, um novo sistema inteligente projetado para consertar essa bagunça de memória. Em vez de deixar o diário do robô crescer descontroladamente com notas antigas e desatualizadas, o CORVUS atua como uma biblioteca mágica e viva. Ele percebe que o código muda o tempo todo. Se o robô lê um arquivo, depois o edita, depois o lê novamente, a nota antiga no diário é um lixo inútil. O CORVUS impede o robô de escrever o conteúdo do arquivo todas as vezes. Em vez disso, ele mantém uma "lista sincronizada" dos arquivos de que o robô precisa. Antes de o robô tomar uma nova decisão, o CORVUS verifica silenciosamente os arquivos reais do computador, pega a versão mais recente e a entrega ao robô. Dessa forma, o robô sempre tem a informação mais fresca e limpa, sem um diário inchado com páginas duplicadas e obsoletas. O resultado? O robô trabalha mais rápido, custa menos para rodar e comete menos erros, mantendo sua memória leve e focada.

O Problema: A Armadilha da "Foto Estática" (Stale Snapshot)

Para entender por que o CORVUS é tão importante, primeiro precisamos entender como esses agentes de codificação geralmente funcionam. Imagine que você está tentando consertar uma torneira com vazamento, mas está fazendo isso usando uma venda nos olhos e só consegue ver o quarto através de uma série de fotos que tirou anteriormente.

No método tradicional, toda vez que o agente (nosso robô) olha para um arquivo, ele tira uma "foto" (snapshot) desse arquivo e a cola em seu registro de histórico. Se o arquivo mudar mais tarde — porque o robô o editou ou porque um desenvolvedor humano fez um ajuste — aquela foto antiga no registro permanece exatamente a mesma. Ela se torna obsoleta (stale).

Os autores do artigo descobriram que isso cria dois grandes problemas:

Leituras Duplicadas: Como a foto antiga está enterrada profundamente em um histórico longo, o robô frequentemente esquece que já olhou para o arquivo. Ele lê o arquivo novamente, tira outra foto e a cola no registro. Isso é como ler a mesma página de um livro cinco vezes porque você perdeu o lugar. Em seus testes, eles descobriram que, em 26% das vezes, o robô estava relendo arquivos que já havia visto.
Erros de Contexto Obsoleto: Pior ainda, o robô pode tentar editar um arquivo com base em uma foto antiga. Imagine que o robô vê uma linha de código que diz "Linha 10: Acender a luz", mas no mundo real, essa linha foi deletada cinco minutos atrás. O robô tenta editar a "Linha 10", falha, fica confuso e precisa gastar tempo e energia extras para entender o que deu errado.

A antiga forma de resolver isso era "reativa". É como esperar até que sua mochila esteja tão cheia de pedras que você não consiga levantá-la e, então, tentar jogar algumas pedras fora. O artigo argumenta que isso é tarde demais. A verdadeira solução é impedir que as pedras entrem na mochila em primeiro lugar.

A Solução: A "Sincronização Viva" (Living Sync)

Os autores propõem o CORVUS (Context Optimization and Reduction Via Underlying Synchronization). Pense no CORVUS não como um diário, mas como um feed ao vivo.

Em vez de colar o conteúdo de um arquivo no registro de histórico, o CORVUS usa uma ferramenta especial chamada sync_file. Quando o robô diz: "Preciso olhar o speech_recognition.py", o CORVUS não copia o texto para o log. Em vez disso, ele coloca uma nota minúscula e leve no log que diz: "Sync: speech_recognition.py."

Nos bastidores, o CORVUS mantém um Conjunto de Arquivos Sincronizados (Synced File Set). Este é uma lista especial de arquivos nos quais o robô está trabalhando no momento. Antes de o robô tomar qualquer nova decisão (em cada ciclo de raciocínio), o CORVUS realiza uma rápida "Sincronização de Contexto" (Context Sync). Ele vai até o computador real, pega a versão atual e mais recente de cada arquivo dessa lista e a injeta no prompt do robô.

Isso muda tudo:

Sem Duplicatas: O robô nunca vê duas versões do mesmo arquivo. Ele vê apenas a versão única e atual.
Sem Dados Obsoletos: Se um arquivo mudar, na próxima vez que o robô pensar, ele receberá a nova versão automaticamente. Ele nunca tentará editar um código que não existe mais.
Mais Leve: O registro de histórico permanece pequeno porque contém apenas os pensamentos e ações do robô, não blocos massivos de texto de arquivos.

O Que Eles Descobriram: Mais Rápido, Mais Barato, Mais Inteligente

Os pesquisadores testaram o CORVUS em dois desafios de codificação difíceis: SWE-POLYBENCH_VERIFIED (que inclui tarefas em Java, JavaScript e TypeScript) e SWE-BENCH PRO (que apresenta problemas complexos de nível empresarial). Eles realizaram esses testes em quatro modelos de IA poderosos, incluindo o CLAUDE SONNET 4 e o QWEN3-CODER-480B.

Os resultados foram impressionantes, mostrando que manter o contexto atualizado torna a IA significativamente mais eficiente:

Menos Leitura Desperdiçada: O CORVUS reduziu as leituras duplicadas de arquivos entre 22% e 86%. O robô parou de perder tempo relendo arquivos que já conhecia.
Menos Etapas: Como o robô não estava ficando confuso com dados antigos, ele terminou as tarefas mais rápido. O número de ciclos de raciocínio (etapas) caiu de 15% a 37%. Por exemplo, em um modelo, as etapas caíram de uma média de 45,03 para 28,22.
Prompts Mais Curtos: O "prompt" final (a mensagem enviada à IA para concluir o trabalho) ficou de 15% a 32% mais curto.
Economia de Dinheiro: Como o custo da IA é baseado em quanto texto ela processa, essas economias se acumularam. Em algumas tarefas, o custo caiu até 50,28%. Por exemplo, uma tarefa que custava $5,27 caiu para $2,62.
Velocidade: Todo o processo terminou até 40% mais rápido em termos de tempo total.

Crucialmente, o artigo observa que o robô não ficou "mais burro" por ter menos texto para ler. A taxa de sucesso (a frequência com que ele corrigiu o bug corretamente) permaneceu comparável ao método antigo e, em alguns casos, até melhorou ligeiramente.

A Visão Geral

Os autores também verificaram se o CORVUS funciona com outros métodos que tentam limpar históricos bagunçados. Eles descobriram que o CORVUS e essas ferramentas de limpeza "reativas" são melhores amigos. O CORVUS impede que a bagunça aconteça na origem (upstream), enquanto as outras ferramentas limpam o que resta (downstream). Quando usados juntos, eles economizam ainda mais tokens e dinheiro.

Em resumo, o CORVUS sugere que, para os agentes de codificação de IA serem verdadeiramente eficientes, eles não devem apenas ser bons em lembrar o passado; eles precisam ser bons em permanecer conectados ao presente. Ao desacoplar a ação de "ler um arquivo" do "conteúdo do arquivo" e, em vez disso, manter uma sincronização ao vivo com a base de código, podemos construir agentes que são mais rápidos, mais baratos e menos propensos à confusão da "deterioração de contexto". O artigo não afirma que isso resolve todos os problemas da IA, mas mostra que uma mudança estrutural simples — trocar um diário estático por um feed ao vivo — pode fazer uma enorme diferença em como esses assistentes digitais trabalham.

Resumo Técnico: CORVUS

Problema: Decomposição de Contexto e Trajetórias de Apenas Anexo

Agentes de codificação baseados em Grandes Modelos de Linguagem (LLMs) operam por meio de um ciclo iterativo de Pensamento–Ação–Resultado, mantendo uma "trajetória" (histórico de interação) como memória de trabalho. Os agentes convencionais utilizam uma arquitetura de trajetória de apenas anexo, onde as ações de leitura de arquivos estão estritamente acopladas às suas observações. Quando um agente lê um arquivo, um snapshot de um ponto no tempo do conteúdo desse arquivo é permanentemente anexado ao histórico cronológico.

Esta arquitetura cria duas ineficiências primárias, particularmente em tarefas de engenharia de software de longo horizonte:

Leituras de Arquivos Duplicadas: À medida que a trajetória cresce, os conteúdos dos arquivos tornam-se enterrados no contexto ("fenômeno perdido no meio"). Os agentes frequentemente releem arquivos para recuperar informações, anexando snapshots redundantes de arquivos completos ao histórico. Uma análise empírica mostrou que 26% das operações de leitura de arquivo em agentes de baseline eram duplicatas.
Erros de Contexto Obsoleto: Como os snapshots são imutáveis, eles não refletem edições subsequentes feitas pelo agente ou modificações humanas simultâneas. Agentes podem tentar editar código com base em números de linhas ou nomes de variáveis desatualizados, levando a falhas nas edições. A recuperação exige ciclos de diagnóstico adicionais e novas leituras de arquivos, exacerbando o inchaço da trajetória.

Esses problemas contribuem para a decomposição de contexto (context rot), onde o aumento do comprimento do prompt degrada a precisão do modelo e a confiabilidade do raciocínio, enquanto simultaneamente aumenta os custos de tokens e a latência de inferência. Os métodos existentes de gerenciamento de contexto são amplamente reativos, comprimindo ou podando o contexto apenas após ele ter se acumulado. Eles não previnem a introdução de conteúdo desnecessário ou obsoleto na origem.

Metodologia: Arquitetura CORVUS

O artigo propõe o CORVUS (Context Optimization and Reduction Via Underlying Synchronization), uma arquitetura de trajetória proativa que desacopla as ações de leitura de arquivos de suas observações. Em vez de armazenar snapshots fixos, o CORVUS mantém um registro sincronizado de arquivos relevantes.

Mecanismos Principais

Conjunto de Arquivos Sincronizados ( $S_t$ ): O CORVUS introduz um registro dinâmico de arquivos relevantes para a tarefa atual. Quando um agente precisa interagir com um arquivo, ele invoca uma nova ferramenta, sync_file(fj), em vez de read_file(fj).
- A ferramenta sync_file registra o arquivo no conjunto $S_t$ , mas anexa apenas um marcador leve (ex: "sync: ./path/to/file") à trajetória histórica, evitando a inclusão imediata do conteúdo do arquivo.
Fase de Sincronização de Contexto: Antes de cada ciclo de raciocínio, uma etapa de sincronização atualiza o contexto. O sistema busca os conteúdos atuais de todos os arquivos no conjunto sincronizado a partir do repositório.
Composição de Prompt: O prompt para cada etapa de raciocínio é construído como:
$P_t = M_{sys} \oplus T_{schema} \oplus H_{t-1} \oplus C_t$
Onde $C_t$ é o Contexto Sincronizado, contendo no máximo uma versão atual de cada arquivo registrado. Isso garante que o agente raciocine sobre o estado mais recente do código sem carregar snapshots históricos potencialmente obsoletos de arquivos no histórico de mensagens.

Esta mudança estrutural garante que a trajetória permaneça sincronizada com o estado real do repositório por construção, eliminando cópias redundantes e impedindo que o agente raciocine sobre informações desatualizadas.

Principais Contribuições

O artigo apresenta três contribuições primárias:

Identificação de Ineficiência Estrutural: Os autores identificam empiricamente que a arquitetura padrão de trajetória de apenas anexo faz com que conteúdos de arquivos mutáveis sejam tratados como entradas de histórico imutáveis, levando ao acúmulo de snapshots duplicados e obsoletos.
Arquitetura Proativa (CORVUS): Eles propõem o CORVUS, que substitui as leituras de arquivos inline por um mecanismo de sync_file e uma atualização de contexto pré-ciclo. Isso garante que o prompt contenha apenas a versão atual dos arquivos relevantes, prevenindo o inchaço da trajetória desde a origem.
Avaliação Abrangente: O sistema foi implementado no framework STRANDS AGENTS e avaliado em quatro LLMs (três proprietários: Claude Sonnet 3.7, 4, 4.5; um de código aberto: Qwen3-Coder-480B) em dois benchmarks: SWE-POLYBENCH_VERIFIED e SWE-BENCH PRO.

Resultados

A avaliação em 573 instâncias demonstrou que o CORVUS melhora significativamente a eficiência da trajetória enquanto mantém as taxas de sucesso das tarefas:

Redução de Redundância: Leituras de arquivos duplicadas foram reduzidas em 22–86% em todos os modelos.
Menos Ciclos de Raciocínio: O número de ciclos de raciocínio necessários para completar tarefas diminuiu em 9–37%, com a maior redução (37,33%) observada no Claude Sonnet 4.5 para o SWE-POLYBENCH_VERIFIED.
Prompts Mais Curtos: Os prompts de requisição finais foram encurtados em 15–32%, reduzindo o uso da janela de contexto máxima.
Economia de Tokens e Custos: Os tokens de entrada médios por tarefa foram reduzidos em 9–50%. Os custos totais de tokens foram reduzidos em até 51% (ex: de \ $5,27 para \$ 2,62 por instância para o Claude Sonnet 4.5 no SWE-POLYBENCH_VERIFIED).
Eficiência de Tempo de Execução: A latência de ponta a ponta foi reduzida em até 40%. O overhead de sincronização (leituras de arquivos locais) foi insignificante comparado às economias provenientes de menos ciclos de inferência de LLM.
Sucesso da Tarefa: As taxas de Pass@1 permaneceram comparáveis aos agentes de baseline, com pequenas melhorias observadas em três dos quatro modelos, indicando que os ganhos de eficiência não comprometeram a correção.

Compatibilidade: O artigo demonstra ainda que o CORVUS é complementar aos métodos reativos de gerenciamento de contexto (ex: janelas deslizantes, sumarização). Combinar o CORVUS com estratégias reativas produz reduções adicionais de tokens e custos, sugerindo que uma abordagem híbrida é ideal.

Significância e Alegações

O artigo alega que a sincronização proativa entre o código e a trajetória é uma otimização crítica, porém anteriormente negligenciada, para agentes de codificação de longo horizonte. Ao abordar a causa raiz da decomposição de contexto — o acoplamento de estados de arquivos mutáveis com entradas de histórico imutáveis — o CORVUS permite fluxos de trabalho de agentes mais eficientes e confiáveis.

Os autores enfatizam que sua abordagem é distinta da compressão reativa; ela evita o acúmulo de dados obsoletos em vez de limpá-los posteriormente. Os resultados sugerem que manter uma visão sincronizada do repositório permite que os agentes operem com trajetórias mais leves, reduzindo custos e latência, preservando a capacidade de resolver tarefas complexas de engenharia de software. O artigo conclui que essa mudança arquitetônica é essencial para escalar agentes de codificação de LLM para fluxos de trabalho de desenvolvimento de nível empresarial de vários dias.