Modulo 4.2 - O que sao Agentes de IA

1

🤖 Automacao vs Agentes Inteligentes

Scripts seguem regras, agentes tomam decisoes. O espectro da autonomia.

Existe uma diferenca fundamental entre automacao e agentes de IA. Um script de automacao e como uma receita de bolo: faca isso, depois aquilo, se der erro pare. Ele nao pensa, nao adapta, nao improvisa. Um agente de IA, por outro lado, e como um estagiario inteligente: voce da o objetivo, e ele decide como chegar la.

O que transforma um chatbot em agente e a autonomia de decisao. Um chatbot responde perguntas. Um agente percebe que precisa de informacao adicional, busca essa informacao, processa, e so entao responde. A diferenca esta no loop: o agente decide o que fazer a cada passo, nao segue um roteiro pre-definido.

Pense no espectro da autonomia: de um lado, um cron job que roda todo dia as 9h. Do outro, um sistema que monitora metricas, detecta anomalias, investiga a causa raiz, propoe uma correcao e, se autorizado, aplica. A maioria dos agentes uteis esta em algum ponto intermediario desse espectro.

O Espectro da Autonomia

Nem tudo precisa ser um agente. Entender onde cada solucao se encaixa e essencial para nao over-engineer:

Nivel	O que faz	Exemplo
Script	Executa passos fixos em ordem	Cron job que faz backup diario
Chatbot	Responde perguntas com contexto	FAQ bot no site da empresa
Assistente	Usa tools quando solicitado	ChatGPT com plugins ativados
Agente	Decide e age autonomamente	Claude Code, Devin, Cursor Agent
Multi-agente	Agentes coordenados em equipe	Sistema com router + executor + reviewer

Quando um Chatbot vira Agente

A transicao acontece quando o sistema ganha tres capacidades fundamentais:

Raciocinio sobre acoes

O sistema nao apenas gera texto. Ele avalia qual ferramenta usar, se precisa buscar mais informacao, ou se ja tem o suficiente para responder. Cada passo e uma decisao ativa, nao uma resposta reflexa.

Uso de ferramentas externas

O agente interage com o mundo real: le arquivos, faz requests HTTP, executa codigo, consulta bancos de dados. Sem tools, e apenas um gerador de texto sofisticado.

Loop de feedback

O agente observa o resultado de cada acao e ajusta o proximo passo. Se a busca retornou dados insuficientes, busca de novo com termos diferentes. Se o codigo gerado tem erro, corrige e tenta novamente.

💡 Dica

Nao transforme tudo em agente. Se o problema tem fluxo previsivel e regras claras, um script ou workflow e mais confiavel, mais barato e mais rapido. Agentes brilham quando o problema e ambiguo, o caminho nao e obvio, ou a tarefa requer adaptacao em tempo real. Use a ferramenta certa para o problema certo.

Fazer

●Avaliar se o problema realmente precisa de autonomia
●Comecar como assistente e evoluir para agente gradualmente
●Definir limites claros do que o agente pode e nao pode fazer
●Manter human-in-the-loop para acoes irreversiveis

Evitar

●Usar agente para tarefas que um cron job resolve
●Dar autonomia total sem guardrails de seguranca
●Confundir "agente" com "chatbot que usa tools"
●Ignorar custo: cada decisao autonoma consome tokens

2

🔄 O Loop ReAct: Reason + Act

Think, Plan, Act, Observe, Repeat. Como agentes decidem o que fazer.

O padrao ReAct (Reasoning + Acting) e o coracao de praticamente todo agente de IA moderno. Publicado em 2022 por pesquisadores de Princeton e Google, ele combina raciocinio em linguagem natural com execucao de acoes em um unico loop. O agente pensa em voz alta, age, observa o resultado, e repete ate resolver o problema.

A inovacao do ReAct nao e complexa: e a ideia de que o LLM pode intercalar pensamento com acao. Antes do ReAct, ou voce tinha chain-of-thought (pensar sem agir) ou action-only (agir sem pensar). O ReAct unifica os dois, e isso muda tudo.

