O que é um agente de IA (e o que é só um wrapper de prompt)

Abre o LinkedIn. Conta quantos "AI Agents" passam no seu feed antes do café esfriar. Agora pega cada um e pergunta: cadê o loop? Cadê a memória? Na prática, 90% do que vendem como agente é um if com esteroides — uma chamada de API embrulhada num prompt bonito, com um botão por cima.

Não é implicância. É vocabulário. Quando todo mundo chama qualquer coisa de "agente", a palavra para de significar algo, e você acaba pagando caro por uma arquitetura que não precisava — ou pior, esperando autonomia de um sistema que nunca foi montado pra isso.

Então vamos resolver isso de uma vez. Este post é a definição honesta de o que é um agente de IA: o loop que define o comportamento e os quatro blocos mínimos que ele precisa ter. Faltar um desses blocos é exatamente o que faz o seu "agente" virar burro depois da terceira mensagem.

TL;DR

• O que é: um sistema onde o LLM dirige o próprio processo — decide qual ação tomar, executa via ferramentas e observa o resultado antes do próximo passo, em loop.
• O que NÃO é: uma chamada única de LLM com prompt caprichado. Isso é um wrapper. Útil, mas não é agente.
• Os 4 blocos mínimos: modelo, ferramentas, memória e orquestração. Tire um e o sistema desmonta.
• Quando vale a pena: só quando a tarefa é aberta o bastante pra justificar a autonomia. Agente troca latência e custo por flexibilidade — nem sempre o trade vale.

O loop que separa agente de chatbot: percepção → decisão → ação → observação

A ideia de agente não nasceu com o ChatGPT. Em 1995, Russell e Norvig já definiram agente no livro-texto da área como "qualquer coisa que pode ser vista percebendo seu ambiente através de sensores e agindo sobre esse ambiente através de atuadores". Trinta anos depois, os LLMs só trocaram os sensores e atuadores por contexto e chamadas de ferramenta. O esqueleto é o mesmo.

Esse esqueleto é um ciclo:

percepção  → o que está acontecendo? (input do usuário + estado + resultado da última ação)
decisão    → qual o próximo passo? (o modelo raciocina e escolhe)
ação       → executa (chama uma ferramenta, roda código, consulta uma API)
observação → o que voltou do mundo real? (resultado da ferramenta, erro, novo estado)
            ↑__________________ repete até concluir __________________|

A Anthropic descreve o mesmo ciclo no Building Effective Agents: o agente começa com a instrução do usuário, planeja por conta própria, executa ações, recebe resultado real do ambiente a cada passo e avalia o progresso — podendo parar pra pedir ajuda quando trava. O detalhe que muda tudo é "a cada passo". O agente não cospe uma resposta e some. Ele age, olha o que voltou e decide de novo.

É isso que separa um agente de IA de um chatbot. O chatbot percebe e responde — uma volta só, sem fechar o ciclo com o mundo. O agente fecha o ciclo: a observação do passo anterior vira a percepção do próximo. O Agents SDK da OpenAI implementa exatamente isso — roda o modelo em loop, executa as chamadas de ferramenta, devolve os resultados pro modelo e repete até atingir um critério de parada. Sem loop, não há agente. Tem só uma chamada de função com marketing em cima.

Os 4 blocos mínimos de um agente de IA

A Anthropic chama de "LLM aumentado" o tijolo básico de qualquer sistema agêntico: o modelo equipado com recuperação, ferramentas e memória. A OpenAI lista o agente como modelo + ferramentas + instruções. Juntando as duas visões e separando o que cada peça faz na prática, dá pra cravar quatro blocos. Tire qualquer um e o sistema deixa de ser agente — ou vira um agente burro.

1. Modelo — o cérebro que decide

É o LLM que faz o raciocínio: lê o estado atual e decide o próximo passo. Sem um modelo capaz de decidir, você não tem agente, tem um fluxograma. Mas atenção: modelo não é o agente. É só o bloco que toma decisão dentro do loop.

Dica de produção: você não precisa do modelo mais caro pra tudo. A própria OpenAI recomenda misturar modelos — um menor e rápido pra classificar intenção ou rotear, um mais forte pra raciocínio pesado. Pôr Opus pra decidir "isso é uma saudação?" é queimar dinheiro.

2. Ferramentas — as mãos que agem

Modelo sozinho só gera texto. Ferramenta é o que deixa ele agir no mundo: consultar um banco, chamar uma API, rodar uma query, disparar um e-mail, executar código. É o atuador do Russell e Norvig com outro nome.

Aqui mora a primeira morte do "agente de LinkedIn": ele não tem ferramenta nenhuma. Só responde texto. Um agente de verdade tem ações concretas, cada uma com contrato claro de entrada e saída — porque é o resultado da ferramenta que alimenta a próxima observação do loop.

3. Memória — o que evita o Alzheimer na terceira mensagem

Esse é o bloco que quase todo mundo esquece, e é o que faz o wrapper desmoronar. Tem dois tipos:

