Top 10+ Frameworks e Ferramentas de Orquestração Agêntica

• Dez frameworks estão próximos entre si em custo e velocidade: 1.000 execuções custam cerca de 1.4 a 1.7 USD, e uma execução leva 12 a 14 segundos em média.
• Google ADK, smolagents e Microsoft Agent Framework se destacam: custam cerca de 1.6 a 1.9 vezes mais, e uma execução leva de 1 a 5 segundos a mais em média.
• Os frameworks mais baratos (LangGraph, LangChain, Agno) levaram cerca de 1 segundo a mais por execução do que o grupo mais rápido: Strands, OpenAI Agents SDK, AutoGen, Pydantic IA e CAMEL.

O agente de atividades tinha uma regra: escolher uma atividade em local fechado se a chance de chuva do dia for 50% ou superior ou se houver previsão de chuva; caso contrário, escolher uma atividade ao ar livre. Os três dias foram ensolarados ou nublados com chance de chuva de 5 a 10%, então a resposta correta foi uma atividade ao ar livre em todos os dias.

Descobertas do benchmark de orquestração agêntica

Quando o model pensava antes de responder, seguia a regra em todas as vezes (388 de 388 execuções). Quando respondia sem pensar, seguia a regra em apenas 38% das execuções.

O mesmo padrão vale dentro de cada framework. No LangGraph, por exemplo, o model pensou em 3 execuções e seguiu a regra em todas as 3; nas execuções em que não pensou, a conformidade foi 46%.

O framework muda a frequência com que o model pensa. O model pensou em 100% das execuções no Google ADK e no smolagents, 86% no Microsoft Agent Framework e 78% no CrewAI. Nos outros 9 frameworks, a taxa foi de 0 a 9%.

Quando o model não pensou, o formato da entrada decidiu a conformidade: 42 a 53% nos frameworks que passam a instrução sem alterações, 2% no Strands e 0% no AutoGen.

Por que o framework afeta o pensamento

Claude Haiku 5.5 decide em cada requisição se deve pensar, com base no que recebe. Todos os frameworks enviaram a mesma instrução e os mesmos dados, mas a arquitetura de cada framework decide o que mais chega junto com eles:

• Quanto contexto anterior cada agente recebe: Frameworks em estilo pipeline passam ao agente de atividades apenas os detalhes da viagem e a previsão (541 tokens, incluindo a instrução). O Google ADK e o Microsoft Agent Framework passam toda a conversa até o momento, incluindo chamadas e resultados de ferramentas anteriores (3.579 e 2.439 tokens).
• Qual template envolve a instrução: O smolagents a coloca dentro de um template de sistema longo com regras e exemplos de uso de ferramentas (2.162 tokens). O CrewAI a transforma em um papel, um objetivo e uma “tarefa atual” com uma saída esperada.
• Como as saídas dos agentes anteriores são apresentadas: Elas podem chegar como blocos de entrada simples, como mensagens de chat de outros agentes ou como respostas anteriores do próprio agente.

O tamanho sozinho não explica o resultado. A entrada do CrewAI para o agente de atividades tinha apenas 648 tokens, mas o model pensou em 78% das execuções. A do AutoGen tinha 1.093 tokens, e o model pensou em apenas 9% das execuções. Tanto o tamanho quanto a estrutura da entrada parecem importar.

Erros

O model não ignorou o clima: todas as violações ocorreram em dias nublados, e nenhuma execução colocou uma atividade em local fechado no dia ensolarado. A violação mais comum foi Vatican Museums, que representou 87% das escolhas em local fechado. Sem pensar, o model parece ter tratado o céu nublado como clima para atividades em local fechado, em vez de aplicar a regra de 50%. Quando o model pensou, seguiu a regra em todas as vezes.

Frameworks que passam o texto sem alterações

Esses frameworks não adicionam texto próprio; o agente recebe exatamente o que o desenvolvedor escreve. Em nosso teste, escrevemos a mesma entrada para os sete, então o agente de atividades recebeu uma requisição idêntica em cada um. O model pensou em de 0 a 3% das execuções, e a conformidade ficou entre 42 e 54%.