Na pratica, o loop e simples: o agente recebe uma tarefa, raciocina sobre o proximo passo ("Preciso buscar o preco atual do produto"), executa a acao (chama a tool de busca), observa o resultado ("Preco: R$49,90"), raciocina novamente ("Agora preciso comparar com o concorrente"), e continua ate concluir. Cada iteracao e uma chamada ao LLM.

O Ciclo ReAct em 4 Passos

Cada iteracao do loop segue essa sequencia. O agente pode executar quantas iteracoes forem necessarias:

1. Think

O LLM raciocina sobre a situacao atual. Avalia o que sabe, o que falta, e qual o proximo passo logico.

2. Act

Executa uma acao concreta: chama uma tool, faz uma busca, executa codigo, ou gera output parcial.

3. Observe

Recebe o resultado da acao e incorpora ao contexto. Avalia se o resultado e suficiente ou se precisa de mais.

4. Repeat

Decide se o objetivo foi atingido. Se sim, gera resposta final. Se nao, volta ao passo 1 com novo contexto.

ReAct em Codigo (Pseudocodigo)

A implementacao real e surpreendentemente simples. O core de qualquer agente cabe em ~30 linhas:

function agentLoop(task, tools, maxIterations = 10) {
  let context = [{ role: "user", content: task }]

  for (let i = 0; i < maxIterations; i++) {
    // 1. THINK + ACT: LLM raciocina e decide acao
    const response = await llm.chat(context, { tools })

    // 2. Se nao chamou tool, e a resposta final
    if (!response.tool_calls) {
      return response.content  // Done!
    }

    // 3. OBSERVE: Executa cada tool e coleta resultado
    for (const call of response.tool_calls) {
      const result = await executeTool(call.name, call.args)
      context.push({ role: "tool", content: result })
    }

    // 4. REPEAT: Loop continua com novo contexto
  }

  return "Max iterations reached"
}

Esse e o esqueleto. Producao requer error handling, logging, timeout por tool call, e limites de custo. Mas a logica central e essa: loop ate resolver ou atingir o limite.

Exemplo Real: Agente de Pesquisa

Veja como um agente de pesquisa resolve "Qual o market cap da Apple hoje?":

Iteracao 1 - Think

"Preciso do market cap atual da Apple. Vou buscar na web."

Iteracao 1 - Act

web_search("Apple market cap 2026")

Iteracao 1 - Observe

"Resultado: Apple market cap $3.8T (Marco 2026, fonte: Yahoo Finance)"

Iteracao 2 - Think + Respond

"Tenho a informacao. Market cap da Apple: $3.8 trilhoes (Marco 2026)."

📊 Dados sobre ReAct

2022

Paper original ReAct (Yao et al., Princeton + Google Brain)

94%

dos frameworks de agentes usam variacao do ReAct como loop principal

3-15

iteracoes tipicas para resolver uma tarefa (mediana: 5 iteracoes)

+34%

ganho de precisao vs chain-of-thought puro em tarefas com tools

💡 Dica

Sempre defina um maxIterations no loop. Sem limite, um agente confuso pode ficar chamando tools em loop infinito, queimando tokens e dinheiro. Um limite de 10-15 iteracoes cobre 99% dos casos. Se o agente precisa de mais que isso, o problema provavelmente precisa ser decomposto.

Fazer

●Logar cada passo do loop (thought, action, observation)
●Definir timeout por tool call e por iteracao total
●Incluir o "pensamento" do agente no log para debug
●Testar com tarefas simples antes de escalar complexidade

Evitar

●Loop sem limite de iteracoes (risco de custo infinito)
●Ignorar erros de tool call (propagar o erro ao LLM)
●Acumular contexto sem limite (estoura a context window)
●Assumir que o LLM sempre segue o padrao ReAct corretamente

3

🔧 Tool Use: Agentes que Usam Ferramentas

Function calling, registro de tools, sandbox de execucao.

Function calling (ou tool use) e o mecanismo que permite ao LLM interagir com o mundo externo. Em vez de gerar texto, o modelo retorna uma chamada estruturada a uma funcao previamente registrada, com parametros preenchidos. O sistema host executa a funcao e devolve o resultado ao modelo.

