Phase 14 - Lesson 05

Self-Refine e CRITIC: Melhoria Iterativa de Saída

O Self-Refine (Madaan et al., 2023) utiliza um LLM em três funções — generate, feedback, refine — em um loop. Ganho médio: +20 absolutos em 7 tarefas. O CRITIC (Gou et al., 2023) robustece a etapa de feedback direcionando a verificação através de ferramentas externas. Em 2026, esse padrão é integrado em todos os frameworks como "evaluator-optimizer" (Anthropic) ou um loop de guardrail (OpenAI Agents SDK).

Type: Build Languages: Python (stdlib) Prerequisites: Phase 14 · 01 (Agent Loop), Phase 14 · 03 (Reflexion) Time: ~60 minutes

Learning Objectives

• Apresentar os três prompts do Self-Refine (generate, feedback, refine) e explicar por que o histórico é importante para o prompt de refinamento.
• Explicar o insight crítico do CRITIC: os LLMs não são confiáveis na autoverificação sem um embasamento (grounding) externo.
• Implementar um loop Self-Refine com stdlib contendo histórico e um verificador externo opcional.
• Mapear esse padrão para o fluxo de trabalho "evaluator-optimizer" da Anthropic e os guardrails de saída do OpenAI Agents SDK.

The Problem

Um agente produz uma resposta que está quase correta. Talvez uma linha de código tenha um erro de sintaxe. Talvez um resumo seja muito longo. Talvez um plano ignore um caso extremo. O que você deseja é: o agente critica a sua própria saída e depois a corrige.

O Self-Refine mostra que isso funciona com um único modelo, sem dados de treinamento e sem RL. Mas há um porém: os LLMs são ruins em autoverificação de fatos concretos. O CRITIC define a solução — direcionar a etapa de verificação por meio de ferramentas externas (busca, interpretador de código, calculadora, executor de testes).

Juntos, esses dois artigos definem o padrão de 2026 para melhoria iterativa: gerar (generate), verificar (verify, externamente quando possível), refinar (refine) e parar quando o verificador for aprovado.

The Concept

Self-Refine (Madaan et al., NeurIPS 2023)

Um único LLM, três papéis:

generate(task)            -> output_0
feedback(task, output_0)  -> critique_0
refine(task, output_0, critique_0, history) -> output_1
feedback(task, output_1)  -> critique_1
refine(task, output_1, critique_1, history) -> output_2
...
stop when feedback says "no issues" or budget exhausted.

Detalhe fundamental: refine visualiza o histórico completo — todas as saídas e críticas anteriores — para não repetir erros. O artigo analisa isso (ablação): remova o histórico e a qualidade despenca drasticamente.

Destaque: +20 de melhoria absoluta na média de 7 tarefas (matemática, código, acrônimos, diálogo), incluindo o GPT-4. Sem treinamento, sem ferramentas externas, modelo único.

CRITIC (Gou et al., arXiv:2305.11738, v4 de fevereiro de 2024)

A fraqueza do Self-Refine: a etapa de feedback é um LLM avaliando a si mesmo. Para alegações factuais, isso não é confiável (uma alucinação frequentemente parece convincente para o próprio modelo que a gerou). O CRITIC substitui feedback(task, output) por verify(task, output, tools), onde tools inclui:

• Um mecanismo de busca para alegações factuais.
• Um interpretador de código para correção de código.
• Uma calculadora para aritmética.
• Verificadores específicos de domínio (testes unitários, verificadores de tipo, linters).

O verificador gera uma crítica estruturada embasada nos resultados das ferramentas. O refinador então se condiciona a essa crítica.

Destaque: O CRITIC supera o Self-Refine em tarefas factuais porque a crítica é embasada. Em tarefas sem verificadores externos (escrita criativa, formatação), o CRITIC se reduz ao Self-Refine.

A condição de parada

Dois formatos comuns:

1. O verificador é aprovado. O teste externo retorna sucesso. Preferível quando disponível (testes unitários, verificador de tipo, asserção de guardrail).
2. Nenhum feedback emitido. O modelo diz que "a saída está correta". Mais barato, porém não confiável; combine com um limite máximo de iterações.

Padrão de 2026: combine ambos. "Parar se o verificador for aprovado OU se o modelo disser que está correto E iterações >= 2 OU iterações >= max_iterations."

Evaluator-Optimizer (Anthropic, 2024)