• LangGraph: Cada agente é um nó em um grafo de estado. O nó lê as saídas anteriores do estado compartilhado e constrói sua mensagem.
• LangChain: Os agentes são etapas em uma cadeia LCEL. Cada etapa constrói sua mensagem a partir dos valores passados ao longo da cadeia.
• Agno: Cada agente é uma etapa em um fluxo de trabalho. A etapa lê as saídas etapas anteriores pelo nome.
• LlamaIndex: Cada agente é uma etapa em um fluxo de trabalho orientado a eventos. Os eventos levam as saídas anteriores para a próxima etapa.
• OpenAI Agents SDK: Os agentes são chamados um após o outro no código. As transferências do SDK permitem que o model escolha o próximo agente, então não as usamos para uma sequência fixa.
• Pydantic IA: Os agentes são chamados um após o outro no código, seguindo o padrão de transferência programática descrito em sua documentação.
• CAMEL: Os agentes são chamados um após o outro no código. O recurso Workforce adiciona um agente coordenador com chamadas extras ao model, então não o usamos.

Frameworks que adicionam seu próprio formato

• CrewAI: Coloca a instrução em seu template de “papel, histórico, objetivo” e apresenta a etapa como uma “tarefa atual” com uma saída esperada, seguida pelas saídas tarefas anteriores. A entrada do agente de atividades tinha apenas 648 tokens, mas o model pensou em 78% das execuções, e 86% das execuções seguiram a regra.
• smolagents: Cada instrução entra no próprio template de sistema longo do smolagents, que explica como chamar ferramentas, dá exemplos e regras e exige que a resposta seja enviada por meio de uma ferramenta final_answer. Com esse template, tanto o pensamento quanto a conformidade com a regra chegaram a 100%.
• Google ADK: As respostas dos agentes anteriores, as chamadas de ferramentas e os resultados das ferramentas chegam uma a uma como notas “For context”, e cada instrução recebe uma linha de identidade. Com essa entrada de 3.579 tokens, o model pensou antes de cada resposta e nunca violou a regra.
• Microsoft Agent Framework: O agente recebe toda a conversa, incluindo chamadas de ferramentas, com as saídas dos agentes anteriores apresentadas como suas próprias respostas anteriores; a opção que o Claude exige adiciona “please continue.” no final. O pensamento ocorreu em 86 de 100 execuções, e a conformidade chegou a 92%.
• AutoGen: Na conversa em grupo do AutoGen, as respostas dos agentes anteriores chegam a cada agente como mensagens de chat. O model pensou em apenas 9 execuções, e essas 9 foram as únicas que seguiram a regra.
• Strands: As entradas chegam sob os títulos “Original Task” e “Inputs from previous nodes”. Nesse formato, o model nunca pensou e seguiu a regra em apenas 2 de 100 execuções.

Alguns desses formatos são configuráveis; Google ADK e Microsoft Agent Framework, por exemplo, têm configurações que reduzem a conversa que cada agente recebe. Usamos as configurações padrão em todos os frameworks.

Esses resultados vêm do Claude Haiku 5.5, que decide em cada requisição se deve pensar. Outros LLMs podem se comportar de maneira diferente, portanto a diferença entre os frameworks pode ser menor ou maior com outro model.

Recomendações do nosso teste

• Teste uma regra com o framework e o model que você planeja implantar. Uma instrução que funciona em um framework pode não dar o mesmo resultado em outro.
• Se uma regra é importante, use uma configuração de raciocínio mais alta ou ative o pensamento. Na configuração média que usamos, o model pulou o pensamento na maioria das execuções; todas as execuções em que pensou seguiram a regra, ao custo de mais tempo e tokens.
• Se uma regra for simples e exata (por exemplo, “em local fechado se a chance de chuva estiver acima de 50%”), verifique-a no código em vez de deixá-la a cargo do model. Uma pequena etapa de validação na saída do agente captura o erro em qualquer framework.
• Nos frameworks que enviam a cada agente toda a conversa, reduzir o contexto diminui o custo. No nosso teste, porém, esses frameworks também provocaram mais pensamento, então verifique se a conformidade com a regra se mantém após a redução.

Sobrecarga do framework e tempo de conclusão

• O código do framework adicionou 55 a 148 ms por execução, cerca de 1% do total. O restante foi o tempo de resposta do model.
• A sobrecarga não prevê a velocidade. O Strands, um dos frameworks mais rápidos, teve sobrecarga alta (115 ms); o Microsoft Agent Framework, o mais lento, teve sobrecarga baixa (73 ms).
• Chamadas extras ao model importam mais. Uma chamada de ferramenta repetida ou uma etapa extra adiciona uma chamada ao model, ou 1 a 3 segundos.
• O tempo de execução variou cerca de 2 segundos de uma execução para outra dentro de cada framework, portanto diferenças inferiores a cerca de meio segundo entre frameworks estão dentro do ruído.

O que os frameworks enviam para cada agente e o uso de tokens