O conceito e simples: voce registra tools com nome, descricao e schema de parametros. O LLM le essas descricoes e decide, baseado na conversa, qual tool chamar e com quais argumentos. E como dar a um trabalhador uma caixa de ferramentas e dizer "use o que precisar para resolver o problema".

A qualidade da descricao da tool e o fator mais importante. O LLM decide qual tool usar baseado na descricao, nao no nome. Uma descricao vaga como "busca dados" vai gerar confusao. Uma descricao precisa como "busca registros de clientes por nome, email ou CPF no banco PostgreSQL" guia o modelo corretamente.

Registro de Tool: JSON Schema

Toda tool precisa de um schema que define seus parametros. O LLM usa isso para gerar chamadas validas:

{
  "name": "web_search",
  "description": "Busca informacoes na web usando Google Search.
    Retorna titulo, snippet e URL dos 5 primeiros resultados.
    Use para informacoes atuais que nao estao no seu treinamento.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Termo de busca em linguagem natural"
      },
      "num_results": {
        "type": "number",
        "description": "Numero de resultados (1-10)",
        "default": 5
      },
      "language": {
        "type": "string",
        "enum": ["pt", "en", "es"],
        "default": "pt"
      }
    },
    "required": ["query"]
  }
}

Note como a descricao e especifica: diz o que faz, o que retorna e quando usar. Isso e mais importante que o nome da funcao.

Como o LLM Escolhe a Tool

O processo de selecao de tools pelo modelo segue uma logica interna:

Analise de intencao

O modelo avalia a mensagem do usuario e identifica que precisa de dados ou acoes externas. Ex: "qual a temperatura agora?" indica necessidade de dados em tempo real.

Match por descricao

Compara a necessidade com as descricoes das tools disponiveis. Se ha uma tool "busca previsao do tempo por cidade", ela e selecionada. Se nenhuma tool serve, responde com o que sabe.

Preenchimento de parametros

Extrai os parametros da conversa e preenche o schema. Se falta um parametro obrigatorio, o modelo pode perguntar ao usuario ou inferir do contexto.

Sandbox de Execucao

Tools que executam codigo ou acessam sistema de arquivos precisam rodar em ambiente isolado:

Docker Container

Executa codigo em container isolado com limites de CPU, memoria e rede. Padrao da industria para code execution.

Permissoes Granulares

Cada tool tem scope definido: read-only, write limitado a diretorio, sem acesso a rede. Principio do menor privilegio.

Timeout + Kill

Cada tool call tem limite de tempo. Se exceder, SIGTERM + SIGKILL. Previne loops infinitos e travamentos.

💡 Dica

Limite o numero de tools a 5-10 por agente. Pesquisas mostram que LLMs perdem precisao na selecao de tools quando ha muitas opcoes. Se precisar de mais, use um router que filtra as tools relevantes antes de passar ao LLM, ou divida em agentes especializados.

Fazer

●Escrever descricoes de tool detalhadas e especificas
●Validar parametros de entrada antes de executar
●Retornar erros estruturados (nao stack traces crus)
●Testar function calling isolado antes de integrar ao loop

Evitar

●Registrar 20+ tools no mesmo agente (confusao garantida)
●Tools sem timeout (podem travar o loop inteiro)
●Expor acesso a banco de dados com permissao de DELETE
●Confiar que o LLM sempre gera parametros validos

4

📋 Planning e Decomposicao de Tarefas

Quebrando objetivos complexos em sub-tarefas. Grafos de dependencia.

Tarefas complexas nao sao resolvidas em um unico passo. Planning e a capacidade do agente de decompor um objetivo grande em sub-tarefas menores, ordenar por dependencia, e executar na sequencia correta. E o que separa um agente que "tenta e erra" de um que "planeja e executa".

Quando voce pede "crie um landing page com formulario de contato", um agente bom nao sai gerando HTML imediatamente. Ele primeiro decompoe: 1) definir estrutura da pagina, 2) criar HTML/CSS base, 3) implementar formulario, 4) adicionar validacao, 5) testar. Cada passo tem dependencias claras e pode usar tools diferentes.

