Capítulo 1
O que é um agente?
Nesta página
Este capítulo cumpre uma promessa feita no prefácio: antes de construir qualquer coisa, definimos com precisão o que um agente é. A necessidade é prática e imediata. Fornecedores chamam de “agentes” bots de roteiro fixo; pesquisadores reservam a palavra para sistemas que rodam por horas sem ninguém acompanhando; e, em algum ponto entre os dois, você precisa tomar decisões de verdade com orçamentos de verdade. Se o termo continuar nebuloso, você vai recorrer a um agente autônomo onde um pipeline de três passos teria sido mais barato e mais fácil de depurar, ou vai montar à mão um pipeline rígido para um problema cujos passos você realmente não tem como prever. O capítulo faz três coisas. Apresenta a ideia de agente em si, explica por que ela se tornou viável quando se tornou — sem datas, de propósito — e expõe a bússola pela qual o livro vai se orientar. Em seguida, traça a distinção prática entre chatbots, workflows e agentes, na qual todos os capítulos seguintes se apoiam. E termina com a pergunta que pouca gente faz em voz alta: se você precisa mesmo de um agente.
A ideia de agente
Deixe de lado as demos e o marketing, e a ideia é pequena o bastante para caber na palma da mão. Um agente é um modelo de linguagem colocado em um loop. Ele recebe um objetivo e um conjunto de ferramentas — funções que ele pode pedir ao seu programa que execute: pesquise isto, leia aquilo, execute este comando. Ele olha o estado da tarefa, escolhe uma ação, vê o resultado e repete, até julgar que o objetivo foi atingido ou até que uma regra de parada encerre a execução. Depois de anos sem conseguir se entender, a comunidade de quem trabalha na área convergiu em grande parte, no momento em que escrevo, para uma versão de uma frase só: um agente executa ferramentas em loop para atingir um objetivo.1 Simon Willison, “I think ‘agent’ may finally have a widely enough agreed upon definition to be useful jargon now”, simonwillison.net (setembro de 2025). A definição citada — “An LLM agent runs tools in a loop to achieve a goal” (um agente de LLM executa ferramentas em loop para atingir um objetivo) — é dele, defendida ali expressão por expressão. LLM é a abreviação usada na área para large language model (grande modelo de linguagem), que este livro chama quase sempre de modelo de linguagem, ou simplesmente de modelo. Cada palavra dessa frase carrega peso. “Ferramentas” é o que conecta o modelo ao mundo; “loop” é o que permite que ele reaja ao que encontra; “um objetivo” é o que encerra o loop — um agente tem uma condição de parada, e é isso que o separa de um processo descontrolado. O capítulo 3 destrincha o loop em código.
O que há de realmente novo aqui é onde mora o fluxo de controle. Em todo programa que você escreveu até hoje, a sequência de operações foi decidida por você, de antemão, em código. Em um agente, a sequência é decidida pelo modelo, em tempo de execução, em resposta ao que ele observa. Essa única mudança é o que faz os agentes merecerem um livro, e também o que os torna caros, lentos e, de vez em quando, alarmantes. O resto do livro trata das duas metades dessa frase.
Você pode, com razão, perguntar por que isso se tornou viável quando se tornou. Os modelos de linguagem já eram fluentes muito antes de alguém confiar um loop a um deles; a fluência nunca foi a peça que faltava. Três coisas precisaram amadurecer. Cada uma vai voltar mais adiante no livro, primeiro como mecanismo e depois como modo de falha, quando começa a faltar.
A primeira: os modelos aprenderam a receber instruções. Um modelo recém-saído do treinamento inicial é um puro continuador de texto — faça uma pergunta e ele pode responder com mais perguntas, porque essa é uma forma plausível de o texto continuar (o capítulo 2 mostra por quê). Uma etapa posterior do treinamento, que a área chama de pós-treinamento (post-training), transforma esse continuador em algo a que você pode confiar um trabalho: ele segue orientações, trabalha em direção ao objetivo declarado e para quando termina. Um agente é uma delegação, e delegar exige um trabalhador que aceite a tarefa.
A segunda: o texto ganhou uma ponte para a ação. A chamada de função (function calling) — o modelo emite uma solicitação legível por máquina, “chame esta função com estes argumentos”, que o seu código executa antes de devolver o resultado a ele — deu ao modelo um canal disciplinado para o mundo. O modelo propõe; o seu código dispõe. O capítulo 2 cobre o mecanismo em detalhe. Aqui, o que importa é a consequência: um sistema que só conseguia escrever sobre o mundo passou a poder pedir, em uma forma que um programa consegue obedecer com segurança, que coisas aconteçam nele.
A terceira: a memória de trabalho do modelo cresceu. Tudo o que um agente sabe em um dado momento precisa caber na janela de contexto do modelo (o trecho limitado de texto que um modelo consegue considerar em uma única chamada). Quando as janelas comportavam umas poucas páginas, um loop morria de fome: as instruções, o histórico e o resultado mais recente de uma ferramenta não cabiam juntos. As janelas cresceram até comportar algo mais próximo de uma sessão de trabalho, e os loops se tornaram sustentáveis.
Cada um desses ingredientes amadureceu como uma curva que cruza um limiar sem fazer barulho, o que é conveniente para nós dois: a explicação do “por que agora” não tem prazo de validade. Ela também diz o que verificar quando alguma nova capacidade é anunciada: pergunte qual dos três ingredientes acabou de melhorar.
Antes da taxonomia e do maquinário, quero entregar a você a bússola pela qual este livro se orienta: quatro rumos que vão reaparecer em quase todos os capítulos. Eu os enuncio aqui sem a defesa completa; a defesa é o livro.
A verificabilidade vem primeiro. O prefácio enunciou a tese, e vale repeti-la: um agente só é tão confiável quanto o sinal que você tem para verificá-lo. A convicção com que o próprio modelo fala não traz nenhuma informação sobre se ele está certo, então a confiança precisa vir de fora — um teste que passa, um schema que valida, uma fonte que você pode abrir, um humano que aprova. A primeira pergunta a fazer sobre qualquer projeto de agente é a que este livro vai fazer repetidas vezes: que sinal indica que deu certo?
Em seguida vem a escassez de contexto. A janela de contexto é finita, e a parte que surpreende as pessoas é que a atenção do modelo se degrada antes de o espaço acabar: um fato enterrado no meio de uma pilha longa fica, na prática, meio esquecido. Trate o contexto como um orçamento a ser gasto com critério. A Parte III deste livro é sobre gastá-lo bem.
O erro composto é o terceiro. Um agente encadeia muitos passos, e a confiabilidade se multiplica ao longo deles. Suponha, apenas como ilustração, que cada passo dê certo 95% das vezes; uma execução de vinte passos encadeados dá certo, então, cerca de 0, 9520 ≈ 36% das vezes. Os números específicos variam; a aritmética não, e ela é impiedosa. Loops longos só sobrevivem com recuperação, checkpoints e verificação ao longo do caminho. Este livro dedica capítulos inteiros a esse maquinário.
E o último rumo é a coisa mais simples que funciona. O conselho de engenharia que melhor envelheceu nesta área tão jovem é direto: encontre a solução mais simples possível e só acrescente complexidade quando ela comprovadamente compensar — o que pode significar não construir agente nenhum.2 Erik Schluntz e Barry Zhang, “Building Effective Agents”, blog de engenharia da Anthropic (2024): “recomendamos encontrar a solução mais simples possível e só aumentar a complexidade quando necessário. Isso pode significar não construir sistemas agênticos de forma alguma”. A distinção entre workflow e agente feita no ensaio também ancora a próxima seção. Às vezes a coisa mais simples é um único prompt. Às vezes é uma expressão regular. A última seção deste capítulo leva esse rumo a sério o bastante para lhe dar uma discussão própria. A figura 1.1 dispõe os quatro rumos em uma única rosa dos ventos, com a agulha pousada no primeiro deles.
Uma bússola é um instrumento modesto; ela não vai projetar o seu sistema por você. Mas sempre que o livro chegar a uma bifurcação — mais autonomia ou menos, outro agente ou um script simples, contexto mais rico ou mais enxuto — você verá os mesmos quatro rumos decidirem a questão, e espero que, no fim, eles estejam decidindo as suas bifurcações também.
Agentes, workflows e chatbots
Vou colocar três sistemas na sua frente. Decida qual deles é o agente antes de continuar a leitura.
O primeiro é um assistente de perguntas e respostas. Você cola uma função e pergunta o que ela faz, e ele explica; você cola um diff e pede um rascunho de mensagem de commit, e ele escreve; depois fica esperando a sua próxima mensagem. O segundo processa do mesmo jeito todo ticket de suporte que chega: uma chamada de modelo classifica o ticket, código comum busca o documento de política correspondente, uma segunda chamada de modelo redige uma resposta, uma terceira checa o rascunho com base em uma rubrica, e o resultado cai em uma fila de revisão humana — quatro passos, nessa ordem, todas as vezes. O terceiro recebe a instrução “os testes do checkout estão falhando — corrija” e, sem ninguém acompanhando, pesquisa na base de código, lê três arquivos, edita um, roda os testes, lê a nova falha, edita de novo e para quando a suíte fica verde.
O instinto da maioria das pessoas separa esses três na hora: o terceiro parece de outra natureza, e o instinto está certo. O trabalho útil é dizer com precisão por quê. Os três podem ser construídos exatamente sobre o mesmo modelo. O que muda é a pergunta que a seção anterior apontou como o que há de realmente novo: quem decide o que acontece em seguida. No primeiro sistema, é você, uma mensagem de cada vez. No segundo, é o seu código; o modelo só preenche o conteúdo ao longo de uma rota que foi fixada antes de o primeiro ticket chegar. No terceiro, quem decide é o modelo: que arquivo ler, se edita ou roda de novo, quando parar. Essa pergunta — quem é dono do fluxo de controle — é a distinção inteira, e ela nos dá os três termos que este livro usa em toda parte. A figura 1.2 desenha os três lado a lado, diferindo apenas em quem decide o próximo passo.
Um chatbot é uma conversa turno a turno. O humano conduz cada passo; o modelo gera texto e espera. Não há loop e nada é executado. Chatbots são úteis de verdade e muitas vezes a ferramenta certa, e sua superfície de falha é pequena de um jeito que quero deixar registrado: o pior que um chatbot pode produzir é uma resposta errada, porque agir sobre o mundo está fora do alcance dele.
Um workflow (fluxo de trabalho) é formado por várias chamadas de modelo (e chamadas de ferramenta) ligadas entre si ao longo de caminhos que o seu código define de antemão. O modelo preenche o conteúdo em cada passo — classifique isto, redija aquilo — mas é o seu código que decide qual passo vem a seguir. Os formatos recorrentes têm nomes que você vai reencontrar no capítulo 10: encadeamento (a saída de uma chamada alimenta a seguinte), roteamento (classificar e então ramificar) e paralelização (disparar várias chamadas ao mesmo tempo e depois agregar os resultados). O pipeline de tickets acima é um workflow, e você poderia ter desenhado o fluxograma dele antes de colocá-lo para rodar.
Um agente entrega o fluxo de controle ao modelo. Um ensaio de engenharia muito citado traça a linha exatamente aqui: workflows são “sistemas em que LLMs e ferramentas são orquestrados por caminhos de código predefinidos”, enquanto agentes são sistemas em que os modelos “dirigem dinamicamente os próprios processos e o uso de ferramentas”.3 Erik Schluntz e Barry Zhang, “Building Effective Agents”, blog de engenharia da Anthropic (2024); as duas frases são citadas do ensaio, que também dá nome ao bloco de construção LLM aumentado, descrito no próximo parágrafo. Um levantamento anterior — Lilian Weng, “LLM Powered Autonomous Agents”, lilianweng.github.io (2023) — descreve a mesma anatomia vista de dentro: um modelo como “cérebro”, apoiado por planejamento, memória e uso de ferramentas. O número de passos, e qual passo vem quando, não existe em lugar nenhum do seu código; o modelo escolhe à medida que avança, reagindo ao que acabou de observar. É por isso que o sistema que corrige testes parece diferente: a transcrição dele se lê como o registro da tarde de um colega, e só de longe lembra a execução de um programa.
Por baixo dos dois últimos está o mesmo átomo, que vale a pena nomear porque os padrões que você vai encontrar no capítulo 10 são montados a partir dele. O LLM aumentado (augmented LLM) é uma chamada de modelo reforçada com três coisas: recuperação (trazer informação relevante no momento da requisição), ferramentas (funções que ele pode solicitar) e memória (alguma forma de levar adiante o que importa). Um workflow é formado por vários desses átomos, ligados pelo seu código ao longo de um caminho fixo. Um agente é um desses átomos colocado dentro de um loop, decidindo por conta própria o que fazer a cada volta. (Um chatbot, nesse quadro, é a chamada de modelo pura, com os reforços quase todos sem uso.) O mesmo átomo, dois arranjos — guarde essa imagem e as taxonomias deixam de parecer misteriosas.
Aqui está o teste decisivo que vou usar no resto do livro. Se você consegue desenhar com segurança o diagrama do fluxo de controle antes de a requisição chegar, está diante de um workflow. Se o diagrama só pode ser desenhado em retrospecto, depois que o modelo reagiu ao que encontrou, está diante de um agente.
É tentador tratar chatbot, workflow e agente como três caixas. A realidade é um dial (figura 1.3). Em uma ponta, o modelo gera texto e um humano decide tudo. Perto dessa mesma ponta fica o pipeline fixo (o sistema de tickets de agora há pouco), em que o código é dono de cada passo e o modelo só preenche o conteúdo. Um pouco acima, um workflow concede ao modelo uma decisão: um roteador escolhe qual ramo fixo no código trata a requisição. Mais adiante, um agente percorre livremente o loop com suas ferramentas, mas faz uma pausa para aprovação humana antes de qualquer ação com consequências — enviar o e-mail, gastar o dinheiro, apagar os dados; boa parte do que está em produção fica aqui. Na extremidade oposta, o modelo é dono do caminho de ponta a ponta, por muitos passos, sem confirmação a cada passo: capacidade máxima, raio de impacto (blast radius) máximo — o estrago que uma ação errada poderia causar antes que algo a detenha, um termo que o capítulo 17 vai tornar preciso. O que se move ao longo desse dial é uma única grandeza, quanto do fluxo de controle pertence ao modelo, e sistemas maduros escolhem uma posição deliberadamente, em vez de herdar uma de alguma demo.
Mais uma observação antes de deixarmos a taxonomia, porque ela antecipa onde este livro vai chegar. Quase nada do que vai para produção é um workflow puro ou um agente puro. O formato dominante em produção é uma casca de workflow com um ou dois passos genuinamente agênticos dentro dela: estrutura previsível onde quer que você consiga prever, autonomia nas mãos do modelo apenas nos pontos que você não consegue enumerar. Você está ajustando um dial, passo a passo, e a próxima seção trata de até onde girá-lo.
Você precisa mesmo de um agente?
Agora que você sabe distinguir um agente de um workflow, está diante da pergunta que esta seção existe para tornar respeitável: você precisa mesmo de um? Eu a coloco tão cedo de propósito. O erro contra o qual esta área mais adverte quem está chegando é recorrer a um agente autônomo quando um único prompt, um pipeline fixo ou cinquenta linhas de código comum teriam sido mais baratos, mais rápidos e mais fáceis de depurar. Uma demo de agente é uma coisa sedutora. Você vê um modelo planejar, agir, se recuperar e terminar, e a conclusão natural é que esse poder cabe em todo lugar. Resista à conclusão por tempo suficiente para calcular o preço dela.
Comparado com uma única chamada de modelo, um agente acrescenta vários custos recorrentes, e eles vêm em pacote. Primeiro, o dinheiro: um agente faz muitas chamadas de modelo por tarefa em vez de uma, e cada chamada reenvia a conversa, que não para de crescer; assim, o custo escala duas vezes — uma no número de chamadas, outra no tamanho de cada uma. Um loop de dez passos pode custar uma ordem de grandeza a mais do que a chamada única que ele substituiu (o multiplicador é ilustrativo; o que importa é a direção). Segundo, a latência: as chamadas são sequenciais, cada uma esperando o resultado da última ferramenta, de modo que uma resposta em menos de um segundo vira muitos segundos ou minutos; se houver um humano esperando do outro lado, isso por si só pode desqualificar o projeto. Terceiro, o não determinismo: a mesma entrada pode seguir um caminho diferente e produzir uma resposta diferente a cada execução, o que quebra, sem alarde, os seus hábitos de teste, depuração e auditoria.4 Uma análise publicada sobre a confiabilidade de agentes relata taxas de sucesso em execução única em torno de 60%, que caem para cerca de 25% quando a mesma tarefa precisa dar certo em oito execuções consecutivas — números que ilustram a lacuna de consistência, não fatos permanentes. Fiddler AI, “AI Agent Failure Rate: Why 70–95% Fail in Production”, blog da fiddler.ai (2026). E a superfície de falha muda de natureza, e esse é o custo que eu mais quero que você sinta: a falha limitada que a seção anterior creditou ao chatbot é exatamente aquilo de que um agente abre mão. O erro dele é uma ação errada, seguida de mais dez ações construídas sobre ela, com o erro se compondo ao longo do loop exatamente como prevê a aritmética da bússola.
Dois outros custos passam facilmente despercebidos quando a demo é deslumbrante. Conceder ferramentas e autonomia a um modelo amplia a sua superfície de ataque; a comunidade de segurança tem um nome para a concessão em excesso: agência excessiva (excessive agency), ou seja, mais permissões, funcionalidades ou liberdade do que a tarefa exige.5 OWASP, “Top 10 for LLM Applications” — o item sobre Excessive Agency. O perigo também vai além do que você concede deliberadamente: um texto que o agente apenas lê pode direcionar o que ele faz em seguida, uma família de ataques chamada injeção de prompt (prompt injection), que o capítulo 17 examina. Por fim, o peso operacional: um chatbot precisa de um prompt, ao passo que um agente precisa, além disso, da integração das ferramentas, de gestão de contexto, recuperação de erros, condições de parada, pontos de aprovação, rastreamento (tracing) e avaliações. Esse maquinário ao redor é chamado de harness, e construí-lo é a maior parte do trabalho; um modelo brilhante em um harness frágil falha em produção.
Portanto, o ponto de partida honesto é uma escada, que é o quarto rumo da bússola posto em prática, e a disciplina é ficar no degrau mais baixo que resolve o seu problema. O degrau de baixo é código comum: uma expressão regular, uma consulta SQL, um if — gratuito, instantâneo, determinístico, auditável; se a lógica pode ser totalmente especificada, não é preciso modelo nenhum. O degrau seguinte é uma única chamada de modelo bem elaborada, talvez com recuperação e alguns exemplos no prompt; uma fração surpreendente dos “precisamos de um agente” se dissolve em “precisávamos de um prompt melhor”. O degrau acima desse é um workflow: várias chamadas em caminhos que você desenhou de antemão. O degrau do topo é um agente. Cada degrau que você sobe compra adaptabilidade e paga por ela em custo, latência e imprevisibilidade. Para um problema cujos passos você consegue desenhar de antemão, um degrau mais baixo é a resposta correta em definitivo; permanecer nele é a disciplina. A figura 1.4 desenha a escada, com a adaptabilidade subindo à medida que você sobe e o custo subindo junto.
O teste prático é o da seção anterior, agora usado como apoio à decisão: você consegue desenhar o fluxograma antes de a requisição chegar? Se sim, pare em um workflow ou abaixo dele — passos conhecidos, requisitos de correção auditáveis, orçamentos apertados de latência ou de custo e tarefas simples de consultar, classificar e transformar apontam todos para baixo na escada. O que aponta para cima é o objetivo realmente aberto: os passos dependem do que o modelo descobre, e é preciso discernimento em ramificações que você não consegue enumerar. Mesmo assim, exija o primeiro rumo da bússola em forma concreta — um critério de sucesso claro, um sinal de feedback a cada passo e um lugar sensato para um humano olhar. Um par concreto para calibrar: “encaminhe cada e-mail recebido para faturamento, suporte técnico ou vendas e redija uma primeira resposta” tem passos que dá para conhecer e alto volume, e pede um workflow; “faça este teste que está falhando passar em uma base de código que você nunca viu” tem passos impossíveis de conhecer de antemão e um verificador embutido, e é um problema genuíno de agente.
Uma armadilha merece um parágrafo só para ela, porque defende com muita eloquência o projeto errado: “pode ser que um dia precise se adaptar”. Isso é uma hipótese, e barata de testar com honestidade: construa primeiro a versão mais simples, meça-a com casos reais e só suba a escada quando puder apontar uma classe de entradas em que o sistema simples comprovadamente falha e confirmar que um agente de fato se sai melhor. A armadilha inversa é o agent-washing: como a palavra vende, pipelines de roteiro fixo são rebatizados de agentes. A pergunta que desmonta as duas é o teste decisivo que você já tem, feito ao sistema que está na sua frente, seja qual for o rótulo: é o modelo que decide o próximo passo, ou é o código? O capítulo 14 retoma essa decisão com a bagagem de todos os capítulos intermediários; o capítulo 16 mostra como fazer a medição.
Um agente, então, é um custo que você paga por uma adaptabilidade que consegue nomear. Se não consegue nomear a adaptabilidade, guarde o seu dinheiro. E se consegue — se os passos realmente não podem ser desenhados de antemão e existe um sinal de verificação — então um agente é a ferramenta certa, e os próximos capítulos tratam de construí-lo bem. Antes, porém, você precisa entender o motor que vamos colocar em loop: o capítulo 2 é sobre o que um modelo de linguagem realmente é.