O planejador de viagem é o último agente no fluxo de trabalho. Ele combina as saídas dos quatro agentes anteriores em um plano dia a dia e precisa apenas dessas quatro saídas, mas os frameworks enviaram a ele quantidades muito diferentes de texto. Os números abaixo são tokens de prompt por execução, somados entre os cinco agentes.

Frameworks que passam apenas as entradas necessárias

Esses frameworks executam os agentes como etapas em um pipeline. O planejador recebe 2 mensagens: sua instrução e as quatro saídas. Pequenas diferenças vêm da forma como cada framework escreve as definições de ferramentas.

• Agno: 6.052 tokens.
• LangGraph: 6.053 tokens.
• LangChain: 6.054 tokens.
• CAMEL: 6.094 tokens.
• OpenAI Agents SDK: 6.235 tokens. Suas definições de ferramentas são mais longas.
• Pydantic IA: 6.411 tokens. Suas definições de ferramentas são mais longas.
• LlamaIndex: 6.590 tokens. Suas descrições de ferramentas incluem a assinatura completa da função e a docstring.

Frameworks que adicionam um template ou entradas extras

• CrewAI: 7.456 tokens. Ele envolve cada instrução em seu template de “papel, histórico, objetivo”, enquadra a etapa como uma tarefa com saída esperada e anexa as saídas tarefas anteriores como contexto.
• Strands: 7.693 tokens. Ele repete a solicitação do usuário para todos os agentes como um bloco “Original Task”. As arestas que mantêm os agentes em ordem também dão a alguns agentes entradas extras; o agente de clima, por exemplo, recebe a saída do agente de voos.
• smolagents: 16.576 tokens. Ele envolve cada instrução em seu próprio template extenso, que explica o uso de ferramentas e inclui exemplos. O prompt do primeiro agente tinha 1.686 tokens, contra 173 na maioria dos outros frameworks.

Frameworks que compartilham toda a conversa

Esses frameworks executam os agentes como uma equipe que compartilha uma conversa, então cada agente vê o que veio antes dele.

• AutoGen: 8.419 tokens. Ele passa apenas as respostas finais dos agentes anteriores, como mensagens de chat; o planejador recebeu 6 mensagens.
• Microsoft Agent Framework: 13.252 tokens. Ele passa toda a conversa, incluindo chamadas e resultados de ferramentas anteriores; o planejador recebeu 11 mensagens.
• Google ADK: 17.315 tokens. Ele retransmite cada resposta anterior, chamada de ferramenta e resultado de ferramenta como uma nota separada de “For context”; o planejador recebeu 10 mensagens. A entrada do agente de clima tinha 6.358 tokens, contra cerca de 1.800 nos frameworks de pipeline.

Efeito no custo e na corretude

• A corretude não foi afetada. Em todos os 13 frameworks, os dados chegaram intactos ao planejador, com uma exceção em uma única execução do Microsoft Agent Framework.
• O custo foi afetado. 1.000 execuções custaram cerca de 1.4 USD nos frameworks de pipeline e 2.4 a 2.8 USD no Microsoft Agent Framework, no Google ADK e no smolagents.
• No Google ADK, no smolagents, no Microsoft Agent Framework e no CrewAI, o model pensou com mais frequência. Isso tornou as execuções mais longas, mas aumentou a conformidade com a regra.

Confiabilidade

• Todas as 1.300 execuções foram concluídas sem erros ou tempos limite.
• Em 1.299 de 1.300 execuções, os dados chegaram corretamente ao plano final.
• A única falha ocorreu no Microsoft Agent Framework. O planejador de viagem tinha todas as ofertas de voo em sua entrada, mas deixou os campos de voo vazios. Isto pode ter contribuído: o Microsoft Agent Framework passa as saídas dos agentes anteriores ao planejador como se o próprio planejador as tivesse escrito.

Chamadas extras ao model

Cada chamada extra ao model adicionou de 1 a 3 segundos a uma execução.

• CrewAI: Em 12 de 100 execuções, o agente de voos repetiu a mesma busca de voos, com os mesmos dados de entrada, depois de obter o resultado.
• smolagents: Ele aceita uma resposta somente por meio de sua ferramenta final_answer. Em 14 de 100 execuções, o model respondeu primeiro em texto simples, então o smolagents precisou de mais uma rodada.

Não perca os nossos benchmarks e insights baseados em dados. O botão abre o Google; selecionar a AIMultiple confirma que deseja ver a AIMultiple com mais frequência nos resultados de pesquisa do Google.

Adicionar como fonte preferencial

Configurações padrão que precisaram de alterações