Existem duas abordagens: planning upfront (planeja tudo antes de comecar) e planning incremental (planeja o proximo passo baseado no resultado do anterior). A maioria dos agentes modernos usa uma combinacao: planeja os passos principais upfront, mas ajusta o plano conforme executa.

Grafo de Dependencia de Tarefas

Em tarefas complexas, nem tudo e sequencial. Algumas sub-tarefas podem rodar em paralelo:

Tarefa: "Crie um relatorio de mercado sobre IA"

  [1. Definir estrutura]
        |
   +---------+---------+
   |         |         |
[2a. Pesquisa  [2b. Dados   [2c. Coleta de
 tendencias]    de mercado]   exemplos]
   |         |         |
   +---------+---------+
        |
  [3. Compilar relatorio]
        |
  [4. Revisar e formatar]
        |
  [5. Gerar PDF final]

Os passos 2a, 2b e 2c sao independentes e podem rodar em paralelo (3 agentes simultaneos). O passo 3 depende dos tres anteriores. Isso e um grafo de dependencia, ou DAG (Directed Acyclic Graph).

Execucao Sequencial vs Paralela

Sequencial

Cada tarefa espera a anterior terminar

Simples de implementar e debugar

Ideal quando cada passo depende do anterior

Mais lento, mas mais previsivel

Paralelo

Tarefas independentes rodam ao mesmo tempo

Requer deteccao de dependencias (DAG)

Ideal para pesquisa, coleta de dados, batch

Mais rapido, mas mais complexo de orquestrar

Prompt de Planning

Um bom prompt de decomposicao de tarefas para o agente inclui instrucoes explicitas:

Voce e um agente de planejamento. Dada a tarefa abaixo:
1. Decomponha em sub-tarefas atomicas (cada uma resolvel em 1 acao)
2. Identifique dependencias entre sub-tarefas
3. Marque quais podem rodar em paralelo
4. Estime complexidade de cada uma (baixa/media/alta)
5. Retorne como JSON com formato:

{
  "tasks": [
    {
      "id": "t1",
      "description": "...",
      "depends_on": [],
      "parallel_group": "A",
      "complexity": "low",
      "tools_needed": ["web_search"]
    }
  ]
}

💡 Dica

O plano nao precisa ser perfeito. Agentes que re-planejam a cada passo (replanning) funcionam melhor do que agentes que seguem um plano rigido do inicio ao fim. Planeje 2-3 passos a frente, execute, avalie, e re-planeje. Isso e mais resiliente a surpresas.

Fazer

●Decompor tarefas em acoes atomicas e verificaveis
●Identificar dependencias antes de executar
●Paralelizar tarefas independentes quando possivel
●Permitir que o agente ajuste o plano mid-execution

Evitar

●Planos com 50+ sub-tarefas (perde contexto e foco)
●Seguir plano rigido sem avaliar resultados intermediarios
●Decompor demais: sub-tarefas triviais geram overhead
●Ignorar custos de planning (cada plan e uma chamada LLM)

5

📊 Agentes em Producao: 42% das Empresas

Dados McKinsey sobre adocao. Casos de uso reais em escala.

Agentes de IA nao sao mais conceito de paper academico. Segundo dados da McKinsey (2025/2026), 42% das empresas ja tem agentes de IA em producao, nao apenas em PoC ou piloto. A transicao de "experimentacao" para "operacao" aconteceu mais rapido do que qualquer analista previu.

Os casos de uso que mais crescem sao os que combinam alto volume + decisao repetitiva + necessidade de personalizacao. Atendimento ao cliente, revisao de codigo, analise de dados, geracao de conteudo. Em todos esses cenarios, o custo de um agente de IA e uma fracao do custo humano equivalente, com disponibilidade 24/7.

O dado mais relevante para quem esta construindo SaaS: empresas estao dispostas a pagar por agentes que funcionam. A willingness-to-pay por automacao inteligente e alta quando o agente demonstra ROI claro em reducao de tempo, custo ou erro.

