Agentes de código para executivos · Capítulo 26 de 27 · 15 min
Treinar agentes de vários turnos e decidir quem recebe o crédito
Escolha entre nota final e nota por passo, desenhe ambiente e verificador de uma tarefa com ferramenta e reconheça quando o RL não compensa.
Este capítulo faz parte do curso gratuito Agentes de código para executivos.
Um agente que monta link de campanha não resolve numa tacada: lê o pedido, chama a ferramenta, recebe um erro, corrige e entrega. Quando a URL final sai certa, a pergunta de treino é quais desses turnos merecem o crédito. Ao fim desta aula você desenha ambiente, verificador e recompensa de uma tarefa com ferramenta. Também escolhe entre nota final e nota por passo e reconhece quando treinar pesos não compensa.
Em tarefa de um turno, a trajetória é uma resposta, e a vantagem da aula anterior cai sobre ela inteira. Em tarefa de vários turnos, o agente alterna ação e observação: cada chamada de ferramenta devolve algo do ambiente, que entra no contexto do turno seguinte. A recompensa costuma chegar só no fim. Daí nasce o problema de atribuição de crédito: descobrir qual decisão, entre dez ou cem, fez o resultado sair bom ou ruim.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Há duas famílias de juiz para esse problema. O modelo de recompensa de resultado, ORM na sigla em inglês, olha só a resposta final. O modelo de recompensa de processo, PRM, dá nota a cada passo intermediário. No estudo Let's Verify Step by Step (OpenAI, maio de 2023), a supervisão por processo superou de forma significativa a supervisão por resultado. O teste usou o MATH, conjunto de problemas de matemática de competição, e o modelo resolveu 78% de um subconjunto representativo.
O preço desse ganho foi o rótulo. Os autores liberaram o PRM800K, com 800.000 rótulos humanos por passo. Mostraram também que o aprendizado ativo (escolher o que mandar para rotulagem em vez de sortear) aumenta a eficácia da supervisão por processo. Para uma empresa, a pergunta prática é quem rotula o passo intermediário do seu agente e quanto isso custa por mil passos. Sem resposta, a nota por passo vira a opinião de outro modelo, com os vieses dele.
Três formas de pagar o crédito num episódio longo
| Forma | O que recebe nota | Custo do sinal | Risco |
|---|---|---|---|
| Recompensa final (ORM ou verificador no fim) | Só o resultado do episódio | Baixo: um veredito por episódio | Crédito difuso; acerto por sorte premia turnos ruins |
| Recompensa intermediária programada | Eventos checáveis no caminho, como chamada válida ou arquivo que compila | Baixo: uma regra escrita | O agente otimiza o evento e esquece o fim |
| PRM | Cada passo do raciocínio | Alto: rótulo humano por passo ou outro modelo | O próprio PRM vira alvo de atalho e precisa de atualização |
Fonte: Elaboração própria a partir de Lightman et al. (2023) e RAGEN (2025)
Três trabalhos de 2025 mostram o desenho do sinal decidindo o resultado. O SWE-RL (Meta, fevereiro de 2025) treinou o Llama 3 com uma recompensa leve baseada em regra: a similaridade entre o patch gerado (o conjunto de mudanças no código) e o patch real de projetos abertos. Com 70 bilhões de parâmetros, chegou a 41,0% no SWE-bench Verified, conjunto de issues reais do GitHub conferidas por pessoas. Os autores relatam ganho em cinco tarefas fora do domínio, enquanto o ajuste supervisionado de base piorou na média.
O RAGEN (abril de 2025) treinou agentes em quatro ambientes, três deles de vários turnos. Descreveu a Echo Trap, armadilha em que a variância da recompensa despenca e o gradiente dá saltos. A versão estabilizada filtra trajetórias, reintroduz um crítico e controla o gradiente; sem sinal fino e atento ao raciocínio, concluem os autores, o agente aprende estratégias rasas. O ToolRL (abril de 2025) estudou só o desenho da recompensa para uso de ferramenta. Treinou com GRPO e mediu 17% sobre o modelo base e 15% sobre o ajuste supervisionado.
Crédito e ambiente em números
78%
do subconjunto do MATH com supervisão por processo
Let's Verify Step by Step, 05/2023
800.000
rótulos humanos por passo no PRM800K
Let's Verify Step by Step, 05/2023
41,0%
no SWE-bench Verified, Llama3-SWE-RL-70B
SWE-RL, 02/2025
+17%
sobre o modelo base em uso de ferramenta
ToolRL, 04/2025
39,4%
no SWE-Bench Verified treinando só com RL
SkyRL-Agent, 11/2025
1.000
ambientes sintéticos com recompensa confiável
Agent World Model, 02/2026
Fonte: Lightman et al., SWE-RL, ToolRL, SkyRL-Agent e Agent World Model, arXiv
De 2025 para 2026 o gargalo saiu do algoritmo e foi para o ambiente. O SkyRL-Agent (Berkeley, novembro de 2025) treinou um agente de código só com RL até 39,4% de acerto na primeira tentativa no SWE-Bench Verified. O custo ficou mais de duas vezes menor que o de modelos de desempenho parecido. O Agent World Model (Snowflake, fevereiro de 2026) gerou 1.000 ambientes sintéticos baseados em código e banco de dados. O ProRL Agent (NVIDIA, março de 2026) oferece rollouts como serviço, separados do laço de treino.
O que os trabalhos de 2026 dizem sobre estabilidade
| Trabalho | Achado | O que muda no seu desenho |
|---|---|---|
| Receita para agentes de ferramenta de horizonte longo, 03/2026 | Cerca de mil exemplos com dificuldade equilibrada são o ponto ideal no TravelPlanner | Comece com conjunto pequeno e balanceado de tarefas |
| RAGEN-2, 04/2026 | Colapso de molde: o raciocínio fica igual para entradas diferentes, mesmo com entropia estável | Meça se o raciocínio muda com a entrada, além da entropia |
| ARLArena, 02/2026 | O RL agêntico é instável e costuma colapsar; o SAMPO estabiliza | Planeje retomada a partir de checkpoint antes da primeira passada |
| Estudo do tamanho do horizonte, 05/2026 | Aumentar só o horizonte já é gargalo de treino | Quebre a tarefa longa em subtarefas mais curtas |
| SDAR, 05/2026 | Autodestilação auxiliar sobre o GRPO: +9,4% no ALFWorld e +10,2% no WebShop | Teste depois que o GRPO básico estiver estável |
Fonte: arXiv 2603.21972, 2604.06268, 2602.21534, 2605.02572 e 2605.15155
Antes de escolher algoritmo, três peças precisam existir. O ambiente é o mundo em que o agente age: ferramentas expostas, estado inicial, limite de turnos e o que fica fora de alcance. O verificador é o programa que decide a nota sem perguntar ao agente o que ele fez. O orçamento de rollouts, execuções completas do agente sobre uma tarefa, fixa quantas tentativas cabem no dinheiro, e ele cresce rápido quando cada episódio tem vários turnos.
A conta de uma passada de treino, com números ilustrativos
| Item | Valor | Conta |
|---|---|---|
| Tarefas no conjunto | 500 | dado do projeto |
| Episódios por passada | 4.000 | 500 tarefas × grupo de 8 |
| Chamadas ao modelo | 24.000 | 4.000 episódios × 6 turnos |
| Tokens de entrada | 72 milhões | 24.000 chamadas × 3.000 tokens de contexto médio |
| Dez passadas | 720 milhões | 72 milhões × 10 |
Números ilustrativos para mostrar a ordem de grandeza; troque pelos do seu projeto. O contexto médio cresce a cada turno, porque a observação anterior volta para o prompt.
Num primeiro projeto com verificador programático, o RL só compensa quando esse verificador é barato, rápido e confiável. Se a nota exige uma pessoa lendo, se o verificador erra muito ou se o rollout custa mais que o ganho, comece pelo prompt, pela memória e pelos exemplos. Essas alavancas mudam o comportamento sem tocar nos pesos, custam horas em vez de semanas e voltam atrás com um commit. RLHF com modelo de recompensa é outro projeto, com outro orçamento. O curso de RLM detalha essa escolha em quando treinar pesos e quando ficar na memória.
Treinar pesos ou ficar no prompt e na memória
Eixo horizontal: Custo do verificador por episódio →Eixo vertical: Confiabilidade do verificador →
Confiável e barato
- RL com verificador vale o teste
- Testes que executam, gabarito numérico
Confiável e caro
- Poucos rollouts e grupos pequenos
- Avalie otimizar o prompt antes, como no GEPA
Pouco confiável e barato
- Atalho provável no treino
- Conserte o verificador antes de treinar
Pouco confiável e caro
- Fique em prompt e memória
- Revisão humana por amostra
A tarefa de UTM do guia de Claude contra OpenAI é um bom primeiro ambiente. O verificador cabe em 35 linhas e não depende de opinião. As regras já estão no AGENTS.md daquele guia: três parâmetros obrigatórios, minúsculas sem acento, meio numa lista fechada e “&” quando a URL já tem “?”. Para comparar, use o GEPA como linha de base barata: ele evolui o prompt por reflexão e superou o GRPO com até 35 vezes menos rollouts (2025).
Desenhar o ambiente e a recompensa da tarefa de UTM
Seis passos, na ordem em que as decisões dependem umas das outras.
Passo 1: Liste o estado inicial e as ferramentas
Pedido em texto, URL de destino e uma única ferramenta gerar_utm; nada de rede nem escrita em disco.
Deu certo quando: Cabe numa frase o que o agente vê e o que pode chamar.
Erro comum: Expor o arquivo de testes junto com a ferramenta.
Passo 2: Escreva os casos de borda antes do verificador
URL com “?” e com fragmento “#”, origem com maiúscula, campanha com acento e espaço, meio fora da lista, parâmetro repetido.
Deu certo quando: Pelo menos um caso por regra do AGENTS.md.
Erro comum: Só casos felizes, que qualquer política passa.
Passo 3: Faça o verificador ler só a URL final
O código abaixo confere a URL, e nunca o texto em que o agente diz que acertou.
Deu certo quando: Uma resposta que só afirma sucesso recebe zero.
Erro comum: Dar ponto por formato parecido.
Passo 4: Decida o que é recusa correta
Meio fora da lista deve ser recusado; responder mesmo assim vale menos 1, abaixo de desistir.
Deu certo quando: Recusar o pedido inválido rende mais que inventar.
Erro comum: Premiar qualquer resposta, o que ensina a inventar.
Passo 5: Ponha a penalidade intermediária com teto
Menos 0,1 por chamada inválida, no máximo três, para não afogar a nota final.
Deu certo quando: Episódio com dois erros e entrega certa ainda vale 0,8.
Erro comum: Penalidade sem teto, que ensina a não chamar a ferramenta.
Passo 6: Calcule o orçamento antes de rodar
Tarefas × grupo × turnos × tokens, como na tabela da conta de uma passada.
Deu certo quando: Teto em dólares aprovado antes da primeira passada.
Erro comum: Descobrir o custo na fatura.
No fim você tem: Ambiente, verificador e recompensa que um colega audita em dez minutos.
import unicodedata
from urllib.parse import urlsplit, parse_qsl
MEIOS = {"cpc", "email", "social", "display", "afiliado"}
def normalizar(v: str) -> str:
v = unicodedata.normalize("NFKD", v).encode("ascii", "ignore").decode()
return v.strip().lower().replace(" ", "-")
def nota_base(caso: dict, resposta: str | None) -> float:
"""Verificador do episódio: lê só a URL final, nunca o raciocínio."""
if caso["medium"] not in MEIOS: # pedido inválido
return 1.0 if resposta is None else -1.0 # recusar é o certo
if resposta is None:
return 0.0 # desistiu de um caso válido
try:
partes, base = urlsplit(resposta), urlsplit(caso["url"])
except ValueError:
return 0.0 # URL malformada
params = parse_qsl(partes.query, keep_blank_values=True)
if len({k for k, _ in params}) != len(params):
return 0.0 # parâmetro repetido, mesmo vazio
p = dict(params)
esperado = {"utm_source": caso["source"], "utm_medium": caso["medium"],
"utm_campaign": caso["campaign"]}
certo = all(p.get(k) == normalizar(v) for k, v in esperado.items())
destino_intacto = (partes[:3] == base[:3] and partes.fragment == base.fragment
and all(p.get(k) == v for k, v in
parse_qsl(base.query, keep_blank_values=True)))
return 1.0 if (certo and destino_intacto) else 0.0
def recompensa(caso: dict, resposta: str | None, chamadas_invalidas: int) -> float:
return nota_base(caso, resposta) - 0.1 * min(chamadas_invalidas, 3) # com teto
caso = {"url": "https://loja.com/ofertas?ref=home#topo", "source": "Google",
"medium": "cpc", "campaign": "Promoção de Verão"}
boa = ("https://loja.com/ofertas?ref=home&utm_source=google&utm_medium=cpc"
"&utm_campaign=promocao-de-verao#topo")
print(recompensa(caso, boa, 0)) # 1.0
print(recompensa(caso, boa.replace("#topo", ""), 0)) # 0.0: perdeu o fragmento
print(recompensa(caso, boa.replace("loja.com", "outro.com"), 0)) # 0.0: trocou o domínio
print(recompensa({**caso, "medium": "newsletter"}, None, 1)) # 0.9: recusou após um erroRode as quatro chamadas do fim: a URL certa vale 1,0, a que perdeu o “#topo” e a que trocou o domínio valem zero, e a recusa ao meio “newsletter” vale 0,9. A penalidade da chamada inválida vale em todo caminho, inclusive na recusa. Depois tente quebrar o verificador como um agente faria: repita o utm_source, troque a ordem dos parâmetros, mande “Google” com maiúscula. Cada caso que passar sem merecer, ou falhar sem motivo, vira linha nova no conjunto de borda, e a regra que faltava entra no AGENTS.md.
Escreva o ambiente da sua primeira tarefa com ferramenta no mesmo formato: estado inicial, ferramentas, seis casos de borda, verificador e conta do orçamento. Considere pronto quando o verificador acertar a nota em todos os casos de borda. Você também precisa dizer, em tokens e em dólares, quanto custa uma passada. Se algum caso precisar de uma pessoa para decidir, a tarefa fica no prompt e na memória até caber rótulo humano no orçamento.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. Nos vídeos e áudios, use Anotar este momento. 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ê.
Conexões deste capítulo
Veja o que estudar antes e para onde seguir depois, explore os conceitos e compare abordagens em outros cursos. Sugestões marcadas como “sugerido pelo grafo” vêm dos assuntos em comum, não do índice do curso.
Depois, siga para
- CursoMCP para quem decidesugerido pelo grafo5 capítulos de “MCP para quem decide” usam conceitos apresentados em “Agentes de código para executivos”.
- CursoClaude Code CLI: Programação com IAsugerido pelo grafo3 capítulos de “Claude Code CLI: Programação com IA” usam conceitos apresentados em “Agentes de código para executivos”.
Conceitos deste capítulo
O mesmo assunto em outros cursos
Voltar ao capítulo anterior: Ler o mapa dos algoritmos de reforço para LLMs, do RLHF ao GRPO
Leve uma ideia para a prática
Escolha uma atividade no painel e volte a este curso quando quiser.
Atividades e evolução ficam reunidas no painel da sua conta.
Capítulos vizinhos em Agentes de código para executivos
- 23Auditar a função de recompensa linha a linha
- 24Promover o piloto a produção com painel e checklist
- 25Ler o mapa dos algoritmos de reforço para LLMs, do RLHF ao GRPO
- 26Treinar agentes de vários turnos e decidir quem recebe o crédito
- 27Reconhecer reward hacking pelos casos documentados de 2024 a 2026