• Memória de curto prazo: o histórico da conversa/tarefa que cabe na janela de contexto. É o que mantém coerência dentro de uma execução.
• Memória de longo prazo: estado que persiste entre execuções — num banco, num vector store, num arquivo. É o que faz o agente lembrar de você amanhã.

Sem memória, cada passo do loop começa do zero. O sistema repete pergunta, perde o fio, contradiz o que falou. É literalmente o "agente" que vira burro depois da terceira mensagem: não é o modelo que ficou ruim, é que ninguém deu memória pra ele.

4. Orquestração — o loop que amarra tudo

Os três blocos acima são peças soltas. Orquestração é o que faz elas girarem no ciclo percepção→decisão→ação→observação: quando chamar ferramenta, quando consultar memória, quando parar, quem aprova o quê, o que fazer quando uma ação falha.

E é aqui que a Anthropic crava a distinção mais importante: em workflow, o caminho é predefinido no código — você é dono do encanamento. Em agente, o modelo dirige o próprio processo — o modelo é dono do encanamento. Os dois são válidos. Mas só o segundo é, tecnicamente, um agente. Grau de autonomia não é detalhe; é a definição. Se quiser ver isso destrinchado em níveis, escrevi sobre os 4 níveis de autonomia em agentic code — do autocompletar ao agente que abre PR sozinho.

Agente de IA vs chatbot vs wrapper de prompt

Pra fechar o vocabulário, a régua honesta:

• Wrapper de prompt: uma chamada de LLM com um system prompt caprichado. Entra texto, sai texto. Zero ferramenta, zero loop, zero memória persistente. 90% dos "agents" do feed param aqui.
• Chatbot: wrapper + histórico da conversa. Percebe e responde, mantém contexto da sessão. Continua sem agir no mundo e sem fechar o loop com resultado de ação.
• Agente de IA: os quatro blocos juntos, rodando no loop. Decide, age via ferramenta, observa o resultado e decide de novo — com memória pra não se perder.

Não é hierarquia de qualidade. Wrapper bem-feito resolve um monte de problema com custo baixo e latência mínima. O erro é chamar o wrapper de agente e cobrar (ou esperar) autonomia que ele nunca vai ter.

Quando você NÃO precisa de um agente

Definir agente direito serve, principalmente, pra você não construir um quando não precisa. A Anthropic é explícita: ache "a solução mais simples possível e só aumente a complexidade quando ela melhora o resultado de forma demonstrável". Sistemas agênticos trocam latência e custo por performance na tarefa — e nem sempre o trade compensa.

Regra prática: se a tarefa tem um caminho previsível, é um workflow (ou um simples wrapper). Você ganha em custo, latência e previsibilidade. Agente só se justifica quando a tarefa é aberta o suficiente pra que valha deixar o modelo decidir os passos — e você topa pagar a conta de latência, custo e imprevisibilidade que vem junto. Já listei 8 cenários onde o agente é prejuízo se quiser os casos concretos.

FAQ rápido

Todo chatbot é um agente? Não. Chatbot percebe e responde, mas não fecha o loop agindo no mundo via ferramenta. Falta ação e observação. É o bloco "modelo + memória de curto prazo", sem ferramentas nem orquestração autônoma.

Preciso de framework (LangGraph, Agents SDK, Claude Agent SDK) pra ter um agente? Não. Framework ajuda a orquestrar, mas você monta o loop com um while e chamadas de ferramenta na mão. O que define o agente são os quatro blocos e o ciclo, não a lib.

Qual o erro nº 1 de quem está começando? Pular a memória e a orquestração. As pessoas grudam um modelo numa API, chamam de agente e se frustram quando ele se perde. O que faltou não foi um modelo melhor — foi memória e um loop de verdade.

RAG é um agente? Não necessariamente. RAG puro (busca + injeta no contexto + responde) costuma ser um workflow de caminho fixo. Vira agente quando o modelo decide sozinho quando e o que buscar, em loop, em vez de seguir um pipeline predefinido.

Conclusão: o vocabulário antes da arquitetura

Agente de IA não é hype nem palavra de pitch. É um sistema com quatro blocos — modelo, ferramentas, memória e orquestração — girando no loop percepção→decisão→ação→observação. Tire um bloco e você não tem um agente meia-boca; você tem um chatbot ou um wrapper com crachá trocado.

Esse vocabulário é a base. É a partir daqui que dá pra discutir as coisas que realmente importam: como dar memória que escala, como desenhar ferramentas seguras, quanta autonomia entregar e onde colocar o ser humano no loop. Saber montar esses blocos num produto real, com engenharia e não com gambiarra, é justamente o que a gente coloca na mesa no Workshop Arquitetando Soluções de IA — arquitetura de software com agents, na prática.

O próximo dev que te mostrar um "agente" no LinkedIn, faz o teste dos quatro blocos. Se faltar um, você já sabe o nome certo da coisa.