📊 Dados de Mercado (2025/2026)

42%

das empresas tem agentes em producao (McKinsey Global Survey)

$4.8B

mercado global de agentes de IA (2026, estimativa Gartner)

92%

dos devs nos EUA usam IA no workflow diario (GitHub Survey)

3.2x

ROI medio reportado em customer service com agentes

Casos de Uso em Producao

Customer Service (Tier 1)

Agentes resolvem 60-80% dos tickets sem escalar para humano. Integram com CRM, base de conhecimento e sistemas de pagamento. Klarna reportou economia de $40M/ano com agentes de atendimento.

Code Review e Code Generation

Agentes como GitHub Copilot, Cursor Agent e Devin automatizam escrita de codigo, revisao de PRs e refatoracao. 92% dos devs usam alguma forma de IA no desenvolvimento diario.

Data Analysis e Reporting

Agentes que conectam a bancos de dados, geram queries SQL a partir de perguntas em linguagem natural, criam visualizacoes e compilam relatorios. Reduz tempo de analise de horas para minutos.

Content Generation

Agentes que pesquisam, redigem, revisam e publicam conteudo. Integram com CMS, SEO tools e social media. Geracao de artigos, emails de marketing, descricoes de produto em escala.

Desafios em Producao

Rodar agentes em producao e diferente de rodar em demo. Os principais desafios:

Confiabilidade

LLMs sao probabilisticos. A mesma tarefa pode ter resultados diferentes. Precisa de validacao, retry e fallback para garantir consistencia.

Custo

Cada iteracao do loop consome tokens. Um agente complexo pode gastar $0.50-$5.00 por tarefa. Precisa de metricas de custo por tarefa e limites.

Latencia

Cada hop (LLM call + tool execution) adiciona 2-10 segundos. Um agente com 5 iteracoes pode levar 30-60 segundos. UX precisa de streaming e feedback.

Observabilidade

Debugar um agente e mais complexo que debugar codigo linear. Precisa de trace logging de cada decisao, tool call e resultado para entender falhas.

💡 Dica

Comece com o caso de uso mais simples e de maior volume. Customer service tier 1 e o sweet spot: alto volume, respostas padronizadas, ROI facil de medir. Depois de provar valor, expanda para casos mais complexos. Nao comece pelo caso mais dificil.

Fazer

●Medir ROI concreto: tempo economizado, tickets resolvidos, custo por tarefa
●Implementar fallback para humano quando o agente nao resolve
●Monitorar custo por tarefa e definir alertas de budget
●A/B testar agente vs fluxo anterior para validar ganho

Evitar

●Lancar agente em producao sem metricas de qualidade
●Ignorar edge cases (o que acontece quando o agente "alucina"?)
●Substituir humanos completamente sem periodo de shadow mode
●Assumir que o que funciona em demo funciona em producao

6

🛠️ Exercicio: Seu Primeiro Agente

Agente ReAct com web search, calculadora e planning.

Hora de construir. Neste exercicio voce vai criar um agente funcional com loop ReAct, duas ferramentas (web search e calculadora) e capacidade de planning. O objetivo e ter um agente que recebe uma pergunta complexa, decompoe em passos, usa tools para coletar dados, e entrega uma resposta final estruturada.

Nao e sobre perfeicao. E sobre ter um agente que funciona end-to-end: recebe input, raciocina, age, observa, e responde. Se funcionar com 2 tools e um loop simples, voce ja entende o padrao o suficiente para construir agentes mais sofisticados.

Especificacao do Agente

1

Loop ReAct com maxIterations

Implemente o loop Think > Act > Observe > Repeat com limite de 10 iteracoes. Log cada passo (thought, action, observation) para debug.

2

Tool 1: Web Search

Registre uma tool que busca na web (pode usar SerpAPI, Tavily, ou simular com dados mockados). Retorna titulo, snippet e URL dos resultados.

3

Tool 2: Calculator

Registre uma tool que avalia expressoes matematicas. Recebe string como "1500 * 1.15" e retorna o resultado. Use eval seguro ou mathjs.

4

Planning: Decomposicao de Tarefas

