InsightsArtigo · Engenharia de IA

Você realmente precisa de um agente? Um modelo para decidir

LangChain, LangGraph, CrewAI e DSPy fazem quatro apostas diferentes. A escolha certa começa por saber se é preciso um agente.

Uma chamada a um LLM é de um único passo: você envia um prompt, recebe texto, sem como agir no mundo além do que ele consegue raciocinar com o que já sabe. O tool calling muda isso. Você descreve um conjunto de funções que o modelo pode invocar, cada uma com nome, descrição e esquema de parâmetros, e, em vez de produzir só texto, o modelo pode produzir um pedido estruturado para chamar uma delas, com argumentos concretos. A aplicação a executa de verdade e devolve o resultado como contexto novo. O próprio modelo decide se chama uma ferramenta, qual e com quais argumentos, de forma dinâmica, a cada pergunta: algo completamente diferente de um único passo de recuperar e gerar.

O ciclo por baixo de todo agente

O padrão que faz os agentes de vários passos funcionarem é o ReAct (raciocinar, agir, observar, repetir): um passo de raciocínio sobre o que fazer em seguida, uma chamada de ferramenta e a observação do resultado, até o modelo decidir que tem o suficiente para responder. Em código, é um laço while: chamar o modelo, ver se ele pediu uma ferramenta, executá-la nesse caso e devolver o resultado, repetir, e retornar o texto final quando ele para de pedir.

O laço em si é pouco código, e vale entendê-lo assim primeiro. A complexidade real está em volta: gerenciar o estado à medida que crescem o histórico e os resultados intermediários; lidar com uma ferramenta que falha ou com um modelo que alucina uma que não existe; limitar as iterações para que nada fique girando para sempre; e registrar cada passo, porque rastrear uma cadeia de chamadas é o mesmo problema que medir o custo dessa cadeia. Não é por acaso que as mesmas ferramentas acabam fazendo as duas coisas.

Quatro apostas diferentes

LangChain é o framework de propósito geral original, e o que definiu boa parte do vocabulário do ecossistema. Os pontos fortes são reais (a maior biblioteca de integrações, a maior documentação, rapidez para prototipar padrões comuns) e os fracos também: camadas de abstração pesadas que tornam o debugging opaco, um histórico de mudanças de API que quebram compatibilidade, e um modelo de controle de fluxo (o agent executor, a implementação original do ReAct) que fica desconfortável de forçar além de uma ramificação simples.

LangGraph, do mesmo time, é a resposta direta a essa limitação: em vez de um laço implícito, o fluxo do agente é um grafo explícito, com nós como passos e arestas como transições, incluindo arestas condicionais que se ramificam conforme o estado atual. Isso traz a ramificação condicional como conceito de primeira classe em vez de lógica aninhada, ciclos com estado (um padrão de "continuar refinando até passar num controle de qualidade" que é naturalmente um ciclo do grafo), passos de aprovação humana e pontos de controle para retomar depois um fluxo longo. O custo é o desenho prévio: um agente realmente simples, com um punhado de ferramentas e sem ramificação real, paga uma sobrecarga por uma explicitude de que não precisa.

CrewAI adota uma postura de nível mais alto e mais opinativa: orquestração de vários agentes por papéis. Em vez de um agente com muitas ferramentas, vários agentes recebem cada um um papel, um objetivo e só as ferramentas relevantes para esse papel. O raciocínio é que um único agente que cuida de todas as tarefas possíveis com um prompt de sistema gigante tende a render pior em cada tarefa do que especialistas, a mesma diluição que acontece quando você dá responsabilidades demais a uma pessoa ao mesmo tempo. Encaixa de verdade quando as subtarefas refletem papéis distintos, como os que uma equipe humana usaria para dividir o trabalho. É engenharia excessiva quando a tarefa é, na verdade, um único trabalho fantasiado de multiagente: cada agente adicional na cadeia soma custo, latência e um novo ponto onde uma passagem de bastão pode falhar, sem benefício nenhum se a tarefa não precisava ser dividida.

DSPy não é um framework de orquestração nem compete com os outros três. Ele trata o desenho de prompts como um programa que se otimiza sozinho: você declara o formato de entrada e saída de uma tarefa em vez de escrever o texto do prompt à mão, compõe a tarefa com módulos reutilizáveis (chain-of-thought, ReAct, predição simples) e, o mais importante, fornece exemplos de treino e uma métrica, e um otimizador busca a redação do prompt e os exemplos few-shot que pontuam melhor. Ele opera um nível abaixo da orquestração, no problema de escrever o prompt de um passo qualquer, não importa o que orquestra esse passo. Ele se justifica com uma métrica clara e exemplos suficientes para generalizar; é exagero para um prompt pequeno e pontual que é mais rápido ajustar à mão.

Uma árvore de decisão, não uma tabela de funcionalidades

O jeito certo de escolher não é comparar listas de funcionalidades: é uma sequência de perguntas em que cada uma descarta algo antes de a próxima importar.

  1. É preciso um agente, ou um único passo de recuperar e gerar resolve? Recorrer a um framework porque está na moda, e não porque o problema exige, é o erro de calibração mais comum.
  2. Se é preciso um agente, ele é simples? Um punhado de ferramentas, sem ramificação real, sem ciclos, sem passagens entre agentes. Então basta um laço escrito à mão ou um executor básico, e a maquinaria do grafo explícito é sobrecarga sem retorno.
  3. O controle de fluxo se complica de verdade? Ramificação condicional, ciclos de nova tentativa, passos de aprovação, um fluxo longo que precisa persistir e ser retomado. Isso é um grafo, não uma cadeia.
  4. O problema se decompõe mesmo em papéis distintos, como uma equipe humana o dividiria, e não porque "multiagente parece impressionante"? Esse é um caso para orquestração por papéis. Se a resposta honesta é uma única tarefa fantasiada, é sinal de voltar um passo.

O DSPy fica de fora de tudo isso, não como mais um item da lista: ele se aplica sempre que o prompt de um passo é ajustado à mão, por tentativa e erro, em vez de forma sistemática, não importa o que orquestra o resto.

Cada agente e cada chamada a mais numa cadeia somam custo, latência e um novo ponto onde algo pode quebrar.

O princípio por trás de tudo: a opção padrão deve apontar para a arquitetura mais simples que resolve o problema real, não para a mais sofisticada disponível. Perguntar se isso realmente precisa ser um agente, ou um sistema multiagente, é a primeira pergunta, não a última.

Compartilhe este insight

LinkedIn