Tivemos que alterar algumas configurações padrão para fazer os frameworks executarem este fluxo de trabalho:

• Microsoft Agent Framework: Sua cadeia sequencial não funcionou com o Claude (HTTP 400). A cadeia envia a cada agente uma conversa que termina com a resposta do agente anterior, que o Claude rejeita. A opção ensure_trailing_user_turnoption corrige isso adicionando uma mensagem de usuário no final da conversa.
• Agno: Por padrão, seu fluxo de trabalho pula uma etapa com falha e ainda relata a execução como bem-sucedida. Definimos a política de erro de etapa como “fail” para que os erros apareçam.
• Strands: Seu grafo inicia um agente assim que qualquer um dos agentes do qual ele depende termina. Com arestas simples, o planejador rodaria cedo demais e várias vezes, então adicionamos condições às arestas para manter a ordem.
• smolagents: Ele força o model a chamar uma ferramenta em cada etapa. O Claude rejeita isso quando o pensamento está ativado, então o definimos como “auto”.
• OpenAI Agents SDK: Ele usa a API Responses da OpenAI por padrão. Para usá-la com um endpoint de Chat Completions, que a maioria dos outros provedores oferece, você precisa da classe de model Chat Completions.

Pipeline ou conversa compartilhada para um fluxo de trabalho fixo

Quando a ordem dos agentes é fixa, cada agente precisa apenas de algumas saídas anteriores. Em nosso teste, passar somente essas saídas moveu os dados entre os agentes de forma tão confiável quanto compartilhar toda a conversa: 1.299 de 1.300 execuções foram corretas nos dois grupos. A conversa compartilhada no Google ADK e no Microsoft Agent Framework mais do que dobrou os tokens de prompt por execução. Conversas compartilhadas se adequam a agentes que precisam ver o raciocínio uns dos outros. Em um pipeline fixo, passar entradas explícitas custa menos, e você pode ver exatamente o que cada agente recebe.

Verifique o que seu framework envia ao model

Sete dos 13 frameworks enviaram ao agente de atividades exatamente o texto que escrevemos. Os outros seis adicionaram seus próprios templates, mensagens retransmitidas ou títulos, de cerca de 50 tokens extras no Strands a mais de 3.000 no Google ADK. Essas adições mudaram a frequência com que o model pensava e se ele seguia a regra. Antes de ajustar prompts em um sistema multiagente, registre a requisição final que cada agente envia ao model. Um proxy de log ou o rastreamento do framework mostra o que o framework adicionou.

O que determina a velocidade de um fluxo de trabalho multiagente

O código do framework levou cerca de 1% de cada execução. O restante veio do número de chamadas ao model e do tempo que cada chamada levou. Três alavancas decorrem disso:

• Menos chamadas ao model: Fique atento a chamadas de ferramentas repetidas e etapas extras; cada uma adicionou de 1 a 3 segundos.
• Entradas menores: Entradas mais curtas para cada agente reduzem os tokens e deixam menos conteúdo para o model ler.
• Agentes independentes em paralelo: Neste fluxo de trabalho, os agentes de voos e de clima não dependem um do outro. Executá-los em paralelo eliminaria o mais curto dos dois, cerca de 3 segundos. Não testamos a execução em paralelo; essa estimativa vem dos tempos por agente.

Metodologia do benchmark

Todos os frameworks executaram o mesmo fluxo de trabalho de planejamento de viagem com cinco agentes, sempre nesta ordem:

1. Parser: Extrai a origem, o destino, a data de partida e a duração da viagem da solicitação do usuário.
2. Localizador de voos: Chama uma ferramenta de busca de voos e lista as ofertas por preço.
3. Relator de clima: Chama uma ferramenta de clima para as datas da viagem.
4. Recomendador de atividades: Escolhe uma atividade por dia, usando a regra de local fechado/ao ar livre acima.
5. Planejador de viagem: Combina as quatro saídas em um plano dia a dia com o voo mais barato.

A solicitação do usuário foi: “Quero viajar de Berlim a Roma no dia 27 de outubro de 2026. Vou ficar por 3 dias.” Cada agente tinha a mesma instrução escrita em todos os frameworks e retornou sua resposta como JSON. Somente o localizador de voos e o relator de clima tinham ferramentas.

Dados das ferramentas

Ambas as ferramentas retornaram dados fixos, portanto todas as execuções em todos os frameworks receberam resultados de ferramentas idênticos:

