Você provavelmente já usou um chatbot com IA. Você pergunta, ele responde. Você pergunta de novo, ele responde de novo. É uma conversa — útil, mas fundamentalmente passiva. O modelo espera você perguntar algo, processa, responde, e para por aí.
Um agente de IA é diferente. Dado um objetivo, ele planeja os passos necessários para alcançá-lo, executa ações no mundo real (consultar APIs, ler arquivos, escrever código, enviar e-mails), observa os resultados, ajusta o plano se necessário, e continua até a tarefa estar concluída — sem intervenção humana a cada passo.
A diferença não é mágica. É arquitetural.
O loop fundamental de um agente
Todo agente de IA — independente do framework ou modelo — opera em um ciclo:
- Observar: recebe o estado atual do ambiente (histórico de conversa, resultado de ações anteriores, contexto do sistema)
- Raciocinar: o modelo analisa o objetivo e o estado atual e decide o que fazer
- Agir: executa uma ação — chamar uma ferramenta, escrever para um arquivo, fazer uma requisição HTTP
- Atualizar: incorpora o resultado da ação ao contexto
- Repetir até o objetivo ser alcançado ou uma condição de parada ser atingida
Esse padrão é chamado de ReAct (Reasoning + Acting) na literatura acadêmica, mas a intuição é simples: o modelo pensa antes de agir, age, observa o que aconteceu, e pensa de novo.
O que faz um agente ser capaz de agir?
Três componentes tornam um LLM capaz de agir:
Ferramentas (Tools)
Funções que o agente pode chamar. Podem ser qualquer coisa: busca na web, consulta ao banco de dados, envio de e-mail, execução de código Python, chamada a uma API REST. O modelo escolhe qual ferramenta usar e com quais parâmetros.
Memória
- Curto prazo: a janela de contexto atual — tudo que aconteceu nessa sessão
- Longo prazo: banco de dados vetorial ou armazenamento externo que persiste entre sessões
- Semântica: fatos sobre o usuário, preferências, histórico relevante recuperados por similaridade
Planejamento
A capacidade de decompor um objetivo complexo em subtarefas. Modelos mais avançados fazem isso implicitamente durante o raciocínio. Para tarefas muito complexas, frameworks como LangGraph permitem definir grafos de estado explícitos.
Agentes single-agent vs. multi-agent
Um agente único recebe o objetivo, planeja sozinho e executa. Funciona bem para tarefas bem definidas e de complexidade moderada.
Um sistema multi-agente tem agentes especializados que colaboram: um agente orquestrador decompõe o objetivo e delega subtarefas para agentes especialistas. É como uma equipe de pessoas, cada uma com uma função específica.
Exemplo: uma tarefa de "analisar a concorrência e gerar um relatório executivo" pode ser decomposta em:
- Agente pesquisador: busca informações sobre concorrentes na web
- Agente analista: processa e sintetiza as informações brutas
- Agente escritor: formata o relatório no tom e estrutura corretos
- Agente revisor: valida consistência e qualidade antes de entregar
O orquestrador coordena o fluxo. Cada agente especialista faz uma parte menor e mais bem definida.
Casos de uso reais — o que já está em produção
1. Agente de suporte a clientes com acesso a sistemas
Contexto: empresa de e-commerce com 5.000 atendimentos/dia. A maioria resolve os mesmos problemas: "onde está meu pedido?", "quero cancelar", "não chegou o produto certo".
O que o agente faz: consulta o sistema de pedidos, verifica o histórico de entrega via API da transportadora, inicia processos de troca ou devolução, envia e-mails de confirmação e só escala para humano quando o caso é genuinamente complexo ou o cliente solicita.
Resultado típico: 60–75% dos atendimentos resolvidos sem intervenção humana. Tempo de resposta de horas para segundos.
2. Agente de triagem e enriquecimento de leads
Contexto: empresa B2B com time de vendas pequeno e muitos leads entrando por formulário.
O que o agente faz: ao receber um novo lead, consulta LinkedIn (via scraping ou API), busca informações da empresa no CNPJ e em fontes públicas, classifica o lead por perfil de ICP (Ideal Customer Profile), enriquece o CRM com os dados encontrados e, se o lead for qualificado, agenda automaticamente uma call com o SDR disponível.
Resultado típico: SDRs gastam tempo apenas com leads qualificados. Taxa de conversão melhora porque o contexto chega completo para a call.
3. Agente de code review automático
Contexto: time de desenvolvimento com PRs que ficam dias esperando review por falta de bandwidth.
O que o agente faz: ao abrir um PR, analisa o diff, verifica padrões de código (nomenclatura, segurança, performance), compara com as convenções do projeto, adiciona comentários nos pontos de atenção, e só notifica um revisor humano quando há mudanças de arquitetura ou lógica de negócio complexa.
Resultado típico: erros óbvios chegam corrigidos para o revisor humano. Ciclo de PR reduz de dias para horas.
4. Agente financeiro de conciliação
Contexto: empresa com múltiplos canais de venda (e-commerce, marketplace, loja física) e conciliação manual mensal de faturamento.
O que o agente faz: extrai dados de cada canal, compara com o extrato bancário, identifica discrepâncias, gera relatório de divergências com possível causa para cada uma e propõe os lançamentos contábeis de ajuste.
Resultado típico: processo que levava 3 dias de analista reduzido para 2 horas de revisão humana do relatório gerado.
5. Agente de geração de conteúdo de produto
Contexto: e-commerce com catálogo de 50.000 SKUs. Descrições de produto são genéricas ou inexistentes em boa parte do catálogo.
O que o agente faz: lê as especificações técnicas do produto, busca o contexto do segmento (para quem serve, quais dores resolve), gera título SEO, descrição completa, bullet points de benefícios e sugestões de palavras-chave — tudo formatado e pronto para publicar.
Resultado típico: geração de 200–500 descrições por hora, vs. 5–10 por hora de um copywriter.
6. Agente de monitoramento de infraestrutura com resposta automática
Contexto: plataforma SaaS com picos de carga imprevisíveis e alertas de infraestrutura que chegam a qualquer hora.
O que o agente faz: recebe alertas do CloudWatch/Datadog, analisa logs e métricas dos últimos minutos, identifica a causa raiz provável, executa ações pré-aprovadas (escalar o grupo de auto-scaling, reiniciar um container travado, limpar filas acumuladas) e documenta tudo num canal do Slack. Para situações fora do playbook, acorda o on-call com um resumo completo já preparado.
Resultado típico: 40–60% dos incidentes resolvidos automaticamente antes de afetar usuários.
Construindo seu primeiro agente com a API da Anthropic
import anthropic
client = anthropic.Anthropic()
# Define as ferramentas disponíveis para o agente
tools = [
{
"name": "consultar_estoque",
"description": "Consulta a quantidade disponível de um produto no estoque",
"input_schema": {
"type": "object",
"properties": {
"sku": {"type": "string", "description": "Código SKU do produto"}
},
"required": ["sku"]
}
},
{
"name": "criar_pedido_reposicao",
"description": "Cria um pedido de reposição de estoque para um produto",
"input_schema": {
"type": "object",
"properties": {
"sku": {"type": "string"},
"quantidade": {"type": "integer"},
"urgencia": {"type": "string", "enum": ["normal", "urgente", "critico"]}
},
"required": ["sku", "quantidade"]
}
}
]
def executar_ferramenta(nome: str, params: dict) -> str:
"""Executa a ferramenta solicitada e retorna o resultado."""
if nome == "consultar_estoque":
# Aqui seria a chamada real ao sistema de estoque
estoques = {"SKU-001": 12, "SKU-002": 0, "SKU-003": 3}
qtd = estoques.get(params["sku"], -1)
if qtd == -1:
return f"SKU {params['sku']} não encontrado"
return f"Estoque atual de {params['sku']}: {qtd} unidades"
if nome == "criar_pedido_reposicao":
# Aqui seria a criação real do pedido
return f"Pedido de reposição criado: {params['quantidade']}x {params['sku']} (urgência: {params.get('urgencia', 'normal')}). Número do pedido: PED-{hash(params['sku']) % 9999:04d}"
return f"Ferramenta '{nome}' não reconhecida"
def rodar_agente(objetivo: str):
"""Loop principal do agente."""
mensagens = [{"role": "user", "content": objetivo}]
print(f"\n🎯 Objetivo: {objetivo}\n")
while True:
resposta = client.messages.create(
model="claude-opus-4-5-20251101",
max_tokens=4096,
tools=tools,
messages=mensagens,
system="Você é um agente de gestão de estoque. Analise os estoques e tome as ações necessárias para garantir que produtos críticos não fiquem sem estoque."
)
# Agente terminou — sem mais ações
if resposta.stop_reason == "end_turn":
for bloco in resposta.content:
if hasattr(bloco, "text"):
print(f"✅ Agente: {bloco.text}")
break
# Agente quer chamar ferramentas
if resposta.stop_reason == "tool_use":
mensagens.append({"role": "assistant", "content": resposta.content})
resultados = []
for bloco in resposta.content:
if bloco.type == "tool_use":
print(f"🔧 Chamando {bloco.name} com {bloco.input}")
resultado = executar_ferramenta(bloco.name, bloco.input)
print(f" → {resultado}")
resultados.append({
"type": "tool_result",
"tool_use_id": bloco.id,
"content": resultado
})
mensagens.append({"role": "user", "content": resultados})
# Executa o agente
rodar_agente(
"Verifique o estoque dos produtos SKU-001, SKU-002 e SKU-003. "
"Para qualquer produto com menos de 5 unidades, crie um pedido de reposição de 50 unidades. "
"Para produtos zerados, marque como urgente."
)Rodando esse código, o agente vai:
- Consultar o estoque dos três SKUs
- Identificar que SKU-002 está zerado e SKU-003 está abaixo de 5
- Criar pedido urgente para SKU-002 e normal para SKU-003
- Reportar o que foi feito
Sem nenhuma lógica de decisão hardcoded. O modelo raciocina, age e documenta.
Quando usar agentes e quando não usar
Agentes são poderosos, mas têm custos: latência maior, custo por token mais alto (múltiplas chamadas ao modelo), e risco de erros em cadeia se uma ação intermediária falhar.
Use agentes quando:
- A tarefa envolve múltiplos passos não lineares
- O caminho para a solução não é conhecido de antemão
- Você precisa integrar múltiplos sistemas em um fluxo
- O volume de tarefas torna a execução manual inviável
Prefira pipelines simples quando:
- A sequência de passos é sempre a mesma
- As entradas e saídas são bem definidas e previsíveis
- Latência é crítica e cada milissegundo importa
- Você precisa de auditabilidade total de cada decisão
O futuro próximo: agentes com memória de longo prazo
A próxima fronteira é agentes que mantêm contexto entre sessões. Hoje, cada conversa começa do zero. Sistemas como o Memory do Claude e bancos de dados vetoriais integrados estão mudando isso: o agente lembra das preferências do usuário, das decisões tomadas em projetos anteriores e do contexto acumulado ao longo do tempo.
Isso transforma o agente de uma ferramenta de sessão única para um colaborador que evolui junto com o trabalho — mais parecido com um funcionário que aprende do que com um utilitário que você abre e fecha.