🤖 AI

CoRe-Code: Collaborative Reinforcement Learning for Code Generation

CoRe-Code é uma estrutura de aprendizado por reforço colaborativa que emprega agentes Planejador e Codificador especializados por função, aprimorados por Otimização de Política Relativa em Grupo (GRPO), para superar as limitações da decodificação autoregressiva e melhorar a precisão e a eficiência da geração de código em tarefas complexas.

Autores originais: Zhihao Dou, Qinjian Zhao, Zhongwei Wan, Xiaoyu Xia, Sumon Biswas

Publicado 2026-05-26

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Zhihao Dou, Qinjian Zhao, Zhongwei Wan, Xiaoyu Xia, Sumon Biswas

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 que você está tentando construir um móvel complexo, como uma estante de livros, mas não tem um projeto. Você simplesmente começa a martelar pregos e colar madeira, esperando que pareça certo conforme avança. É assim que a maioria dos geradores de código de IA atuais funciona. Eles escrevem código palavra por palavra (ou "token por token"), o que frequentemente leva a uma estrutura que parece aceitável à primeira vista, mas desmorona quando você tenta usá-la. Pode ser localmente coerente (as palavras fazem sentido), mas globalmente quebrada (a estante não sustentará livros).

O artigo apresenta CoRe-Code, uma nova maneira de ensinar a IA a escrever código, atuando como uma equipe de construção com dois papéis distintos: um Planejador e um Codificador.

O Problema: A Abordagem "Martelo Primeiro"

Os modelos de IA atuais são como aprendizes entusiastas que pegam um martelo imediatamente. Eles podem construir uma perna de mesa com aparência sólida, mas depois percebem que esqueceram de fazer o tampo. Ou podem construir uma mesa que funciona, mas que leva 100 anos para ser montada porque não planejaram as etapas de forma eficiente.

A Solução: O Arquiteto e o Construtor

O CoRe-Code divide o trabalho em dois agentes especializados:

O Planejador (O Arquiteto): Antes que qualquer código seja escrito, este agente desenha um projeto detalhado. Ele não escreve o código em si; escreve uma receita passo a passo chamada "Pensamento Algorítmico". Essa receita divide o problema em partes claras:
- Entradas/Saídas: Com o que estamos começando e com o que precisamos terminar?
- Passos Lineares: O caminho reto do início ao fim.
- Condições: "Se isso acontecer, faça aquilo."
- Laços: "Repita esta ação até termos terminado."
O Codificador (O Construtor): Este agente pega o projeto do Arquiteto e realmente constrói o móvel (escreve o código). Sua única função é seguir o plano fiel e eficientemente.

O Segredo: Aprendizado Fazendo (Aprendizado por Reforço)

A verdadeira magia do CoRe-Code não é apenas ter dois agentes; é como eles aprendem a trabalhar juntos.

Imagine um campo de treinamento onde o Arquiteto e o Construtor praticam juntos.

O Arquiteto desenha um plano.
O Construtor tenta construí-lo.
O Teste: Eles colocam o produto final em um "laboratório de testes" (executando o código contra problemas do mundo real).
O Feedback:
- Se o código funcionar perfeitamente e for rápido, ambos recebem uma pontuação alta.
- Se o código falhar, o sistema analisa o porquê. O Construtor estragou as instruções? Ou o Arquiteto deu um projeto ruim?

O artigo usa um método especial de treinamento chamado GRPO (Otimização de Política Relativa em Grupo). Pense nisso como um treinador que compara diferentes equipes de pares Arquiteto/Construtor. Se o plano da Equipe A leva a uma mesa sólida e o plano da Equipe B leva a uma bagunça instável, o treinador diz à Equipe A: "Bom trabalho, continue fazendo isso", e diz à Equipe B: "Seu projeto foi o problema; tente uma abordagem diferente".

Crucialmente, o Arquiteto aprende indiretamente. Ele não recebe uma pontuação pelo desenho em si; recebe uma pontuação baseada em quão bem o Construtor pôde executar esse desenho. Isso força o Arquiteto a escrever planos que são realmente úteis, não apenas bonitos.

O Que Eles Encontraram

Os pesquisadores testaram essa equipe "Planejador-Construtor" em vários desafios de codificação difíceis (como ordenar listas de números ou resolver quebra-cabeças matemáticos complexos).