• Voos: Seis ofertas de ida de Berlim a Roma. Elas são sintéticas: as companhias, horários e preços plausíveis não vêm de uma busca de tarifas ao vivo.
• Clima: Uma previsão real de Roma para 27 a 29 de outubro de 2026, registrada uma vez no WeatherAPI.com.

Como as ferramentas responderam instantaneamente, os tempos de conclusão refletem chamadas ao model e código do framework, não a latência da API.

Frameworks

• Versões testadas: LangGraph 1.2.17, LangChain 1.4.7, CrewAI 1.15.30, AutoGen 0.7.5, Microsoft Agent Framework 1.23.0, OpenAI Agents SDK 0.24.0, Google ADK 2.13.0, Agno 3.1.10, Pydantic IA 2.61.0, smolagents 1.26.0, LlamaIndex 0.14.25, Strands Agents 1.62.0 e CAMEL 0.2.90, todos no Python 3.12.
• Como os agentes foram executados: Cada framework executou os agentes com seu próprio mecanismo multiagente onde ele existia. O OpenAI Agents SDK, o Pydantic IA, o smolagents e o CAMEL não têm um mecanismo para sequência fixa, então seus agentes foram chamados um após o outro no código.
• Configurações: Todas as configurações permaneceram nos padrões, exceto as alterações listadas em “Configurações padrão que precisaram de alterações”.

Model e execuções

• Model: Cada agente em cada framework usou o Claude Haiku 5.5 por meio do OpenRouter, servido pela Anthropic, com a configuração de raciocínio fixada em médio. Configurações que um framework tentava adicionar, como temperatura, eram removidas antes de a requisição chegar ao model.
• Execuções: Cada framework executou o fluxo de trabalho 100 vezes, 1.300 execuções no total, em 27 de outubro de 2026. As execuções foram realizadas uma de cada vez, em ordem misturada entre os frameworks.
• Aquecimento: Antes de cada execução cronometrada, o mesmo fluxo de trabalho rodou uma vez contra um model de teste roteirizado, para que os custos de carregamento únicos não contassem no tempo medido.
• Limites: Cada execução foi limitada a 30 chamadas ao model e 300 segundos. Nenhuma execução atingiu qualquer um dos limites.

O que medimos

• Requisições: Um proxy de log registrou todas as requisições e respostas entre os frameworks e o model. Cada agente tinha seu próprio endpoint, então cada chamada ao model pôde ser rastreada até o agente que a fez. As chamadas de ferramentas foram registradas separadamente.
• Tempo de conclusão: Tempo do início do fluxo de trabalho até o plano final.
• Tokens e custo: Tokens de prompt, de conclusão e de pensamento, e o custo de cada chamada, conforme relatado pelo provedor.
• Sobrecarga do framework: A parte de uma execução que não foi gasta nem esperando pelo model nem executando ferramentas.
• Pensamento: Uma execução conta como uma em que o model pensou se o provedor relatou tokens de pensamento para a chamada do agente de atividades.
• Itinerário correto: O plano final contém o voo mais barato (número do voo e preço), as três datas da viagem, o clima de cada dia conforme previsto e a atividade e o cenário de cada dia exatamente como o recomendador de atividades os produziu.
• Conformidade com a regra: Todos os três dias seguem a regra de local fechado/ao ar livre. Como nenhum dia teve chance de chuva perto de 50%, a resposta correta foi uma atividade ao ar livre em todos os dias.

Cite este benchmark

Escolha o formato adequado ao local onde você vai publicar. Colar a versão com link no seu CMS preserva o backlink.

@misc{sipi2026,
  author = {Şipi, Nazlı},
  title  = {{Top 10+ Frameworks e Ferramentas de Orquestração Agêntica}},
  year   = {2026},
  month  = oct,
  howpublished    = {\url{https://aimultiple.com/agentic-orchestration}},
  note   = {AIMultiple. Acessado em 30 outubro 2026}
}

Registro de alterações

4 atualizações

Todas4Geral3Metodologia1

20262025

1. 27 jan

   Removida a seção "Agentic orchestration benchmark".

2. 26 jan

   Atualizada a seção 'Benchmark de orquestração agêntica' com novas métricas.

Nazlı Şipi

Pesquisadora de IA

Siga-nos

Nazlı é analista de dados na AIMultiple. Ela tem experiência anterior em análise de dados em vários setores, onde trabalhou transformando datasets complexos em insights acionáveis.

Ver perfil completo

Seja o primeiro a comentar

Seu endereço de e-mail não será publicado. Todos os campos são obrigatórios. Os comentários são deixados em seu idioma original.

Nome

Endereço de email

Comentário

0/450

Postar comentário