O que é um agente de IA? Guia completo

Um agente de IA é um sistema que usa um modelo de linguagem (LLM) como motor de decisão: ele percebe um contexto, escolhe entre ações disponíveis — geralmente chamadas de ferramentas —, executa essa ação, observa o resultado e repete o ciclo até completar um objetivo, com pouca ou nenhuma intervenção humana a cada passo. A diferença central para um chatbot comum não está no modelo por trás dos dois, e sim em quem controla o próximo passo: num chatbot tradicional, é um fluxo pré-definido pelo desenvolvedor; num agente, é o próprio modelo que decide em tempo real o que fazer em seguida.

Agente de IA vs. chatbot: a diferença que importa

Um chatbot clássico responde dentro de uma única interface de conversa, seguindo regras ou um roteiro configurado com antecedência. Um agente de IA vai além: ele pode iniciar processos, executar várias etapas em sequência e usar ferramentas externas — uma API, um banco de dados, um navegador, uma calculadora — para chegar ao resultado, sem que cada etapa precise ser aprovada por um humano.

• Autonomia: o chatbot espera uma pergunta por vez; o agente pode encadear várias ações sozinho até terminar a tarefa.
• Ferramentas: o chatbot normalmente só conversa; o agente chama APIs, consulta sistemas e executa ações reais.
• Controle do fluxo: no chatbot o caminho é fixo (pergunta → resposta); no agente, o modelo decide o próximo passo a cada iteração.
• Objetivo vs. turno: o chatbot otimiza a resposta de um turno; o agente persegue um objetivo que pode levar vários turnos e chamadas de ferramenta.

O loop do agente: percepção, raciocínio, ação

Na literatura sobre IA agêntica, esse comportamento costuma ser descrito como um ciclo repetido de quatro momentos: o agente percebe uma entrada (uma instrução, o resultado da última ação, um dado novo), raciocina sobre o que essa entrada significa à luz do objetivo e do que já tem em memória, decide uma ação — que pode ser responder em texto ou chamar uma ferramenta — e executa essa ação, incorporando o resultado de volta ao contexto antes de decidir o passo seguinte. O ciclo só termina quando o agente conclui que o objetivo foi atingido ou quando esbarra em um limite de segurança (número máximo de passos, tempo, orçamento de tokens).

# Loop simplificado de um agente — ilustrativo, não amarrado a um SDK específico
estado = {"objetivo": objetivo_do_usuario, "memoria": [], "passos": 0}

while not objetivo_concluido(estado) and estado["passos"] < LIMITE_DE_PASSOS:
    contexto = montar_contexto(estado)
    decisao = llm.decidir_proxima_acao(contexto)  # responder ou chamar uma ferramenta

    if decisao.tipo == "ferramenta":
        resultado = executar_ferramenta(decisao.nome, decisao.parametros)
        estado["memoria"].append(resultado)
    else:
        responder_ao_usuario(decisao.texto)

    estado["passos"] += 1

Workflows ou agentes? A distinção que a Anthropic formalizou

Segundo material técnico da Anthropic sobre construção de sistemas com LLM ("Building Effective Agents"), vale separar dois termos que o mercado usa como sinônimos. Workflows são sistemas em que o LLM e as ferramentas são orquestrados por um caminho de código predefinido — o desenvolvedor decide a sequência de passos com antecedência. Agentes são sistemas em que o próprio LLM dirige dinamicamente o processo e o uso de ferramentas, mantendo controle sobre como a tarefa é realizada. Na prática, boa parte do que o mercado chama de "agente" hoje é, por essa definição, um workflow bem construído — o que não é um problema: workflows são mais previsíveis, mais baratos e mais fáceis de depurar.

O mesmo material descreve cinco padrões de workflow que aparecem com frequência em produção:

• Prompt chaining: divide uma tarefa em chamadas de LLM sequenciais, com checagens programáticas entre uma etapa e outra.
• Routing: classifica a entrada e a encaminha para um prompt especializado diferente conforme o caso.
• Parallelization: roda chamadas independentes em paralelo, ou repete a mesma chamada várias vezes para tirar um consenso.
• Orchestrator-workers: um LLM central quebra a tarefa em subtarefas que não dá para prever de antemão, delega a LLMs "trabalhadores" e depois junta os resultados.
• Evaluator-optimizer: um LLM gera uma resposta enquanto outro avalia e devolve feedback, em ciclo, até a resposta passar no critério.

