Agentes de IA: como funciona o ReAct Loop e por que ele é essencial

Se você já se perguntou como agentes de IA conseguem resolver tarefas complexas que exigem múltiplas etapas e decisões condicionais, a resposta está em um mecanismo chamado ReAct loop (Reason + Act). Neste tutorial prático, vamos entender como esse loop funciona e por que ele é a peça central da maioria dos agentes de IA modernos.

Em um artigo anterior da mesma autora, vimos como funciona o Tool Calling — o mecanismo que permite a um modelo decidir qual função chamar e com quais argumentos. Mas o Tool Calling básico resolve apenas tarefas em que todas as chamadas de ferramenta podem ser planejadas de antemão. Quando o resultado de uma chamada determina se (e como) a próxima deve acontecer, entramos no território do ReAct loop.

O que é um ReAct loop?

O ReAct loop é um ciclo de três passos repetidos em sequência:

1. Reason (Raciocinar): O modelo avalia o que já sabe e o que ainda precisa descobrir para responder corretamente.
2. Act (Agir): O modelo chama uma ferramenta apropriada para obter a informação que está faltando.
3. Observe (Observar): O resultado da ferramenta é adicionado ao contexto do modelo.

O loop então recomeça: com a nova observação em seu contexto, o modelo raciocina novamente, decide se precisa de mais informação, age novamente se necessário, e assim por diante — até ter tudo que precisa para dar a resposta final.

Quando o ReAct loop é necessário?

Imagine esta pergunta: “Apostei com meu amigo 100 EUR que choveria em Atenas hoje. Se eu ganhei, quantos dólares são?”

Aqui, o modelo não pode decidir se precisa converter moeda antes de saber se choveu. Se não choveu, a aposta foi perdida e não há conversão alguma a fazer. Se choveu, aí sim é preciso converter 100 EUR para USD. Esta é exatamente a classe de dependência condicional que o Tool Calling paralelo não resolve — e onde o ReAct loop brilha.

Implementação prática em Python

O código é surpreendentemente simples. Usando a API da OpenAI, o loop principal tem esta estrutura:

messages = [{"role": "user", "content": "I bet my friend 100 EUR..."}]
max_iterations = 5

for i in range(max_iterations):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )
    message = response.choices[0].message
    messages.append(message)
    
    # Se não há tool call, o modelo está pronto para responder
    if not message.tool_calls:
        print(message.content)
        break
    
    # Executa cada tool call e adiciona o resultado
    for tool_call in message.tool_calls:
        func = available_functions[tool_call.function.name]
        result = func(**json.loads(tool_call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

As funções usadas no exemplo são get_current_weather (via Open-Meteo, sem API key) e convert_currency (via Frankfurter, também sem API key).

O loop em ação: dois cenários

Cenário 1 — Choveu em Atenas:

• Passo 1: Reason → Act (get_current_weather) → Observe: precipitação de 3.2mm
• Passo 2: Reason → Act (convert_currency) → Observe: 100 EUR = 108.50 USD
• Passo 3: Reason → resposta final: “Choveu em Atenas hoje. Você ganhou 108.50 USD.”

Cenário 2 — Não choveu em Atenas:

• Passo 1: Reason → Act (get_current_weather) → Observe: precipitação de 0.0mm
• Passo 2: Reason → resposta final: “Não choveu. Você perdeu a aposta.” (sem chamar convert_currency!)

Note a diferença crucial: no cenário 2, o modelo decidiu sozinho não chamar a segunda ferramenta. Ninguém programou essa decisão — ela emergiu do raciocínio do modelo baseado na observação.

Quando usar ReAct vs. Tool Calling paralelo?

Use ReAct loop quando:

• O resultado de uma chamada determina se outra é necessária
• Os argumentos de uma chamada dependem do resultado de uma chamada anterior
• Resultados inesperados exigem adaptação do plano (cidade não encontrada, erro de API)

Use Tool Calling paralelo quando:

• Todas as ferramentas e argumentos são conhecidos de antemão
• As chamadas são independentes entre si
• Latência é crítica e você quer minimizar round-trips

Por que isso importa

O que torna o ReAct loop fascinante é a relação entre simplicidade de código e poder de execução. Um for loop, um if e um dicionário de funções são tudo que separa um sistema de Tool Calling básico de um agente capaz de raciocinar, adaptar-se e decidir seus próximos passos com base em informações que ele nem sabia que existiam momentos antes.

Este mecanismo, em uma forma ou outra, é o coração do que a indústria chama de “agentes de IA”. Entender o ReAct loop é entender como agentes tomam decisões em ambientes com informação incompleta — uma habilidade cada vez mais central no desenvolvimento de aplicações com IA.