O artigo da Anthropic de dezembro de 2024 aponta este como um dos cinco padrões de fluxo de trabalho. Duas funções:

• Evaluator: avalia a saída e produz uma crítica.
• Optimizer: revisa a saída com base na crítica.

O ciclo se repete até que o avaliador (evaluator) aprove a saída. Este é o Self-Refine/CRITIC sob a ótica da Anthropic. O detalhe crítico de engenharia que a Anthropic adiciona: os prompts do evaluator e do optimizer devem ser substancialmente diferentes para que o modelo não faça apenas uma aprovação automática ("rubber-stamp").

OpenAI Agents SDK output guardrails

O OpenAI Agents SDK distribui esse padrão como "guardrails de saída" (output guardrails). Um guardrail é um validador executado na saída final de um agente. Se o guardrail for acionado (lança OutputGuardrailTripwireTriggered), a saída é rejeitada e o agente pode tentar novamente. Os guardrails podem chamar ferramentas (estilo CRITIC) ou ser funções puras (estilo Self-Refine).

Armadilhas de 2026

• Loops de aprovação automática (Rubber-stamp loops). O mesmo modelo realizando a geração e a crítica com o mesmo estilo de prompt converge para "parece bom para mim". Use prompts estruturalmente diferentes, ou um modelo menor e mais barato para a crítica.
• Refinamento excessivo. Cada passagem de refinamento adiciona latência e tokens. Defina um orçamento de 1 a 3 passagens; depois disso, encaminhe para revisão humana.
• CRITIC em tarefas triviais. Se não houver um verificador externo, o CRITIC se degrada para o Self-Refine; não pague o custo de latência por um verificador simulado (stub).

Build It

O arquivo code/main.py implementa o Self-Refine e o CRITIC em uma tarefa simples: produzir uma pequena lista de tópicos sobre um assunto. O verificador checa o formato (3 tópicos, cada um com menos de 60 caracteres). O CRITIC adiciona um "verificador de fatos" externo que penaliza alucinações conhecidas.

Componentes:

• generate — produtor roteirizado.
• feedback — autocrítica no estilo LLM.
• verify_external — verificador embasado no estilo CRITIC.
• refine — reescreve a saída com base no histórico.
• Condição de parada — aprovação do verificador ou máximo de 4 iterações.

Execute:

python3 code/main.py

Compare as execuções do Self-Refine versus CRITIC. O CRITIC detecta um erro factual que o Self-Refine deixou passar porque o verificador externo possui um embasamento que o autocriticador não tem.

Use It

O evaluator-optimizer da Anthropic é esse padrão em linguagem amigável ao Claude. Os guardrails de saída do OpenAI Agents SDK possuem o formato do CRITIC (guardrails podem chamar ferramentas). O LangGraph disponibiliza um nó de reflexão que funciona de forma semelhante ao Self-Refine. O Computer Use do Gemini 2.5 do Google adiciona um avaliador de segurança por etapa que é uma variante do CRITIC: cada ação é verificada antes de ser executada.

Ship It

O arquivo outputs/skill-refine-loop.md configura um loop evaluator-optimizer considerando o formato da tarefa, a disponibilidade do verificador e o orçamento de iterações. Emite prompts para o gerador, avaliador/verificador e otimizador, além de uma política de parada.

Exercises

1. Execute o exemplo simples com max_iterations=1. O CRITIC ainda ajuda?
2. Substitua o verificador externo por um ruidoso (30% de falsos positivos aleatórios). O que o loop faz? Esta é a realidade de 2026 para a maioria das pilhas de guardrails.
3. Implemente uma variante de "gerador-crítico em modelos diferentes": um modelo grande gera e um modelo menor critica. Essa abordagem supera a de modelo único?
4. Leia a Seção 3 do CRITIC (arXiv:2305.11738 v4). Nomeie as três categorias de ferramentas de verificação e dê um exemplo para cada uma.
5. Mapeie o output_guardrails do OpenAI Agents SDK para a função de verificador do CRITIC. O que o SDK faz de errado e o que ele faz de correto?

Key Terms

Further Reading

• Madaan et al., Self-Refine (arXiv:2303.17651) — o artigo original
• Gou et al., CRITIC (arXiv:2305.11738) — verificação embasada em ferramentas
• Anthropic, Building Effective Agents — padrão de fluxo de trabalho evaluator-optimizer
• OpenAI Agents SDK docs — guardrails de saída como verificadores no estilo CRITIC