2026-01-31 · Atualizado 2026-07-14

[!NOTE] Tradução automática Este artigo foi traduzido automaticamente a partir da versão original em inglês.

AI Laços de Raciocínio de Agente em 2026: ReAct vs ReWOO vs Planeamento e Execução

Parte 1 da série de engenharia da pilha Agentic

Um agente reasoning loop determina a forma como um sistema planeia as suas ações, invoca ferramentas, analisa os resultados e decide o momento de interromper o processo. Esse fluxo de controlo influencia diretamente os custos, o tempo de resposta e a capacidade de recuperação em caso de retorno inesperado por parte de uma ferramenta.

Este artigo compara os três padrões AI agent loop que são essenciais de se conhecer em 2026: ReAct, ReWOO e Plan-and-Execute. O exemplo em funcionamento é um Agente Analista de Mercado que desenvolvi no LangGraph, sendo que o código completo encontra‑se no GitHub.

Trata‑se da camada interna da série. As partes seguintes adicionam o estado a partir do qual o ciclo é retomado, as ferramentas que podem ser chamadas, a política que rege essas chamadas, o runtime que mantém uma execução ativa, e o harness que realiza as verificações para determinar se o trabalho foi realmente concluído.

TL;DR: ReAct é flexível, mas dispendioso; o ReWOO é rápido quando o fluxo de trabalho é previsível, enquanto o método Plan-and-Execute é adequado para análises com várias etapas. Um agente AI em produção consegue alternar entre ciclos de raciocínio por pedido, recorrendo a estado partilhado e a nós LangGraph com pontos de verificação, de modo a que cada tarefa utilize o ciclo mais adequado ao seu formato.

O ciclo controla o custo, a latência e a recuperação

Um agente útil requer mais do que um bom prompt. O seu grafo de controlo deve ligar o raciocínio, as ferramentas e a memória, ao mesmo tempo que gere falhas.

O reasoning loop controla o momento em que o modelo planeia, efetua uma chamada a uma ferramenta, lê o resultado e para. Uma escolha inadequada gera chamadas desnecessárias ao modelo e aumenta a latência. Além disso, pode impedir que o agente se recupere de um tool result inesperado.

Três padrões de raciocínio de agente AI

ReAct: pensar, agir, observar, repetir

ReAct (Yao et al., 2022) representa o padrão original para agentes interativos. Este modelo executa um ciclo:

1. Pensamento: o agente gera um “pensamento” para decompor o objetivo e planear o próximo passo.
2. Ação: com base nesse pensamento, ele utiliza uma ferramenta.
3. Observação: o agente analisa o resultado, o que atualiza a sua compreensão para o próximo pensamento.

Vantagens:

• A baseação em observações reais reduz a ocorrência de factos inventados.
• O agente consegue alterar a sua estratégia em tempo real, com base no que acaba de observar.
• O histórico de chamadas de ferramentas e de observações fornece um registo de execução concreto.

Desvantagens:

• A história é acumulada e reprocessada a cada passo, pelo que a latência e o custo aumentam à medida que o comprimento do ciclo cresce.
• É um desperdício quando o tool calls poderia ter sido planeado com antecedência, sendo exatamente essa a área de atuação da ReWOO.
• Sem uma condição de paragem ou limite de passos, o ciclo irá continuar a executar‑se indefinidamente.

Ideal para: tarefas exploratórias, depuração, situações em que não é possível prever o que acontecerá a seguir.

ReWOO: planeie tudo com antecedência

ReWOO (Raciocínio Sem Observação) é uma versão mais eficiente do ReAct. A estratégia consiste em dissociar o raciocínio da execução de ferramentas: em vez de interromper o processo para observar cada ação, o ReWOO planeia toda a sequência de tool calls numa única passagem.

