05-02-02 — Plan-and-Execute, reflection e self-correction

⏱ 12 minFontes validadas em: 2026-04-29

TL;DR

Plan-and-Execute separa planejamento de execução — um agente planeja tudo antes de agir, o que é mais eficiente para tarefas longas. Reflection faz o agente avaliar suas próprias respostas. Self-correction fecha o loop: o agente itera até a saída estar boa o suficiente.

Por que ir além do ReAct?

ReAct funciona bem para tarefas curtas. Para tarefas complexas com muitos steps independentes, ele é ineficiente: decide um passo de cada vez sem visão do todo. Plan-and-Execute resolve isso.

Plan-and-Execute

Dois agentes especializados:

Planner — recebe o objetivo e gera um plano com todos os steps antes de executar qualquer um.
Executor — executa cada step do plano, podendo re-planejar se encontrar obstáculos.

graph TD A[Objetivo: Análise de mercado de ERP para manufatura] --> B[PLANNER] B --> C["Plano:\n1. Listar top vendors ERP manufatura\n2. Analisar preços de cada um\n3. Comparar features\n4. Verificar casos de uso Vale/Michelin\n5. Sintetizar recomendação"] C --> D[EXECUTOR: Step 1] D --> E[EXECUTOR: Step 2] E --> F[EXECUTOR: Step 3] F --> G[EXECUTOR: Step 4] G --> H[EXECUTOR: Step 5] H --> I[Relatório final] D -.->|obstáculo encontrado| B style B fill:#1e40af,color:#fff style I fill:#065f46,color:#fff

Quando usar Plan-and-Execute: Tarefas com 5+ steps que podem ser paralelizados ou que têm dependências claras entre si. Research, análises, auditorias técnicas. Não faz sentido para tarefas simples — o overhead do planner não compensa.

Reflection

O agente avalia criticamente sua própria saída antes de entregá-la. Pode ser implementado como:

Self-critique: o mesmo LLM recebe sua resposta e uma rubrica de avaliação.
Critic agent: um segundo LLM avalia a saída do primeiro (mais caro, mais confiável).

graph LR A[Gera resposta] --> B[Reflection: avalia contra critérios] B --> C{Satisfatória?} C -->|Sim| D[Entrega ao usuário] C -->|Não| E[Identifica problemas] E --> F[Refina resposta] F --> B style D fill:#065f46,color:#fff style E fill:#7c2d12,color:#fff

Self-correction

Combinação de reflection com ação corretiva. O agente não apenas avalia — ele busca informação adicional ou reexecuta steps para corrigir.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o")

# Agente gerador
generator_prompt = ChatPromptTemplate.from_messages([
    ("system", "Você é um analista técnico. Responda a pergunta."),
    ("human", "{question}")
])

# Agente crítico (reflection)
critic_prompt = ChatPromptTemplate.from_messages([
    ("system", """Avalie a resposta abaixo com critérios:
    1. Factualmente correto?
    2. Completo?
    3. Claro para um CEO não-técnico?
    
    Responda com: APROVADO ou REVISAR: [motivo específico]"""),
    ("human", "Pergunta: {question}\nResposta: {answer}")
])

def self_correcting_agent(question: str, max_iterations: int = 3) -> str:
    answer = None
    for i in range(max_iterations):
        # Gera ou refina resposta
        if answer is None:
            answer = (generator_prompt | llm).invoke({"question": question}).content
        else:
            refine_prompt = f"Pergunta: {question}\nResposta anterior: {answer}\nProblemas: {critique}\nRefine a resposta."
            answer = llm.invoke(refine_prompt).content
        
        # Avalia
        critique = (critic_prompt | llm).invoke({
            "question": question, 
            "answer": answer
        }).content
        
        if critique.startswith("APROVADO"):
            return answer
    
    return answer  # Retorna melhor versão após max_iterations

Reflexion (Shinn et al. 2023): Paper que formalizou o padrão de reflection em agentes. O agente mantém um "episodic memory" das tentativas anteriores e usa esse histórico para não repetir os mesmos erros em runs futuras.

Comparativo dos padrões

Padrão	Melhor para	Custo relativo	Complexidade
ReAct	Tarefas curtas e diretas	💛 Médio	Baixa
Plan-and-Execute	Tarefas longas com muitos steps	💛 Médio-alto	Média
Reflection	Alta qualidade, baixa tolerância a erro	🔴 Alto	Média
Self-correction	Geração de código, documentação crítica	🔴 Alto	Alta

Custo de reflexão: Cada ciclo de reflection dobra (ou mais) o custo de tokens. Em produção, limite os ciclos (max 2-3) e defina critérios de aceitação objetivos — "bom o suficiente" definido por rubrica é melhor que loops abertos.

Como isso se conecta

05-02-01 — ReAct é o padrão base sobre o qual Plan-and-Execute é construído.
05-04-03 — Anthropic descreve evaluator-optimizer como padrão de reflection em escala.
05-03-01 — Multi-agent: o critic agent de reflection pode ser um agente separado num sistema multi-agent.

Fontes

Wang et al. — "Plan-and-Solve Prompting" (2023) — base acadêmica do padrão Plan-and-Execute.
Shinn et al. — "Reflexion: Language Agents with Verbal Reinforcement Learning" (2023) — paper fundacional sobre reflection em agentes.
LangGraph — Plan-and-Execute tutorial — implementação prática com LangGraph.
LangChain Blog — Reflection Agents (2024) — patterns de reflection com exemplos de código.