Maior Precisão: A equipe CoRe-Code resolveu mais problemas corretamente do que outros métodos de IA, incluindo aqueles que usam "Cadeia de Pensamento" (falando consigo mesma) ou outros sistemas multiagente.
Eficiência: O código que escreveram não foi apenas correto; foi mais rápido e usou menos memória do computador.
Flexibilidade: A equipe mostrou que esse estilo de aprendizado "Planejador-Construtor" não serve apenas para um tipo de tarefa. Eles aplicaram com sucesso a outros times de IA que incluem "Agentes de Recuperação" (que encontram informações) e "Agentes de Depuração" (que corrigem erros), provando que o método é uma ferramenta versátil para qualquer equipe de construção de IA.

Em Resumo

O CoRe-Code é como atualizar uma IA de um trabalhador solitário que adivinha os passos para uma equipe profissional de construção com um Arquiteto e um Construtor dedicados que treinam juntos. Ao recompensá-los com base no resultado final e funcional, eles aprendem a se comunicar melhor, planejar com mais inteligência e construir código que realmente funciona.

Resumo Técnico: CoRe-Code

Declaração do Problema

Os Modelos de Linguagem de Grande Escala (LLMs) demonstraram capacidades robustas na geração de código, mas frequentemente dependem de decodificação autoregressiva sem planejamento global. Esse mecanismo de geração sequencial em nível de token frequentemente produz saídas que são localmente coerentes, mas globalmente subótimas, levando a falhas em casos de teste ou complexidade algorítmica ineficiente. Embora abordagens recentes como Cadeia de Pensamento (CoT) e Sistemas Multiagente (MAS) tentem introduzir planejamento, elas frequentemente sofrem com especialização de papel limitada e coordenação deficiente. As estruturas existentes de MAS, onde agentes auxiliares (por exemplo, planejadores, recuperadores) fornecem orientação a um Codificador central, frequentemente resultam apenas em ganhos marginais de desempenho ou mesmo em ganhos negativos de "colaboração", indicando que os agentes auxiliares falham em apoiar efetivamente o Codificador.

Metodologia

Os autores propõem o CoRe-Code (Código de Reforço Colaborativo), uma estrutura projetada para aprimorar a coordenação interagentes e a especialização de papéis por meio de uma abordagem de aprendizado por reforço consciente da colaboração. A estrutura opera sob um paradigma Planejador–Codificador e utiliza Otimização de Política Relativa de Grupo (GRPO) com recompensas verificáveis.

1. Pensamento Algorítmico

Para estruturar o processo de planejamento, a estrutura introduz o Pensamento Algorítmico, uma representação estruturada para a saída do agente Planejador. Inspirado em trabalhos anteriores, essa representação decompõe o raciocínio em quatro componentes principais:

Definição de Entrada-Saída: Clarifica objetivos funcionais.
Progressão Linear: Esboça etapas computacionais sequenciais.
Lógica Condicional: Especifica decisões de ramificação.
Iteração: Descreve computações repetidas.
Essa estrutura alinha o raciocínio do Planejador com a semântica de programação, fornecendo orientação mais clara para o Codificador.

2. Estrutura Colaborativa GRPO

O CoRe-Code emprega um processo de aprendizado por reforço em duas etapas para otimizar conjuntamente os agentes Planejador e Codificador, utilizando resultados de execução de código a jusante como recompensas verificáveis, em vez de recompensas proxy não verificáveis.

RL para Especialização do Planejador:
- O Planejador gera $N$ pensamentos algorítmicos distintos.
- O Codificador (congelado durante esta etapa) traduz esses pensamentos em código.
- Recompensas: A qualidade de um pensamento é avaliada com base na precisão (taxa de aprovação de casos de teste) e complexidade de tempo do código gerado. Um esquema de ponderação baseado em sigmóide atribui recompensas mais altas a pensamentos que levam a código que passa em mais testes e possui menor complexidade.
- O Planejador é atualizado para maximizar essas recompensas, aprendendo a gerar planos que melhor suportam a síntese de código a jusante.
RL para Especialização do Codificador:
- O Planejador especializado gera um pensamento algorítmico de alta qualidade.
- O Codificador gera múltiplos trechos de código com base nesse pensamento.
- Recompensas: O Codificador é recompensado pela precisão (passar em casos de teste) e eficiência de espaço. Uma recompensa de eficiência de espaço é atribuída se o código passar em todos os testes, incentivando implementações que se aproximam de um uso de memória alvo ( $O_{target}$ ) derivado do trecho de melhor desempenho.
- O Codificador é atualizado para se alinhar melhor e executar fielmente as instruções do Planejador.

