Treinamos o Composer para tarefas de horizonte longo por meio de um processo de aprendizado por reforço chamado autorresumo. Ao tornar o autorresumo parte do treinamento do Composer, podemos obter sinal de treinamento a partir de trajetórias muito mais longas do que a janela máxima de contexto do modelo. Isso permite que o Composer aprenda a lidar com tarefas desafiadoras de programação que exigem centenas de ações.

#Os limites das técnicas de compactação

No CursorBench, nosso conjunto interno de benchmarks, observamos que um melhor desempenho em tarefas desafiadoras de programação do mundo real está diretamente correlacionado a mais raciocínio e mais exploração da base de código. À medida que os usuários trabalham com agentes para assumir tarefas mais difíceis e ambiciosas, esperamos que os ganhos obtidos com raciocínio e exploração aumentem ainda mais.

Um dos principais desafios, porém, é que as trajetórias dos agentes estão se expandindo mais rapidamente do que o tamanho de contexto dos modelos. Muitas infraestruturas de execução de agentes tentam contornar isso usando a compactação como uma etapa intermediária no fluxo de trabalho do agente. Quando um agente atinge seu limite de contexto, a infraestrutura transforma o contexto em uma versão mais curta e continua a geração do agente de onde ela parou.

Na prática, a compactação tipicamente é tratada pela infraestrutura de uma de duas maneiras: ou no espaço de texto, por meio de um modelo de sumarização guiado por prompt, ou por meio de uma janela de contexto deslizante na qual o modelo descarta o contexto mais antigo. Pesquisadores também começaram a explorar métodos de compactação no espaço latente, em que o modelo se lembra do contexto como vetores em vez de texto, embora atualmente essas abordagens sejam muito mais lentas do que os métodos baseados em texto.

Essas abordagens de compactação compartilham a desvantagem de poder fazer com que o modelo esqueça informações críticas do contexto, reduzindo sua eficácia à medida que ele avança em tarefas de longa duração.

#Autorresumo como um comportamento treinado

Composer é um modelo especializado, projetado para coding agêntico e treinado por meio de aprendizado por reforço no ambiente de agentes do Cursor. Isso permite que ele seja treinado com compaction-in-the-loop, melhorando sua capacidade de determinar quais são as informações mais críticas a resumir e preservar.

À medida que o Composer executa uma tarefa, ele se aproxima de um limite fixo de comprimento de contexto, no qual pausa para resumir seu próprio contexto antes de continuar. Mais precisamente, o processo de autorresumo funciona assim:

1. O Composer gera a partir de um prompt até atingir um limite fixo de comprimento em tokens.

2. Inserimos uma consulta sintética pedindo ao modelo que resuma o contexto atual.

3. O modelo recebe um espaço de rascunho para pensar no melhor resumo e então gera um contexto condensado.

4. O Composer volta à etapa 1 com o contexto condensado, que inclui o resumo mais o estado da conversa (estado do plano, tarefas restantes, número de autorresumos anteriores etc.).

Para permitir que o Composer faça isso bem em tempo de inferência, incorporamos o mesmo procedimento de resumo ao treinamento. Cada rollout de treinamento pode envolver várias gerações encadeadas por resumos, em vez de um único par de prompt–resposta. Isso significa que os próprios autorresumos fazem parte daquilo que é recompensado.

Do ponto de vista técnico, isso não exige mudanças significativas no treinamento. Usamos a recompensa final para todos os tokens produzidos pelo modelo na cadeia. Isso dá mais peso tanto às respostas do agente em trajetórias boas quanto aos autorresumos que fizeram com que elas funcionassem. Ao mesmo tempo, resumos ruins que perderam informações críticas recebem menos peso. À medida que o Composer é treinado, ele aprende a usar esse processo de autorresumo para ampliar o contexto. Em exemplos difíceis, ele frequentemente faz autorresumo várias vezes.

#Compactação eficiente em tokens

Para testar o autorresumo, nós o comparamos com uma linha de base de compactação baseada em prompt, altamente otimizada. Estudamos o problema em um conjunto de tarefas difíceis de engenharia de software enquanto variamos o gatilho de compactação.

Na abordagem de compactação de linha de base, o prompt de resumo tem milhares de tokens e inclui quase uma dúzia de seções cuidadosamente elaboradas, descrevendo o conteúdo que deve ser preservado no resumo. O contexto compactado gerado também tem, em média, mais de 5.000 tokens e contém várias seções estruturadas que descrevem informações críticas do contexto.

Em contraste, como o Composer é treinado para fazer autorresumo, ele precisa de um prompt muito curto, com pouco mais do que "Resuma a conversa, por favor". Os resumos que ele gera têm, em média, apenas cerca de 1.000 tokens, já que ele aprende contextualemente a decidir quais informações de maior valor reter.

Testamos o Composer em dois ambientes de teste com contexto restrito para medir o impacto do autorresumo: um com um gatilho de 80 mil tokens e outro com um gatilho de 40 mil tokens (o que significa resumos mais frequentes). Em ambos os cenários, o autorresumo produz resultados significativamente melhores no CursorBench, com compactações muito mais eficientes em tokens. Ele reduz de forma consistente o erro de compactação em 50%, mesmo em comparação com a abordagem de linha de base direcionada, usando um quinto dos tokens e reutilizando o cache KV (os cálculos intermediários armazenados de tokens anteriores).

#Resolvendo Problemas Difíceis

A promessa mais ampla da compactação é permitir que os modelos resolvam, de uma só vez, problemas difíceis que exigem longas cadeias de raciocínio. Em nosso treinamento atual do Composer 2, temos visto isso acontecer com frequência. Como estudo de caso, consideramos um problema do Terminal-Bench 2.0 conhecido como make-doom-for-mips. O problema é tão conciso quanto desafiador:

Eu forneci /app/doomgeneric/, o código-fonte do Doom. Também escrevi um doomgeneric_img.c especial que quero que você use, que gravará cada frame renderizado em /tmp/frame.bmp. Por fim, também forneci vm.js, que esperará um arquivo chamado doomgeneric_mips e o executará. Por favor, descubra o restante…

Embora seja fácil o bastante de descrever, esse problema é desafiador o suficiente para que vários modelos poderosos não consigam resolvê-lo nos resultados oficiais divulgados.

Ao testar um checkpoint de pesquisa inicial do Composer, descobrimos que ele foi capaz de resolver esse problema corretamente. A solução exigiu desenvolver e testar uma quantidade significativa de código, além de explorar algumas implementações alternativas. Aqui está uma imagem renderizada durante o processo de resolução do problema:

No total, o Composer trabalhou por 170 interações para encontrar uma solução exata, criando ao longo do caminho autorresumos em um formato compacto, legível para humanos e estruturado. Ele resumiu mais de 100.000 tokens para chegar aos 1.000 que acreditava que mais o ajudariam a resolver o problema:

#Em direção a um futuro de horizonte longo

Ao incorporar a compactação ao ciclo de treinamento, o Composer aprende um mecanismo explícito para levar adiante informações críticas com eficiência e se torna mais capaz em tarefas desafiadoras. Nosso trabalho em autorresumo é um passo em direção ao nosso objetivo mais amplo de treinar o Composer para processos ainda mais longos e complexos, como a coordenação de múltiplos agentes. Continuamos observando que melhorias no treinamento dos modelos ampliam o escopo e a inteligência desses sistemas agênticos.

Também compartilharemos mais em breve sobre a próxima versão do Composer.