Tipos de agentes de IA

Fora da distinção workflow/agente, a literatura clássica de inteligência artificial também classifica agentes pelo tipo de decisão que tomam. Essa taxonomia é anterior aos LLMs, mas continua útil para situar onde um agente baseado em LLM se encaixa:

• Reativos: agem só com base em regras fixas e no que percebem no momento, sem manter histórico da interação — o exemplo clássico é um robô aspirador que desvia de obstáculos.
• Baseados em objetivos: avaliam diferentes ações possíveis e escolhem o caminho mais eficiente para atingir uma meta definida, em vez de só reagir ao ambiente.
• Baseados em utilidade: vão além de atingir o objetivo — comparam várias soluções possíveis e escolhem a que maximiza um critério de qualidade ou benefício, não só a que "funciona".
• Multiagentes: várias instâncias autônomas dividem o mesmo ambiente e cooperam, competem ou se especializam em subtarefas diferentes, coordenadas para um objetivo comum.

A maioria dos agentes de IA construídos sobre LLMs hoje se aproxima do modelo "baseado em objetivos": recebem uma meta em linguagem natural e decidem, passo a passo, qual ferramenta chamar para chegar lá.

Onde agentes de IA falham

Autonomia tem custo. Cada passo do loop é uma nova chamada ao modelo — o que soma latência e custo de tokens conforme a tarefa cresce, e cada chamada carrega uma chance pequena, mas não nula, de erro que se acumula ao longo de vários passos. Um agente com 95% de acerto por passo já erra em mais de 1 a cada 5 tarefas de 5 passos (0,95 elevado a 5 ≈ 77% de acerto), só pela composição de probabilidades — um exemplo ilustrativo, não uma estatística de mercado.

Dar a um agente acesso amplo demais a sistemas de produção sem aprovação humana no meio do caminho é o que a comunidade de segurança em IA chama de "excessive agency": o agente tecnicamente consegue fazer mais do que deveria, e um erro de raciocínio (ou uma instrução maliciosa injetada em um dado que ele processa) vira uma ação real, não só um texto errado.

Quando vale a pena usar um agente (e quando não vale)

Um agente compensa quando a tarefa tem passos que variam conforme o caso, não dá para prever todos os caminhos de antemão, e o custo de errar uma vez é baixo (ou há revisão humana no fim). É o cenário de empresas que já usam [agentes Claude para automatizar processos internos](/artigo/claude-agentes-automacao-empresas): triagem de tickets, pesquisa que cruza várias fontes, tarefas de suporte que dependem do que a etapa anterior revelou.

• Vale a pena: tarefas com caminho variável, onde a próxima ação depende do resultado da anterior, e onde um erro ocasional é barato de corrigir.
• Não vale a pena: tarefas com um único caminho fixo e repetitivo (nesse caso, um workflow determinístico é mais barato, mais rápido e mais previsível).
• Cuidado redobrado: tarefas com ação irreversível (pagamento, exclusão, envio para terceiros) — aí a recomendação padrão é manter aprovação humana no loop, não automação total.

Como os agentes se conectam ao resto da IA

Um agente não existe sozinho: ele é a camada de decisão em cima de um [LLM](/artigo/o-que-e-um-llm-guia-modelos-linguagem), que por sua vez é a peça central do que hoje se chama de [inteligência artificial generativa](/artigo/o-que-e-inteligencia-artificial-guia-completo-iniciantes). As "ferramentas" que um agente chama seguem cada vez mais um padrão comum de integração — é o caso do Model Context Protocol (MCP), que já aparece em produtos como o GitHub Copilot, [com allowlist de servidores MCP](/artigo/github-allowlist-mcp-copilot) justamente para conter o raio de ação do agente. Para quem vai construir um agente do zero, a escolha de linguagem segue as mesmas trocas discutidas em [Python ou TypeScript para projetos de IA](/artigo/python-ou-typescript-para-ia).

Vale reforçar: nem todo sistema com LLM é um agente, e isso não é um defeito. Boa parte do valor prático de IA em produção hoje vem de workflows bem desenhados — mais simples de testar, mais baratos e mais fáceis de prever do que um agente totalmente autônomo. A pergunta certa antes de construir um não é "dá para fazer isso com um agente?", e sim "esse problema realmente precisa que o modelo decida o próprio caminho?".