O agente deve ser capaz de receber uma pergunta complexa (ex: "Quanto custa viajar de SP para Tokyo por 7 dias?") e decompor em sub-tarefas antes de executar.

Scaffold do Agente (TypeScript)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools = [
  {
    name: "web_search",
    description: "Busca informacoes atuais na web. Use para
      dados que nao estao no seu treinamento.",
    input_schema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Termo de busca" }
      },
      required: ["query"]
    }
  },
  {
    name: "calculator",
    description: "Calcula expressoes matematicas. Recebe
      expressao como string, retorna resultado numerico.",
    input_schema: {
      type: "object",
      properties: {
        expression: { type: "string", description: "Ex: 1500 * 1.15" }
      },
      required: ["expression"]
    }
  }
];

async function agent(task: string) {
  const messages = [{ role: "user", content: task }];

  for (let i = 0; i < 10; i++) {
    const res = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 4096,
      tools,
      messages
    });

    // Check for tool use
    const toolUse = res.content.find(b => b.type === "tool_use");
    if (!toolUse) {
      return res.content[0].text; // Final answer
    }

    // Execute tool and continue loop
    const result = await executeTool(toolUse.name, toolUse.input);
    messages.push({ role: "assistant", content: res.content });
    messages.push({
      role: "user",
      content: [{ type: "tool_result",
                   tool_use_id: toolUse.id,
                   content: result }]
    });

    console.log(`[Iteration ${i+1}] ${toolUse.name}(${
      JSON.stringify(toolUse.input)})`);
  }
}

Teste seu Agente

Use essas perguntas para validar que o agente funciona corretamente:

"Qual a populacao do Brasil?" (requer web_search) "Quanto e 15% de R$3.200?" (requer calculator) "Se o PIB do Brasil e X trilhoes e a populacao e Y milhoes, qual o PIB per capita?" (requer search + calculator) "Compare o preco de um iPhone 16 no Brasil vs EUA" (requer multiple searches + calculator) O agente para apos maxIterations se nao resolver Logs mostram cada iteracao com thought, action e observation

💡 Dica

Se nao tem API key para web search, use dados mockados. O importante e o agente decidir corretamente QUANDO chamar a tool, nao se os dados sao reais. Voce pode substituir a implementacao real depois. O padrao ReAct e o mesmo com dados reais ou mockados.

Fazer

●Comecar com o loop basico e testar com 1 tool
●Adicionar a segunda tool so depois que a primeira funcionar
●Logar cada iteracao para entender o raciocinio do agente
●Testar com perguntas que requerem ambas as tools

Evitar

●Construir tudo de uma vez (loop + tools + planning)
●Usar eval() diretamente no calculator (XSS risk)
●Pular o logging (impossivel debugar sem logs)
●Copiar o scaffold sem entender cada parte

🤖 Automacao vs Agentes Inteligentes

O Espectro da Autonomia

Quando um Chatbot vira Agente

💡 Dica

Fazer

Evitar

🔄 O Loop ReAct: Reason + Act

O Ciclo ReAct em 4 Passos

ReAct em Codigo (Pseudocodigo)

Exemplo Real: Agente de Pesquisa

📊 Dados sobre ReAct

💡 Dica

Fazer

Evitar

🔧 Tool Use: Agentes que Usam Ferramentas

Registro de Tool: JSON Schema

Como o LLM Escolhe a Tool

Sandbox de Execucao

💡 Dica

Fazer

Evitar

📋 Planning e Decomposicao de Tarefas

Grafo de Dependencia de Tarefas

Execucao Sequencial vs Paralela

Sequencial

Paralelo

Prompt de Planning

💡 Dica

Fazer

Evitar

📊 Agentes em Producao: 42% das Empresas

📊 Dados de Mercado (2025/2026)

Casos de Uso em Producao

Desafios em Producao

💡 Dica

Fazer

Evitar

🛠️ Exercicio: Seu Primeiro Agente

Especificacao do Agente

Scaffold do Agente (TypeScript)

Teste seu Agente

💡 Dica

Fazer

Evitar

📋 Resumo do Modulo 4.2