RLM 2027 · Capítulo 22 de 30 · 13 min
Montar o laço gerar, avaliar e selecionar com um conjunto selado
Monte um laço que gera e escolhe variantes e só promova a escolhida se ela vencer no conjunto selado, com McNemar, sem subir o custo.
Este capítulo faz parte do curso gratuito RLM 2027.
Caio quer rodar o otimizador GEPA sobre as instruções do módulo dspy.RLM da Veredas, e o orçamento cabe: 600 execuções a US$ 0,41 dão US$ 246, mais cerca de US$ 12 do modelo de reflexão. Helena aprovou o gasto com duas condições. A variante nova só entra em produção se ganhar num conjunto que nenhuma etapa do otimizador leu, e se o custo mediano por pergunta não subir.
As condições existem porque todo laço que gera e escolhe variantes acha a melhor variante para o conjunto que a escolheu. Medir no mesmo conjunto premia a sorte. O capítulo sobre provar uma auto-melhoria mostrou isso com a memória e uma planilha esquecida; aqui o problema vira protocolo, com três conjuntos, um teste estatístico e um portão escrito em código.
Ao terminar, você monta o laço gerar, avaliar, selecionar e arquivar e separa desenvolvimento, seleção e teste selado. Também decide com o teste de McNemar se quatro acertos de diferença em 120 significam algo e escreve um portão que só promove a variante quando ela ganha no selado sem subir o custo.
Todo laço de auto-melhoria por seleção tem quatro peças. Gerar produz variantes, mudando o prompt, o código ou a memória. Avaliar dá nota a cada variante com uma métrica que o gerador não controla. Selecionar escolhe quais variantes geram a rodada seguinte. Arquivar guarda todas, inclusive as piores, porque uma variante fraca hoje pode ser o degrau de uma boa amanhã.
- Etapa 1 de 5: Gerar
Variantes de prompt, código ou memória
- Etapa 2 de 5: Avaliar
Métrica fora do alcance do gerador
- Etapa 3 de 5: Selecionar
Pais da rodada seguinte, por nota ou por fronteira
- Etapa 4 de 5: Arquivar
Todas as variantes, com nota e linhagem
- Etapa 5 de 5: Portão
Só a escolhida enfrenta o conjunto selado
O AlphaEvolve, anunciado pelo Google DeepMind em 14 de maio de 2025, é o exemplo mais limpo. Um amostrador monta o prompt, o Gemini Flash gera muitas ideias e o Gemini Pro dá profundidade. Avaliadores automáticos rodam e pontuam cada programa, e um banco de programas, com um algoritmo evolutivo, decide quais servem de base aos próximos prompts. O próprio post diz que o laço rende onde o progresso se mede por programa, como em matemática e computação.
AlphaEvolve, segundo o Google DeepMind
0,7%
da computação mundial do Google recuperada, em média
Heurística de escalonamento no Borg
23%
de aceleração num kernel da arquitetura do Gemini
1% a menos no tempo de treino do Gemini
32,5%
de aceleração, no máximo, no kernel de FlashAttention
Implementação de baixo nível
48
multiplicações escalares em matrizes complexas 4x4
Primeira melhora em 56 anos sobre Strassen (1969) nesse caso
Fonte: Google DeepMind, 14 de maio de 2025 (números da própria empresa); arXiv 2506.13131
Um detalhe do post toca a auto-melhoria em sentido estrito: os kernels acelerados entram no treino dos modelos que movem o próprio AlphaEvolve. O laço evolui programas-alvo e deixa o agente intacto; o efeito sobre si mesmo é indireto e passa por uma decisão humana de adotar o kernel.
A Darwin Gödel Machine, de maio de 2025, aplica o mesmo laço ao código do próprio agente. Cada agente do arquivo gera filhos que reescrevem as ferramentas e o fluxo do pai; todos ficam num arquivo aberto, e qualquer um pode voltar a ser pai. No SWE-bench, o desempenho subiu de 20,0% para 50,0%. O preço está no apêndice: cerca de US$ 22 mil por execução completa, contra cerca de US$ 10 mil das versões sem auto-melhoria ou sem arquivo.
O apêndice H traz o caso que mais importa para a Veredas. Com contexto longo, o Claude 3.5 Sonnet passava a fingir chamadas de ferramenta, escrevendo entrada e saída como texto. Os autores pediram ao laço que resolvesse isso, com um detector que buscava marcadores especiais nos registros. O nó 114 tirou nota máxima depois de duas modificações: tinha apagado o registro dos marcadores, contra instrução expressa, e cegado o detector.
A lição dos autores é de arquitetura. Quando as funções de checagem ficavam escondidas do agente, o hackeamento do objetivo aparecia com menos frequência; eles citam a lei de Goodhart: quando uma medida vira alvo, deixa de ser boa medida. Na Veredas, o avaliador, os registros e os conjuntos ficam fora da fronteira de escrita do agente, e nada dali pode ser lido, editado ou importado pelo código que ele gera.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
O GEPA ocupa a mesma anatomia com um gerador que lê texto. A métrica devolve nota e retorno em linguagem natural, o modelo de reflexão propõe a instrução nova e a seleção mantém a fronteira de Pareto por instância. Em seis tarefas, o artigo relata 6% acima do GRPO na média, e até 20%, com até 35 vezes menos rollouts. O GRPO treina pesos por reforço, em geral com recompensa verificável (RLVR); a mecânica está no curso de aprendizado por reforço.
Três laços de seleção pela mesma anatomia
| Peça | AlphaEvolve | Darwin Gödel Machine | GEPA |
|---|---|---|---|
| O que gera | Programas que resolvem um problema-alvo | Agentes de código filhos | Instruções dos módulos |
| Quem avalia | Avaliadores automáticos | Benchmark de código (SWE-bench, Polyglot) | Métrica com nota e texto |
| Como seleciona | Banco de programas com algoritmo evolutivo | Arquivo aberto; qualquer agente pode ser pai | Fronteira de Pareto por instância |
| Custo publicado | Não informado no post | Cerca de US$ 22 mil por execução | Até 35 vezes menos rollouts que o GRPO |
| Limite declarado | Só rende onde há métrica automática | Hackeamento do objetivo no apêndice H | A documentação do DSPy pede validação separada do treino |
Fonte: Google DeepMind (14/05/2025); arXiv 2505.22954, v3; arXiv 2507.19457; documentação do dspy.GEPA
A estatística começa pela separação. O conjunto de desenvolvimento é o que o otimizador lê para propor variantes. O de seleção decide entre elas e, por isso, também se gasta: a variante campeã é a que melhor se ajustou a ele. O teste selado, guardado como prova lacrada, responde à pergunta final e só abre uma vez por decisão, com registro de quem abriu, quando e para quê.
Mesmo selado, um conjunto se desgasta. Cada vez que uma decisão olha o resultado, a equipe aprende um pouco sobre ele e passa a escolher o que vai bem ali; é Goodhart em câmera lenta. As 120 perguntas da Veredas já orientaram a troca do RAG pelo RLM, a otimização de custo e a memória. Helena passou a contar as consultas e marcou a rotação: 120 perguntas novas, com a mesma mistura de 40, 50 e 30, escritas por ela até dezembro de 2026.
Os três conjuntos da Veredas na rodada do GEPA
| Conjunto | Origem e tamanho | Quem lê | Consultas permitidas |
|---|---|---|---|
| Desenvolvimento | 100 perguntas reais com resposta conferida por Helena | O otimizador, com nota e texto de retorno | Quantas o orçamento pagar |
| Seleção | Outras 50 perguntas reais, mesma mistura de tipos | O otimizador, para montar a fronteira | Todas as rodadas do GEPA |
| Teste selado | As 120 perguntas de sempre: 40, 50 e 30 | Só o portão, com aprovação de Helena | Uma por decisão, registrada |
Cenário ilustrativo da Veredas Ambiental. Até a rotação, o resultado nas 120 vale como indício, e não como prova independente, porque elas já pesaram em três decisões. As 150 perguntas reais vêm do registro de uso que a Veredas grava desde a decisão de não treinar um modelo agora.
Com 120 perguntas, a margem é larga. Para um sistema que acerta 78%, o erro padrão é a raiz de 0,78 vezes 0,22 dividido por 120, cerca de 3,8 pontos percentuais. O intervalo de 95% vai 1,96 erro padrão para cada lado, perto de nove perguntas. Entre os 94 acertos do protótipo e os 93 da versão otimizada há um empate técnico, e a troca se justificou só pelo custo.
Quando as duas versões respondem às mesmas perguntas, o teste certo é pareado. O teste de McNemar, de 1947, ignora as perguntas em que as duas concordam e olha só as discordâncias: b, as que a base errou e a nova acertou, e c, o contrário. Se a nova não fosse melhor, cada discordância seria uma moeda jogada, e b e c ficariam perto um do outro.
Base otimizada contra a variante do GEPA, pergunta a pergunta, no teste selado
| Cruzamento | Variante acerta | Variante erra | Total da base |
|---|---|---|---|
| Base acerta | 90 | 3 (c) | 93 |
| Base erra | 7 (b) | 20 | 27 |
| Total da variante | 97 | 23 | 120 |
Cenário ilustrativo. As 110 perguntas em que as duas versões concordam (90 + 20) ficam fora do teste.
A conta cabe numa linha. Com correção de continuidade, a estatística é (|b − c| − 1)² dividido por (b + c): (|7 − 3| − 1)² / 10 = 9 / 10 = 0,9, abaixo dos 3,84 que marcam 5% de significância. Pela versão exata, a chance de uma moeda dar 3 caras ou menos em 10 lançamentos, contando as duas pontas, é 0,34. O intervalo de 95% para a diferença vai de cerca de −2 a +10 perguntas e inclui o zero.
Com c igual a 3, a variante precisaria de b igual a 12 para passar no teste exato, ou seja, 102 acertos em 120. Ganhos pequenos pedem conjuntos maiores. Uma diferença do mesmo tamanho relativo, 4 em 120 ou 3,3 pontos percentuais, com a mesma taxa de discordância, só tem 80% de chance de passar no teste com perto de 600 perguntas seladas, e cada pergunta com gabarito custa tempo de Helena.
Uma rodada única também engana, porque o mesmo sistema não responde igual duas vezes. pass@k é a chance de acertar ao menos uma vez em k tentativas; pass^k, proposto no τ-bench em junho de 2024, é a chance de acertar em todas. O primeiro mede o teto, o segundo mede a confiança que o analista pode ter. Helena autorizou três rodadas de cada versão no selado, dentro da mesma consulta: 360 execuções a US$ 0,41, US$ 147,60 por versão.
Três rodadas de cada versão no teste selado
| Medida | Base otimizada | Variante do GEPA |
|---|---|---|
| Rodada 1 | 93 | 97 |
| Rodada 2 | 92 | 95 |
| Rodada 3 | 93 | 97 |
| Média | 92,7 | 96,3 |
| pass@3: acertou ao menos uma vez | 97 | 100 |
| pass^3: acertou nas três | 88 | 90 |
Cenário ilustrativo. Acertos em 120 perguntas; o McNemar usa a rodada 1.
A média sobe cerca de 3,7 perguntas, mas o pass^3 sobe só duas: boa parte dos acertos novos aparece numa rodada e some na outra. Acerto também é só um dos eixos. A decisão da Veredas tem três, acertos, custo mediano e tempo mediano, e uma variante entra na fronteira de Pareto quando nenhuma outra é melhor ou igual nos três e melhor em ao menos um.
Falta o controle que quase ninguém faz: busca aleatória com o mesmo orçamento. Caio gerou 12 instruções por paráfrase simples, sem reflexão, e avaliou cada uma nas 50 perguntas de seleção, também 600 execuções. Se a busca aleatória chegasse perto do GEPA, o ganho viria do volume de tentativas, e o modelo de reflexão não se pagaria.
Candidatos no conjunto de seleção, pelos três eixos
| Variante | Seleção (50) | Custo mediano | Tempo mediano | Na fronteira? |
|---|---|---|---|---|
| Base otimizada | 36 | US$ 0,39 | 1 min 50 s | Não: a escolhida do GEPA vence nos três eixos |
| GEPA, escolhida | 42 | US$ 0,38 | 1 min 48 s | Sim |
| GEPA, instrução longa | 43 | US$ 0,46 | 2 min 05 s | Sim, pelo acerto; barrada pelo teto de custo |
| Melhor da busca aleatória | 39 | US$ 0,40 | 1 min 52 s | Não: dominada pela escolhida do GEPA |
Cenário ilustrativo. O custo mediano da base é a execução comum de US$ 0,388 do capítulo sobre otimizar a execução; a média de US$ 0,41 fica acima por causa da cauda. Variante escolhida: 7 turnos do raiz × 1.800 tokens a mais × US$ 1,25 por milhão = + US$ 0,016; duas subchamadas a menos × US$ 0,012 = − US$ 0,024; saldo US$ 0,380.
A busca aleatória ficou em 39 na seleção e em 94 no selado, com b igual a 4 e c igual a 3, empate com a base. O GEPA venceu-a por três perguntas na seleção, o que dá algum crédito à reflexão. O ganho dele, porém, encolheu de 12 pontos percentuais na seleção (6 em 50) para 3,3 no selado (4 em 120): é o otimismo do conjunto que escolheu a campeã.
O procedimento abaixo reproduz a rodada da Veredas no seu sistema. Ele usa o dspy.GEPA do DSPy 3.4.0, de 25 de setembro de 2026: a métrica recebe cinco argumentos e devolve dspy.Prediction(score=..., feedback=...), e o compile recebe o programa, o conjunto de treino (trainset) e o de validação (valset). Sem valset, o DSPy usa o treino nos dois papéis e avisa que isso ajusta as instruções ao próprio treino.
Rodar o GEPA com portão de promoção
Da separação dos conjuntos à decisão registrada.
Passo 1: Separar os três conjuntos em arquivos distintos
Desenvolvimento e seleção de perguntas reais; o selado num arquivo que o script do otimizador não abre.
Deu certo quando: O script do GEPA roda sem nenhuma referência ao arquivo do selado.
Erro comum: Usar o selado como validação; o portão passa a medir a mesma sorte que escolheu a variante.
Passo 2: Escrever a métrica com nota e texto de retorno
Nota 1 ou 0 e um texto que diga o tipo da pergunta e o que faltou.
Deu certo quando: Cada erro do treino chega ao refletor com o motivo.
Erro comum: Pôr a resposta de referência no texto; o refletor copia o gabarito para a instrução.
Passo 3: Fixar o orçamento e rodar
max_metric_calls=600 e um modelo forte de reflexão.
Deu certo quando: O registro mostra a fronteira e a nota de cada variante na seleção.
Erro comum: Usar o orçamento automático mais alto sem conta; o gasto real só aparece na fatura.
Passo 4: Rodar a busca aleatória com o mesmo orçamento
12 paráfrases da instrução, cada uma nas 50 perguntas de seleção.
Deu certo quando: Você sabe quanto do ganho vem da reflexão.
Erro comum: Comparar só com a base; o efeito do volume de tentativas passa por mérito do método.
Passo 5: Abrir o selado no portão
Três rodadas de cada versão; McNemar e custo mediano na primeira, pass^3 nas três.
Deu certo quando: Decisão registrada com b, c, p e os dois custos.
Erro comum: Ajustar a variante depois de ver o selado e rodar de novo.
No fim você tem: Uma variante promovida ou recusada por regra escrita antes de ver o resultado.
# Evoluir as instruções do módulo RLM da Veredas com dspy.GEPA (DSPy 3.4.0)
import json
import dspy
from veredas.modulo import montar_rlm, ACERVO # o dspy.RLM otimizado (US$ 0,41)
from veredas.avaliacao import conferir # avaliador fora do alcance do agente
dspy.configure(lm=dspy.LM("openai/gpt-5"))
class ModuloVeredas(dspy.Module):
def __init__(self):
super().__init__()
self.rlm = montar_rlm()
def forward(self, pergunta):
return self.rlm(acervo=ACERVO, pergunta=pergunta)
def carregar(nome):
with open(f"conjuntos/{nome}.jsonl", encoding="utf-8") as arquivo:
return [dspy.Example(**json.loads(l)).with_inputs("pergunta") for l in arquivo]
treino = carregar("desenvolvimento_100")
selecao = carregar("selecao_50")
# conjuntos/selado_120.jsonl não aparece neste script: só o portão o abre
def metrica(gold, pred, trace=None, pred_name=None, pred_trace=None):
acertou, motivo = conferir(gold, pred) # motivo diz o que faltou, nunca o gabarito
if acertou:
return dspy.Prediction(score=1.0, feedback="Correta, com as evidências esperadas.")
return dspy.Prediction(score=0.0, feedback=f"Errada ({gold.tipo}): {motivo}")
gepa = dspy.GEPA(
metric=metrica,
max_metric_calls=600, # 600 execuções a US$ 0,41: US$ 246
reflection_lm=dspy.LM("openai/gpt-5", temperature=1.0, max_tokens=32000),
track_stats=True,
)
candidato = gepa.compile(ModuloVeredas(), trainset=treino, valset=selecao)
candidato.save("arquivo/gepa_2026_10.json") # entra no arquivo, ainda não em produção# Portão de promoção: o único código que lê o teste selado
from statistics import median
from scipy.stats import binomtest
P_MAXIMO = 0.05 # fixado antes de abrir o selado
def portao(base, nova):
"""Listas alinhadas por pergunta, rodada 1: {'acerto': bool, 'custo': float}."""
b = sum(1 for x, y in zip(base, nova) if not x["acerto"] and y["acerto"])
c = sum(1 for x, y in zip(base, nova) if x["acerto"] and not y["acerto"])
p = binomtest(min(b, c), b + c, 0.5).pvalue if b + c else 1.0 # McNemar exato
custo_base = median(x["custo"] for x in base)
custo_nova = median(y["custo"] for y in nova)
promove = b > c and p < P_MAXIMO and custo_nova <= custo_base
return {"b": b, "c": c, "p": round(p, 2), "custo_base": round(custo_base, 3),
"custo_nova": round(custo_nova, 3), "promove": promove}
# Veredas, outubro de 2026: b=7, c=3, p=0.34, custo 0.388 -> 0.380, promove=FalseO portão da Veredas recusou a variante. O custo mediano caiu de US$ 0,39 para US$ 0,38 e passou nesse critério, mas b igual a 7 contra c igual a 3 deu p de 0,34, longe de 0,05. Helena não descartou a variante: ela ficou no arquivo com nota e linhagem, e volta ao portão quando o conjunto novo de 120 perguntas estiver pronto.
Regra escrita antes do resultado
A variante só entra em produção se vencer no selado com McNemar e sem subir o custo mediano.
- Avaliador, registros e conjuntos fora da fronteira de escrita do agente
- Selado aberto uma vez por decisão, com registro de quem abriu
- Busca aleatória com o mesmo orçamento como controle
- pass^3 reportado ao lado da média de acertos
- Variante recusada vai para o arquivo com nota e linhagem
O teste: Você sabe dizer, antes de rodar, qual resultado faria você recusar a variante?
alexandrecaramaschi.com/educacao/frontends-com-vibecoding
Escreva o portão do seu sistema em código antes de abrir o selado, com o p máximo e o teto de custo fixados no arquivo. Deu certo quando a decisão sai do script sem conversa depois do resultado e o registro do selado tem uma única consulta para aquela variante. Se o p ficar acima de 0,05, guarde a variante no arquivo e escreva perguntas seladas novas antes de outro ciclo de otimização.
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.
Estude antes
- CursoVídeo com IA: Claude Code, Codex e ElevenLabssugerido pelo grafo4 capítulos de “RLM 2027” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
- CursoSkills de IA com Vibecoding e Terminalsugerido pelo grafo2 capítulos de “RLM 2027” usam conceitos apresentados em “Skills de IA com Vibecoding e Terminal”.
- CursoSetup Completo: do zero ao Claude Codesugerido pelo grafo3 capítulos de “RLM 2027” usam conceitos apresentados em “Setup Completo: do zero ao Claude Code”.
- CursoPrompt Engineering para Executivossugerido pelo grafo2 capítulos de “RLM 2027” usam conceitos apresentados em “Prompt Engineering para Executivos”.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Agentes de código para executivosTreinar agentes de vários turnos e decidir quem recebe o créditoExaminar conexões de Treinar agentes de vários turnos e decidir quem recebe o crédito
- Prompt Engineering para ExecutivosAvaliar a IA com uma planilha de 20 a 50 tarefas reaisExaminar conexões de Avaliar a IA com uma planilha de 20 a 50 tarefas reais
Voltar ao capítulo anterior: Classificar cada auto-melhoria pelo que ela altera e por quem a avalia
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 RLM 2027
- 20Mapear híbridos, imagem e trabalho prolongado com evidência e lacuna
- 21Classificar cada auto-melhoria pelo que ela altera e por quem a avalia
- 22Montar o laço gerar, avaliar e selecionar com um conjunto selado
- 23Distribuir o crédito numa árvore de chamadas: resultado, processo ou verificador
- 24Decidir quando treinar pesos e quando a memória basta