RLM 2027 · Capítulo 17 de 24 · 13 min
Treinar um modelo pequeno para decidir quando delegar
A receita que ensinou um modelo de 8 bilhões de parâmetros a operar o REPL e a conta que diz se vale repeti-la.
Este capítulo faz parte do curso gratuito RLM 2027. Para marcar como concluído e salvar o progresso, abra este capítulo na página do curso.
Com a execução isolada e os erros contidos antes de subirem pela árvore, o protótipo da Veredas ficou seguro o bastante para rodar todo dia. Sobra uma dependência que nenhum ajuste de código remove: o modelo raiz precisa ser grande para escrever bom código no REPL, escolher o que ler e saber quando delegar. Todo o ganho medido até aqui veio de modelos que ninguém treinou para esse papel.
Essa dependência pesa no custo e no controle. Um modelo de fronteira cobra caro pelo token de saída e muda de versão quando o fornecedor decide. Um modelo pequeno treinado para operar recursivamente rodaria em servidor próprio, com custo previsível e sem mandar o acervo para fora da empresa. Para chegar lá, porém, é preciso ter dados que a maioria das equipes não tem, e o primeiro resultado publicado é de escala pequena.
Ao terminar, você sabe como o primeiro modelo treinado para o papel de raiz foi feito e quanto cada etapa consumiu em tarefas, trajetórias e horas de GPU. Sabe também onde o aprendizado por reforço entra e qual volume de dados próprios justificaria repetir a receita.
Por que treinar o raiz muda o que um modelo pequeno consegue fazer
Zhang, Kraska e Khattab formularam a ideia no próprio artigo. Na versão de janeiro de 2026, os autores acrescentaram o RLM-Qwen3-8B, que chamam de primeiro RLM nativo: um Qwen3-8B pós-treinado para trabalhar dentro do REPL. O Qwen3-8B tem janela de 32 mil tokens e, usado sem treino como raiz, tropeça no formato e no código. Era esse o problema que queriam resolver: o modelo pequeno entende o texto e não sabe operar o andaime em volta dele.
Uma aposta organiza a receita inteira. Ser uma boa subchamada se parece com ser um bom modelo de raciocínio geral, e os modelos gerais já são treinados para isso. Então bastaria ensinar o raiz a manipular o REPL e a decidir quando delegar. Os autores usam essa aposta como receita e não a testam em separado; o resultado apoia a hipótese sem fechá-la.
Destilação: treinar um modelo menor para imitar as saídas de um maior, como um estagiário que aprende copiando os rascunhos do sênior. A receita começa por aí. Um RLM com o Qwen3-Coder-480B-A35B no raiz e o próprio Qwen3-8B nas subchamadas resolveu 750 tarefas em inglês do LongBench Pro e gerou 2.250 trajetórias candidatas, três por tarefa.
Trajetória é o registro completo de uma execução: cada código escrito, cada saída do REPL e a resposta final. Das 2.250, os autores descartaram as de nota zero e as de um turno só, que não ensinam a operar o laço. Sobraram 1.072. Cada turno do raiz virou um exemplo de ajuste fino supervisionado (SFT, treinar o modelo em pares de entrada e saída desejada), filtrado a cerca de 100 mil caracteres. O artigo chama o método de rejection fine-tuning: gerar muito, rejeitar o que falhou e treinar no que sobrou.
Antes do treino, uma correção feita por programa consertou erros de formato nas trajetórias aprovadas: 16% dos turnos usavam FINAL do jeito errado e 13% faziam o mesmo com FINAL_VAR. Sem esse conserto, o modelo aprenderia o erro junto com o acerto. O treino rodou no prime-rl, a biblioteca de treino da Prime Intellect, com lote de 64, 300 passos e 48 horas de H100, a placa de GPU de data center usada nesse tipo de trabalho.
- Etapa 1 de 5: 750 tarefas do LongBench Pro
Em inglês, com resposta que dá para conferir
- Etapa 2 de 5: 2.250 trajetórias candidatas
Qwen3-Coder-480B no raiz, Qwen3-8B nas subchamadas
- Etapa 3 de 5: 1.072 trajetórias aprovadas
Fora as de nota zero e as de um turno só
- Etapa 4 de 5: Correção de formato
16% dos turnos com FINAL errado, 13% com FINAL_VAR errado
- Etapa 5 de 5: SFT turno a turno
prime-rl, lote de 64, 300 passos, 48 horas de H100
Esse ganho vale para esse modelo e esses benchmarks. Na versão de maio de 2026 do artigo, o RLM-Qwen3-8B supera o Qwen3-8B por uma mediana de 28%, e, segundo Zhang, Kraska e Khattab, ele se aproxima da qualidade do GPT-5 sem andaime em três tarefas de contexto longo. A versão de janeiro chamava o mesmo número de média; a de maio corrigiu para mediana. A tabela com os valores está na versão de janeiro, porque a de maio mostra esses resultados só em gráfico.
Qwen3-8B sem andaime, como raiz sem treino e treinado para o papel
| Método | CodeQA | BrowseComp+ (1K) | OOLONG | OOLONG-Pairs |
|---|---|---|---|---|
| Qwen3-8B base | 4,0* (US$ 0,01) | 0,0* | 0,0* | 0,1 (US$ 0,01) |
| RLM(Qwen3-8B), sem treino | 26,0 (US$ 0,04) | 2,0 (US$ 0,03) | 24,0 (US$ 0,19) | 4,3 (US$ 0,05) |
| RLM-Qwen3-8B, treinado | 32,0 (US$ 0,02) | 14,0 (US$ 0,01) | 32,0 (US$ 0,04) | 5,2 (US$ 0,02) |
Acurácia em %, exceto OOLONG-Pairs, que usa F1. Asterisco: o modelo bateu no limite de contexto. Entre parênteses, custo médio por consulta.
Fonte: Zhang, Kraska e Khattab, Recursive Language Models, arXiv 2512.24601, versão 2 (janeiro de 2026)
Três leituras saem da tabela. O treino rende mais onde o modelo sem treino quase não operava: no BrowseComp+ com mil documentos, o acerto vai de 2,0 para 14,0. Com ele, o custo também cai, porque o modelo treinado erra menos o formato e desperdiça menos chamadas: no OOLONG, de US$ 0,19 para US$ 0,04 por consulta. Nas medições dos autores, o modelo treinado roda mais de três vezes mais rápido que o Qwen3-8B usado como raiz sem treino.
Resta a terceira leitura, o teto, e é nela que mora a armadilha comum: ler os 28% como ganho sobre modelos grandes. O número compara o modelo treinado com ele mesmo sem treino. Nos 32,0 do OOLONG, o RLM-Qwen3-8B continua longe dos 56,0 que o RLM com GPT-5 no raiz marca na tabela principal do artigo. Treinar tornou o modelo pequeno utilizável como raiz, e o nível dos modelos de fronteira continua distante.
Onde o aprendizado por reforço entra e o que ele já mostrou
Aprendizado por reforço com recompensa verificável (RLVR): o modelo tenta, um programa confere a resposta e as tentativas certas ganham peso, como um aluno que só recebe nota quando a conta fecha. A versão de maio do artigo acrescentou um experimento assim no MRCRv2, benchmark de achar várias agulhas num texto longo. O modelo foi o Qwen3-4B-Instruct-0527, treinado em 150 passos, com lote de 128 e quatro trajetórias por exemplo.
Todo o interesse do experimento está no tamanho. O treino usou textos de 32 mil a 64 mil tokens com duas agulhas; a avaliação usou textos de 512 mil a 1 milhão de tokens com oito agulhas. Cada turno tinha até 4.096 tokens de saída e cada execução até 20 iterações. Os autores relatam generalização de comprimento: o modelo treinado em texto curto continuou operando no longo. O valor aparece só em gráfico, ao lado do Gemini 3.1 Pro, e por isso fica aqui sem número.
Em 13 de maio de 2026, a equipe do alphaXiv publicou outra variante, sobre o SkyRL. Uma única política ocupa os papéis de pai e de filho, e as trajetórias dos filhos herdam a vantagem do pai: quando a execução inteira acerta, cada subchamada que contribuiu recebe crédito. Na seleção de evidências em artigos científicos, o modelo de 4 bilhões de parâmetros empatou com o Claude Sonnet 4.6 no mesmo harness, o andaime de código em volta do modelo. É resultado de blog da própria equipe, sem revisão por pares.
Fora do REPL também há recursão treinada. O grupo do TTIC treinou modelos recursivos em traços de SAT e de Go 4x4. No SAT, um Qwen2.5-3B ajustado chegou a 64% nas instâncias difíceis que não viu no treino, enquanto modelos muito maiores só com prompt ficaram perto do acaso. O Context-Folding, da ByteDance Seed com CMU e Stanford, treinou por reforço um agente que abre subtrajetórias e as dobra num resumo. São parentes do RLM, e seus números não se transferem para ele.
Rotas de treino para operar recursivamente, com o que cada uma demonstrou
| Rota | Quem e quando | Condição | O que ficou demonstrado | Grau de evidência |
|---|---|---|---|---|
| Destilação por rejeição | Zhang, Kraska e Khattab, janeiro de 2026 | Qwen3-8B, 1.072 trajetórias, 48 horas de H100 | Mediana de +28% sobre o mesmo modelo sem treino | Demonstrado, escala pequena |
| Reforço verificável no MRCRv2 | Mesmos autores, maio de 2026 | Qwen3-4B, treino em 32K a 64K, teste em 512K a 1M | Generalização de comprimento | Demonstrado, valor só em gráfico |
| Política única para pai e filho | alphaXiv, maio de 2026 | Modelo de 4B, seleção de evidências | Empate com Claude Sonnet 4.6 no mesmo harness | Demonstrado pela equipe, em blog |
| Recursão treinada em traços | TTIC, março de 2026 (ICML 2026) | Qwen2.5-3B em SAT; Transformer de 3,18M em Go | 64% no SAT difícil, fora do treino | Demonstrado; sem REPL |
| Context-Folding com FoldGRPO | ByteDance Seed, CMU e Stanford, outubro de 2025 | Seed-OSS-36B com 32K de contexto ativo | 62,0% no BrowseComp-Plus | Demonstrado; sem REPL |
| Modelo de fronteira treinado como RLM | Nenhum anúncio até setembro de 2026 | Sem condição publicada | Nada | Hipótese |
Fonte: arXiv 2512.24601 (v2 e v3); alphaXiv, 13 de maio de 2026; arXiv 2603.02112; arXiv 2510.11967
Do lado das apostas, os autores do RLM escrevem que esperam ver o treino de RLMs nativos virar “um novo eixo de escala”. Em janeiro de 2026, a Prime Intellect afirmou que ensinar modelos a gerir o próprio contexto por reforço seria o próximo grande avanço e anunciou que começaria por modelos pequenos. Em agosto, o texto do Prime Agent admitia que nenhum modelo tinha sido treinado para ele ainda. Até setembro de 2026, nenhum fornecedor anunciou modelo comercial de fronteira treinado explicitamente como RLM.
Treino para operar recursivamente, de outubro de 2025 a setembro de 2026
- outubro de 2025Concluído
Context-Folding
Reforço num agente que ramifica e resume; sem REPL.
- janeiro de 2026Concluído
RLM-Qwen3-8B
Destilação por rejeição; a Prime Intellect anuncia treino de modelos pequenos.
- março de 2026Concluído
Modelos recursivos do TTIC
Prova teórica e treino em SAT e Go.
- maio de 2026Concluído
Reforço verificável e SkyRL
MRCRv2 na versão 3 do artigo; política única no alphaXiv.
- agosto de 2026Concluído
Prime Agent sem modelo próprio
O texto do lançamento diz que nenhum modelo foi treinado para ele.
- setembro de 2026Agora
Nenhum modelo de fronteira nativo
O treino de RLM segue em escala pequena e em blogs de equipe.
Como a Veredas decidiu não treinar um modelo agora
Caio levou a receita para Helena com uma proposta: treinar um modelo de 8 bilhões de parâmetros com as trajetórias do protótipo e rodá-lo num servidor da própria Veredas. O argumento tinha dois lados, custo e sigilo. O protótipo otimizado gastava US$ 0,41 por pergunta num modelo de fronteira, e parte dos clientes pedia que os laudos não saíssem da empresa.
Volume foi a primeira conta. A receita do artigo gerou três trajetórias por tarefa e aprovou 1.072 de 2.250, perto de 48%. As 120 perguntas de Helena, rodadas três vezes, dariam 360 trajetórias, a US$ 0,41 cada: US$ 147,60. Com a mesma taxa de aprovação, sobrariam cerca de 171 trajetórias, um sexto do que o artigo usou, e tiradas de um único conjunto de perguntas em vez de um benchmark público com tarefas variadas.
Pior era o segundo problema. As 120 perguntas são o conjunto de avaliação: é com elas que a Veredas mede se qualquer mudança melhora ou piora o resultado. Treinar nelas seria entregar ao aluno a prova com gabarito e depois aplicar a mesma prova. Qualquer ganho medido depois estaria contaminado, e a empresa perderia a régua que sustentou todas as decisões desde o protótipo.
Do rastro veio a terceira conta. Caio revisou 200 turnos do raiz registrados no protótipo e achou 23 com erro de formato na resposta final, 11,5%, na faixa dos 13% a 16% do artigo. Nenhum chegou ao cliente, porque a checagem de formato recusava e o laço tentava de novo, mas cada tentativa extra custava tempo e dinheiro. Um modelo treinado pagaria parte do próprio custo por aí, sem resolver a falta de dados.
A conta que Caio apresentou, lado a lado com a receita do artigo
| Item | Receita do artigo | Veredas, se treinasse agora |
|---|---|---|
| Perguntas de origem | 750 tarefas públicas e variadas | 120 perguntas, todas do conjunto de avaliação |
| Trajetórias geradas | 2.250 (três por tarefa) | 360 (três por pergunta), US$ 147,60 a US$ 0,41 |
| Trajetórias aprovadas | 1.072, cerca de 48% | Cerca de 171, pela mesma taxa |
| Erro de formato nos turnos | 16% com FINAL, 13% com FINAL_VAR | 23 de 200 turnos revisados, 11,5% |
| Avaliação depois do treino | Benchmarks separados do treino | Contaminada: treino e prova nas mesmas perguntas |
Cenário ilustrativo da Veredas Ambiental. A taxa de aprovação de 48% é 1.072 dividido por 2.250.
Helena decidiu em três partes. Nada de treino em 2026. Todo uso real passa a gravar a trajetória completa, com a pergunta do analista e a nota que ela ou um revisor dá à resposta. As 120 perguntas ficam fora de qualquer treino, sem exceção, e o próprio filtro de dados recusa os identificadores delas. A receita volta à mesa quando houver 1.000 trajetórias aprovadas de perguntas reais, fora do conjunto de avaliação.
# Filtro das trajetórias da Veredas antes de qualquer treino.
# Os campos são do registro que o Caio definiu, não de uma biblioteca.
import json
LIMITE_CARACTERES = 100_000 # ordem de grandeza do corte usado no artigo
def exemplos_de_treino(caminho, ids_avaliacao):
exemplos = []
with open(caminho, encoding="utf-8") as arquivo:
for linha in arquivo:
t = json.loads(linha)
if t["pergunta_id"] in ids_avaliacao:
continue # as 120 perguntas de Helena nunca entram no treino
if t["nota_revisor"] == 0 or len(t["turnos"]) < 2:
continue # sem acerto ou sem laço, não ensina a operar o REPL
for turno in t["turnos"]:
if len(turno["historico"]) > LIMITE_CARACTERES:
continue # turno longo demais fica fora
exemplos.append({"entrada": turno["historico"], "saida": turno["codigo"]})
return exemplosDuas saídas para a proposta de treino
Treinar agora com o que existe
Coluna a evitar
- Cerca de 171 trajetórias de um só conjunto de perguntas
- Treino e avaliação nas mesmas 120 perguntas
- Ganho impossível de separar de memorização
- Modelo próprio sem régua para compará-lo
Acumular trajetórias reais e decidir depois
Coluna recomendada
- Toda pergunta real gravada com nota do revisor
- As 120 perguntas bloqueadas no filtro de dados
- Gatilho explícito: 1.000 trajetórias aprovadas
- Nova decisão com a régua intacta
No ritmo que a Veredas projetou, 30 perguntas reais por semana com aprovação perto de metade, as 1.000 trajetórias chegam em cerca de 67 semanas: 15 aprovadas por semana, 1.000 dividido por 15. Nesse prazo, os grupos que prometeram treinar modelos pequenos terão publicado resultado ou não, e a decisão poderá ser tomada com evidência nova.
Em troca da aposta de treino, a Veredas ganhou um acervo de trajetórias que cresce toda semana e uma régua que ninguém pode contaminar. Uma ideia vizinha, a de o agente reescrever a própria memória e as próprias instruções, promete ganho sem treino algum. Antes de ler o próximo capítulo, anote o número de acertos do seu sistema num conjunto de perguntas que ele nunca viu; é contra esse número que qualquer auto-melhoria terá de se provar.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Voltar ao capítulo anterior: Impedir que o erro de uma folha chegue à resposta final
Todos os capítulos de RLM 2027
- 01Descobrir onde o modelo encontra cada informação que usa
- 02Medir o limite real do contexto e dividir o problema
- 03Guardar o acervo numa variável e deixar o modelo programar a leitura
- 04Desenhar a árvore de chamadas e decidir a profundidade
- 05Explorar o acervo antes de decidir onde cortar
- 06Processar as partes e juntar as respostas sem perder a evidência
- 07Comparar contexto longo, RAG e compactação antes de escolher o RLM
- 08Situar agentes, híbridos e RLM numa matriz de decisão
- 09Julgar um benchmark antes de acreditar no número dele
- 10Comparar métodos nas mesmas condições e ler os resultados contrários
- 11Preparar o acervo e rodar a biblioteca oficial rlm
- 12Montar o protótipo com dspy.RLM e auditar o rastro de cada resposta
- 13Decompor o custo de uma execução e pôr teto em cada parte
- 14Baixar o custo por pergunta e vigiar o que a média esconde
- 15Isolar o código gerado e tratar cada documento como dado
- 16Impedir que o erro de uma folha chegue à resposta final
- 17Treinar um modelo pequeno para decidir quando delegar
- 18Provar uma auto-melhoria antes de acreditar nela
- 19Julgar as apostas de recursão aprendida e execução previsível
- 20Mapear híbridos, imagem e trabalho prolongado com evidência e lacuna
- 21Ler 2027 por sinais observáveis em vez de apostar numa previsão
- 22Escolher onde o RLM entra primeiro e decidir o piloto
- 23Definir o problema e construir quatro alternativas comparáveis
- 24Avaliar as alternativas e dizer em quais condições o RLM compensa