3. Ganho de Colaboração (CG)

O artigo define Ganho de Colaboração (CG) como uma métrica para quantificar a contribuição efetiva de agentes auxiliares para o desempenho do Codificador. O CoRe-Code visa maximizar esse ganho, garantindo que a saída do Planejador melhore diretamente a taxa de sucesso do Codificador.

Contribuições Principais

Estrutura CoRe-Code: Uma estrutura inovadora de RL consciente da colaboração que otimiza agentes especializados em papéis (Planejador e Codificador) usando feedback de execução verificável.
Pensamento Algorítmico: Uma representação estruturada de planejamento que decompõe o raciocínio algorítmico em definições de entrada-saída, progressão linear, lógica condicional e iteração, melhorando a interpretabilidade e executabilidade dos planos.
GRPO Colaborativo: Uma extensão do GRPO que otimiza conjuntamente o Planejador e o Codificador. Utiliza a execução de código a jusante (precisão e complexidade) como recompensas verificáveis para treinar o Planejador, resolvendo o desafio de otimizar planos intermediários que são difíceis de verificar isoladamente.
Generalizabilidade: Demonstração de que a estrutura se estende além do paradigma Planejador–Codificador para otimizar outros agentes em sistemas multiagentes, como agentes de Recuperação e Depuração dentro da estrutura MapCoder.

Resultados Experimentais

Os autores avaliaram o CoRe-Code em quatro benchmarks (LiveBench, MBPP, CodeContests, CodeForces) usando três modelos base (Qwen2.5-7B-Coder-Instruct, Qwen2.5-14B-Coder-Instruct e Qwen3-4B).

Desempenho: O CoRe-Code superou consistentemente as linhas de base existentes baseadas em RL (GRPO, Focused-DPO, CURE, CodeRL+) e sistemas multiagentes (SCoT, Reflexion, MapCoder) em todas as métricas, incluindo Pass@1, Pass@5 e Taxa Média de Aprovação (APR).
Eficiência: A estrutura alcançou maior eficiência em termos de tempo de execução e uso de memória em comparação com as linhas de base.
Estudos de Ablação: A remoção de qualquer um dos componentes RL do Planejador ou RL do Codificador resultou em degradação de desempenho, confirmando que a otimização conjunta fornece benefícios complementares.
Extensão: Quando aplicado ao MapCoder, o reforço independente dos agentes de Recuperação ou Depuração com CoRe-Code melhorou o desempenho sobre a linha de base original do MapCoder, particularmente em tarefas complexas de programação competitiva.
Dinâmicas de Treinamento: A análise mostrou uma tendência ascendente consistente no Ganho de Colaboração durante o treinamento, indicando melhoria na coordenação entre os agentes.

Significado e Alegações

O artigo alega que o CoRe-Code representa uma das primeiras estruturas multiagentes baseadas em RL guiadas por verificador para geração de código. Seu significado reside em:

Abordar a "lacuna de coordenação" em sistemas multiagentes onde agentes auxiliares frequentemente falham em fornecer suporte substancial ao Codificador.
Demonstrar que o uso de resultados de execução verificáveis (em vez de recompensas proxy) permite o treinamento eficaz de agentes de planejamento.
Mostrar que a colaboração especializada em papéis, quando otimizada via RL, leva a uma geração de código mais precisa, eficiente e mantível em vários níveis de dificuldade.
Destacar a flexibilidade, já que a abordagem não se limita ao paradigma Planejador–Codificador, mas pode ser adaptada para otimizar diversos agentes em fluxos de trabalho multiagentes mais amplos.

Os autores observam limitações, incluindo a dependência de modelos específicos de código aberto e um formato de interação fixo, sugerindo que trabalhos futuros poderiam explorar estilos de comunicação de agentes mais diversos e famílias de modelos.