1. Plano: uma chamada LLM grava o plano completo de tool calls, utilizando placeholders de variáveis (#E1, #E2) para resultados que ainda não existem.
2. Worker: um executor que não é o LLM executa as ferramentas planeadas sequencialmente ou em paralelo, preenchendo os placeholders.
3. Solver: uma chamada final ao LLM utiliza as observações recolhidas para gerar a resposta.

Vantagens:

• Menos chamadas repetidas ao modelo em comparação com ReAct, desde que o plano inicial continue válido.
• Latência reduzida. Não é necessário submeter novamente o histórico a cada passo.
• O planeador pode ser ajustado detalhadamente de forma independente, sem necessidade de um ambiente em tempo real.

Desvantagens:

• Frágil quando as ferramentas apresentam comportamentos imprevistos. O plano pressupõe que tudo funcione corretamente.
• Exige fluxos de trabalho previsíveis.
• Sem uma lógica de fallback explícita, um plano defeituoso continua a ser executado.

Ideal para: capturas rápidas, verificações de estado, painéis de controlo. Em qualquer cenário em que as ferramentas apresentem comportamento previsível.

Planeamento e Execução: um modelo híbrido

Planeamento e Execução encontra‑se entre os dois. O artigo descreve uma divisão simples que a maioria dos agentes modernos adotou:

1. Fase de planeamento: o agente gera primeiro um plano que divide a tarefa em sub-tarefas menores.
2. Fase de execução: em seguida, o agente executa essas sub-tarefas.

O artigo original focava no prompting de zero-shot. Ferramentas modernas frameworks como o LangGraph desenvolveram essa abordagem até transformá‑la num padrão completo de orquestração, que inclui execução sequencial e seleção de modelo a cada passo (um modelo de raciocínio avançado para o planeamento e um modelo mais económico para a execução).

Vantagens:

• Raciocínio hierárquico que replica a forma como um especialista humano descompõe um projeto.
• É possível replanificar. Pode-se pausar e reavaliar a situação caso o resultado de uma etapa seja inesperado.
• Especialização do modelo. O planeador pode ser dispendioso, enquanto o executor pode ser económico.
• Complexidade delimitada, com um checkpoint claro após cada etapa.

Desvantagens:

• Latência superior à do ReWOO, uma vez que as etapas são executadas sequencialmente.
• Maior quantidade de estado a gerir.
• Excesso de recursos para consultas únicas.

Ideal para: análises complexas em vários passos, tarefas de investigação e qualquer cenário que exija síntese no final.

Escolha com base em onde o plano pode falhar

A tabela representa um ponto de partida, e não um benchmark resultado final. Deve‑se utilizar ReAct sempre que cada observação possa influenciar a ação subsequente. O método Plan-and-Execute é adequado quando a tarefa como um todo pode ser desmembrada, mas os passos individuais ainda necessitam de feedback. Já o ReWOO é indicado quando as dependências são conhecidas antes da execução e um dado inválido pode interromper as chamadas subsequentes. Antes de se decidir apenas com base no custo, é necessário avaliar todos estes três métodos tendo em conta a latência da ferramenta, o modelo, o conjunto de tarefas e a política de tentativas repetidas.

Um exemplo prático: o Agente Analista de Mercado

Para tornar isto concreto, construí um Agente de Análise de Mercado que utiliza todos os três padrões numa única base de código, num projeto de investigação de mercado.

Utiliza LangGraph para orquestração. Os três padrões partilham o mesmo objeto de estado, permitindo que o router escolha qual deles executar para cada pedido:

Definição de estado

O estado partilhado captura tudo o que o agente necessita entre os diferentes modos:

class PlanStep(BaseModel):
    """A single step in the research plan."""
    step_number: int
    description: str
    tool_hint: str | None = None
    completed: bool = False
    result: str | None = None

class UserProfile(BaseModel):
    """Structured user context loaded from long-term memory."""
    risk_tolerance: str | None = None
    investment_horizon: str | None = None

class AgentState(BaseModel):
    """Main state for the Market Analyst Agent graph."""

    # Identity and profile context for memory-backed personalization
    user_id: str
    user_profile: UserProfile = Field(default_factory=UserProfile)

    # Message history with LangGraph's add_messages reducer
    messages: Annotated[list, add_messages] = Field(default_factory=list)

    # Execution mode (set by router)
    execution_mode: ExecutionMode | None = None

    # Plan-and-Execute state
    plan: list[PlanStep] = Field(default_factory=list)
    current_step_index: int = 0

    # ReWOO state
    rewoo_plan: list[ReWOOPlanStep] = Field(default_factory=list)

    # Research results
    research_data: ResearchData | None = None

    # HITL output
    draft_report: DraftReport | None = None
    report_approved: bool = False

Padrão 1: Implementação de tipo planeie-e-execute

O padrão Plan-and-Execute é a solução ideal para tarefas que exigem síntese em vários passos. A chave está em manter o planeamento e a execução separados: um modelo robusto para a elaboração inicial do plano, seguido de um ciclo ReAct que permite executar cada etapa com margem para react até tool results.

Como se alinha com o padrão:

1. Uma única fase de planeamento inicial. Uma única chamada a LLM gera todo o plano na forma de uma lista de descrições de passos.
2. Saída orientada por esquema, que valida o plano antes da sua execução.
3. Ainda não há execução de ferramentas. O planeador apenas decide o que fazer, e não como.
4. Passos legíveis por humanos. Cada passo é um texto que será interpretado pelo executor.

# System prompt guides the LLM to think like a research analyst
# creating a strategic plan, not immediate tool calls
PLANNER_SYSTEM_PROMPT = """You are a senior investment research analyst.
Break down stock analysis requests into 4-6 research steps covering:
1. Current price and basic metrics
2. Recent news and announcements
3. Competitor analysis (if relevant)
4. Financial health assessment
5. Risk factors
6. Investment thesis synthesis

Output as JSON with step_number, description, and tool_hint."""

# Schema-Guided Reasoning: Enforce structure with Pydantic
class PlanOutput(BaseModel):
    """Structured output for the planner."""

    steps: list[PlanStep] = Field(description="Research steps to execute")
    ticker: str = Field(description="The stock ticker being analyzed")

def planner_node(state: AgentState) -> dict:
    """Generate a research plan from the user's request.

    This is Phase 1 of Plan-and-Execute: creating the high-level strategy.
    """

    # Use a powerful model for strategic planning
    llm = ChatAnthropic(model="claude-sonnet-4-5-20250929", temperature=0)

    # Ask for a typed plan and validate it before execution.
    # The API can still fail, so production code also handles that exception.
    structured_llm = llm.with_structured_output(PlanOutput)

    # Context from long-term memory personalizes the plan
    profile_context = f"""
User Profile:
- Risk Tolerance: {state.user_profile.risk_tolerance}
- Investment Horizon: {state.user_profile.investment_horizon}
"""

    # Single LLM call creates the complete plan
    result: PlanOutput = structured_llm.invoke([
        SystemMessage(content=PLANNER_SYSTEM_PROMPT + profile_context),
        HumanMessage(content=f"Create a research plan for: {last_user_message}"),
    ])

    # State update: Store the plan and initialize tracking
    return {
        "plan": result.steps,           # The sequential steps to execute
        "current_step_index": 0,        # Start at step 0
        "research_data": ResearchData(ticker=result.ticker),  # Initialize data container
    }

Esse llm.with_structured_output(PlanOutput) A linha em questão é o Raciocínio Orientado por Esquema (SGR), que abordei anteriormente. um artigo anterior. O esquema permite que a aplicação rejeite um plano mal formatado antes de o LangGraph utilizar os campos validados para gerar arestas condicionais.

Padrão 2: execução de ReAct

Assim que o plano estiver definido, o executor executa cada passo como uma loop ReAct independente. Esta é a Fase 2: cada passo é suficientemente pequeno para que o ciclo Pensamento-Ação-Observação mantenha a sua foco, permitindo ao agente react processar o resultado retornado pela ferramenta.

Como se alinha a parte ReAct:

1. Execução iterativa. Um passo de cada vez, com feedback baseado em observações.
2. O ciclo Pensamento-Ação-Observação é executado internamente create_react_agent3. Os resultados da etapa anterior são utilizados como contexto para o raciocínio atual.
3. O agente seleciona as ferramentas com base na descrição da etapa.
4. É possível alterar a abordagem a meio da etapa, dependendo do que uma ferramenta retorna.

# Tools available for the ReAct agent to choose from
TOOLS = [
    get_stock_snapshot,
    get_price_history,
    search_news,
    search_competitors,
    get_financials,
]

def executor_node(state: AgentState) -> dict:
    """Execute the current step using a ReAct agent.

    This is Phase 2 of Plan-and-Execute: adaptive execution of each planned step.
    Each step runs as a mini ReAct loop until completion.
    """

    # Get the current step from the plan
    current_step = state.plan[state.current_step_index]

    # Build context from what we've learned so far
    # This matters: each step builds on previous observations
    previous_context = ""
    for step in state.plan[:state.current_step_index]:
        if step.result:
            previous_context += f"\nStep {step.step_number}: {step.result}\n"

    # Create a ReAct agent for this step
    # LangGraph's create_react_agent implements the full Thought-Action-Observation loop:
    # 1. Agent generates a "thought" about what tool to call
    # 2. Agent calls the tool ("action")
    # 3. Tool returns result ("observation")
    # 4. Agent decides: call another tool or finish
    react_agent = create_react_agent(
        model=ChatAnthropic(model="claude-sonnet-4-5-20250929"),
        tools=TOOLS,
    )

    # Invoke the ReAct loop for this single step
    # The agent will loop internally until it completes the step
    result = react_agent.invoke({
        "messages": [
            SystemMessage(content=EXECUTOR_SYSTEM_PROMPT),
            HumanMessage(content=f"""Execute Step {current_step.step_number}:
{current_step.description}

Ticker: {state.research_data.ticker}
Previous findings: {previous_context}"""),
        ]
    })

    # Extract the final answer from the ReAct agent's message history
    # The last message contains the synthesis after all tool calls
    updated_plan = list(state.plan)
    updated_plan[state.current_step_index] = PlanStep(
        step_number=current_step.step_number,
        description=current_step.description,
        completed=True,
        result=result["messages"][-1].content,  # Final observation
    )

    # State update: Mark step complete and advance to next
    return {
        "plan": updated_plan,
        "current_step_index": state.current_step_index + 1,
    }

Esse é o fluxo central de Planeamento e Execução: um modelo avançado elabora o plano e, em seguida, ReAct executa cada passo com total capacidade de adaptação.

Padrão 3: ReWOO para capturas rápidas

Para briefings rápidos, o ReWOO omite o raciocínio intercalado e executa as ferramentas em paralelo. O planeador emite um script compilado de tool calls desde o início, e o worker executa-o sem qualquer tipo de intervenção adicional de LLM.

A sua forma:

1. Três fases (Planner → Worker → Solver), sem laços.
2. Referência Tool calls #E1, #E2 placeholders para resultados que ainda não existem.
3. Não há LLM durante a execução. O worker apenas executa as ferramentas.
4. As ferramentas independentes são executadas em paralelo.
5. Uma chamada de síntese no final, processando todos os dados de uma só vez.

Fase 1: Planeador ReWOO (cria o grafo de execução completo desde o início)

class ReWOOPlanStep(BaseModel):
    """A step in the ReWOO plan with variable placeholders.

    Key difference from Plan-and-Execute's PlanStep:
    - Contains actual tool_name and tool_args (not just description)
    - Uses variable references (#E1) for dependencies
    """
    step_id: str  # e.g., "#E1" - becomes a variable
    description: str
    tool_name: str     # Exact tool to call
    tool_args: dict    # May contain variable refs like {"price": "#E1"}
    depends_on: list[str] = []  # For dependency ordering
    result: str | None = None

class ReWOOPlanOutput(BaseModel):
    """Structured output for ReWOO planner."""
    steps: list[ReWOOPlanStep] = Field(description="Planned tool calls with variables")

def rewoo_planner_node(state: AgentState) -> dict:
    """Generate a complete plan of tool calls upfront.

    This is the key difference from Plan-and-Execute: instead of creating
    human-readable step descriptions, we create EXACT tool calls that
    the worker will execute blindly.
    """

    llm = ChatAnthropic(model="claude-sonnet-4-5-20250929", temperature=0)

    # Schema-Guided Reasoning ensures valid tool call specifications
    structured_llm = llm.with_structured_output(ReWOOPlanOutput)

    ticker = state.research_data.ticker if state.research_data else "UNKNOWN"

    # Single LLM call to plan ALL tool executions
    result: ReWOOPlanOutput = structured_llm.invoke([
        SystemMessage(content=REWOO_PLANNER_PROMPT),
        HumanMessage(content=f"""Create a ReWOO plan for: {query}

Ticker: {ticker}

Output tool calls with:
- step_id: Variable name (#E1, #E2, etc.)
- description: What this accomplishes
- tool_name: Exact tool from the list
- tool_args: Dictionary of arguments
- depends_on: List of step_ids this depends on"""),
    ])

    # State update: Store the complete execution plan
    # Worker will execute this without any LLM involvement
    return {"rewoo_plan": result.steps}

Fase 2: Trabalhador ReWOO (executa ferramentas sem raciocínio LLM)

def rewoo_worker_node(state: AgentState) -> dict:
    """Execute all planned tools in parallel (no LLM calls).

    This is the key efficiency: Worker is "dumb" - it just runs tools
    according to the plan. No LLM calls = massive token savings.
    """

    results = {}  # Store results keyed by step_id (e.g., "#E1": "$150.23")

    # Execute ALL independent steps in parallel using ThreadPoolExecutor
    # This is where ReWOO gets its speed advantage
    with ThreadPoolExecutor(max_workers=5) as executor:
        futures = {
            executor.submit(execute_tool, step): step
            for step in state.rewoo_plan
            if not step.depends_on  # Only independent tools for parallel batch
        }

        # Collect results as they complete
        for future in as_completed(futures):
            step = futures[future]
            results[step.step_id] = future.result()
            # No LLM reasoning here - just store the raw tool output

    # State update: Store results for the Solver phase
    return {"rewoo_plan": updated_steps}

Fase 3: Solucionador ReWOO (sintetiza todos os resultados numa única chamada LLM)

def rewoo_solver_node(state: AgentState) -> dict:
    """Synthesize all tool results into a flash briefing.

    This is the second efficiency gain: Instead of interleaving
    LLM calls with tool execution (like ReAct), we make ONE
    final synthesis call with all gathered data.
    """

    # Build context from ALL tool results at once
    tool_results = []
    for step in state.rewoo_plan:
        if step.result:
            tool_results.append(f"### {step.description}\n{step.result}")

    context = "\n\n".join(tool_results)

    # Single LLM call to synthesize everything
    structured_llm = llm.with_structured_output(FlashBriefingOutput)
    result = structured_llm.invoke([
        SystemMessage(content=REWOO_SOLVER_PROMPT),
        HumanMessage(content=f"Create a flash briefing from this data:\n\n{context}"),
    ])

    return {"draft_report": result}

ReWOO planeia cada tool call com antecedência e armazena as dependências em placeholders como #E1 e #E2O executor pode executar chamadas independentes em paralelo, sem precisar perguntar ao modelo qual é a próxima ação a ser realizada. Uma última chamada ao modelo combina os resultados obtidos, o que permite manter fluxos de trabalho previsíveis a um custo reduzido.

Onde cada padrão chama o modelo

Os três padrões diferem em termos de quando e como eles chamam o LLM:

O que difere entre eles é o que o planeador produz. É isso que determina tudo no fluxo posterior.

1. O Plan-and-Execute gera descrições de passos legíveis por humanos:

   # Planner output (list of PlanStep objects)
   plan = [
       PlanStep(
           step_number=1,
           description="Get current price and key financial metrics",
           tool_hint="get_stock_price"
       ),
       PlanStep(
           step_number=2,
           description="Search for recent news and earnings",
           tool_hint="search_news"
       ),
       # ... more steps
   ]

   O executor lê cada descrição e decide quais ferramentas devem ser chamadas. É flexível, mas custa uma chamada de LLM por passo.

2. ReAct não dispõe de um plano inicial. Ele recorre a um raciocínio iterativo:

   # No planning phase - ReAct works step-by-step with accumulated messages
   messages = [
       HumanMessage(content="Execute Step 1: Get current price"),
       AIMessage(content="I'll call get_stock_price"),
       ToolMessage(tool_call_id="1", content="$132.45"),
       AIMessage(content="Now I need metrics..."),
       # ... agent continues until step complete
   ]

   Várias chamadas de LLM por passo adaptam‑se às observações e, geralmente, têm um custo superior aos dois modos planeados.

3. O ReWOO gera especificações claras e executáveis de tool call:

   # Planner output (list of ReWOOPlanStep objects)
   rewoo_plan = [
       ReWOOPlanStep(
           step_id="#E1",
           tool_name="get_stock_price",
           tool_args={"ticker": "NVDA"}
       ),
       ReWOOPlanStep(
           step_id="#E2",
           tool_name="search_news",
           tool_args={"query": "NVDA earnings", "limit": 5}
       ),
       # ... all tool calls planned upfront
   ]

   O agente executa as tarefas de forma autónoma, sem qualquer intervenção de LLM. Todas as chamadas ao modelo são geridas pelo planeador e pelo resolvedor, o que torna possível prever o número total de tais chamadas.

Fluxo de memória e estado:

• Planeamento e Execução: o estado percorre as etapas plan → current_step_index → research_data.
• ReAct: o estado acumula-se no messages array (o histórico completo da conversa).
• ReWOO: o estado evolui ao longo rewoo_plan, com result campos preenchidos pelo operador.

Integrando tudo: ligação do grafo

Aqui está como os três padrões coexistem num único sistema LangGraph. Eles partilham um AgentState e residem num único grafo. Um roteador seleciona o caminho para cada pedido; portanto, trata‑se de um agente com três modos de execução, e não de três agentes agindo de forma isolada.

O LangGraph mantém a configuração da arquitetura de forma declarativa:

def create_graph(checkpointer=None):
    builder = StateGraph(AgentState)

    # Add nodes
    builder.add_node("router", router_node)
    builder.add_node("planner", planner_node)
    builder.add_node("executor", executor_node)
    builder.add_node("reporter", reporter_node)
    builder.add_node("rewoo_planner", rewoo_planner_node)
    builder.add_node("rewoo_worker", rewoo_worker_node)
    builder.add_node("rewoo_solver", rewoo_solver_node)

    # Define edges
    builder.add_edge(START, "router")
    builder.add_conditional_edges("router", route_after_router, {
        "planner": "planner",
        "rewoo_planner": "rewoo_planner",
    })

    # Deep Research path
    builder.add_edge("planner", "executor")
    builder.add_conditional_edges("executor", route_after_executor, {
        "executor": "executor",  # Loop back for more steps
        "reporter": "reporter",  # Done with plan
    })
    builder.add_edge("reporter", END)

    # Flash Briefing path (ReWOO)
    builder.add_edge("rewoo_planner", "rewoo_worker")
    builder.add_edge("rewoo_worker", "rewoo_solver")
    builder.add_edge("rewoo_solver", END)

    return builder.compile(
        checkpointer=checkpointer,
        interrupt_before=["reporter"],  # HITL pause for approval
    )

Seleção automática de padrões com um router

Para selecionar o ciclo adequado para cada pedido, adicionei um classificador de roteador. Este utiliza o Reasoning Guiado por Esquema para garantir a fiabilidade da classificação:

class ExecutionMode(str, Enum):
    """Execution mode for the agent."""

    DEEP_RESEARCH = "deep_research"  # Plan-and-Execute + ReAct (thorough)
    FLASH_BRIEFING = "flash_briefing"  # ReWOO (fast, token-efficient)

class RouterOutput(BaseModel):
    """Structured output for the router."""

    mode: ExecutionMode  # DEEP_RESEARCH or FLASH_BRIEFING
    ticker: str
    reasoning: str

ROUTER_SYSTEM_PROMPT = """Classify the user's request:

1. **deep_research**: Complex analysis requiring synthesis
   - Examples: "Analyze strategic risks", "investment thesis"

2. **flash_briefing**: Quick snapshots, simple data retrieval
   - Examples: "quick snapshot", "current price"

Default to deep_research if unclear."""

structured_llm = llm.with_structured_output(RouterOutput)

Com isto implementado, os utilizadores não precisam de selecionar um modo. O router encaminha automaticamente o “preço atual” para a ReWOO e a “tese de investimento” para o Plan-and-Execute.

Principais conclusões

1. ReAct fornece os pontos de feedback mais frequentes, ao custo de chamadas repetidas ao modelo.
2. O ReWOO reduz as viagens de ida e volta do modelo quando as ferramentas são fiáveis e as dependências são previsíveis.
3. O método Plan-and-Execute é adequado para análises complexas que podem ser decompostas antes da execução, mas que ainda necessitam de feedback a cada passo.
4. Um router pode escolher entre estas abordagens por pedido, evitando assim que os utilizadores tenham de o fazer.
5. O ciclo requer estado armazenado para sobreviver a interrupções ou reinícios dos workers. Esse é o tema da Parte 2.

A implementação completa, incluindo o router e o estado partilhado, encontra-se em Repositório de Agentes de Analista de Mercado.

A próxima camada é a memória

Parte 2, AI Arquitetura de Memória de Agente em 2026, isola o checkpoints recuperável dos conhecimentos entre sessões e dos documentos de projeto. Sem essa camada de estado, o roteador e o executor acima funcionam apenas enquanto um processo e uma janela de contexto permanecem ativos.

Referências

• ReAct: Sinergizar o Raciocínio e a Ação em Modelos de Língua (Yao et al., 2022) ReWOO: Desacoplamento do Raciocínio das Observações para Modelos de Linguagem Aumentados Eficientes (Xu et al., 2023)
• Prompting de Planeamento e Resolução: Melhorar o Raciocínio Zero-Shot Chain-of-Thought por Modelos de Língua Grande (Wang et al., 2023) Repositório de Agentes de Análise de Mercado

O código do Agente Analista de Mercado encontra-se em GitHub se quiser seguir a leitura.

Série: Engenharia da pilha Agentic

• Parte 1: AI Laços de Raciocínio de Agente em 2026 (este artigo) Parte 2: AI Arquitetura de Memória de Agente em 2026 — checkpoints, armazenamentos vetoriais e memória de documentos Parte 3: AI Agente Tool Use em 2026 — MCP, CLI, competências, execução de código e ACI Parte 4: AI Segurança de Agentes em 2026 — restrições de segurança, permissões, sandboxes, HITL e delimitação de escopo de MCP
• Parte 5: Agente AI de execução contínua Runtime em 2026 — sessões, sandboxes, checkpoints, mecanismos de aproveitamento e formatos de implementação
• Parte 6: Harness Engineering para Agentes AI (a seguir) — verificações de aceitação, rastreios, tentativas repetidas, transferências de responsabilidade e o ciclo associado ao modelo