Top 13 frameworks de IA agêntica de código aberto

O smolagents não está no gráfico. Com 20.55 s e $4,52 por 1.000 execuções em média, ele teve de longe o maior tempo e custo, e incluí-lo tornou as diferenças entre os outros frameworks ilegíveis. Explicamos o porquê abaixo.

• Os três frameworks mais baratos são Agno ($1,41), CAMEL ($1,45) e Google ADK ($1,48). Os três executam as ferramentas uma após a outra e nunca encontram os erros que surgem quando as ferramentas não esperam uma pela outra. LangChain ($1,49) e LangGraph ($1,50) executam as ferramentas ao mesmo tempo, mas custam quase o mesmo, porque escrevem algumas das definições de ferramenta mais curtas.
• Microsoft Agent Framework é rápido (7.57 s), mas é o framework mais caro do gráfico ($1,88). Ele executa as ferramentas ao mesmo tempo, então 64% das execuções encontram um erro e repetem etapas, e escreve definições de ferramenta longas.
• A diferença de custo entre os 12 frameworks do gráfico é pequena: no máximo $0,47 por 1.000 execuções.
• 98% a 99% do tempo é gasto esperando pelo modelo. O próprio código do framework quase não afeta o tempo.

Executamos este benchmark pela primeira vez em fevereiro de 2026 com quatro frameworks no GPT-5.2: LangChain, LangGraph, AutoGen e CrewAI. Naquela época, o CrewAI levou cerca de duas vezes mais tempo que os outros três (52.7 s em média contra 27.5-29.6 s), e o framework mais pesado usou 64% mais tokens que o mais leve. Com as versões atuais, os quatro frameworks têm média de 8.20-8.39 s e a diferença de tokens é de 26%.

Veja nossa metodologia de benchmark para obter detalhes sobre como executamos os testes e analisamos os resultados.

Execução paralela e sequencial de ferramentas

O modelo às vezes solicita várias ferramentas de uma vez. Agno, CAMEL e Google ADK executam essas ferramentas uma após a outra: a próxima começa quando a anterior termina. Os outros dez frameworks iniciam todas ao mesmo tempo por padrão. Quando as ferramentas dependem umas das outras, iniciá-las juntas causa problemas, porque a segunda ferramenta não espera a primeira terminar. Em uma aplicação real, isso é como uma ferramenta gravar um registro no banco de dados enquanto outra tenta ler o mesmo registro.

O comportamento sequencial se aplica às chamadas síncronas que usamos. As arun() do Agno, as astep() do CAMEL e as ferramentas assíncronas no Google ADK executam as chamadas ao mesmo tempo.

Vimos isso em três tarefas:

• Tarefa 1 (carregar os dados e depois calcular):
  • O modelo solicitou as duas etapas juntas. Nos frameworks que executam ferramentas ao mesmo tempo, o cálculo começou antes de os dados serem carregados e falhou, e o modelo solicitou novamente.
  • Isso é uma chamada extra de LLM. A tarefa levou 2.5-3 s e $0,48-0.64 por 1.000 execuções em Agno, Google ADK e CAMEL, contra 3.5-5.2 s e $0,74-1.05 nos dez frameworks que executam ferramentas ao mesmo tempo.
• Tarefa 3 (aplicar dois filtros um após o outro e depois calcular):
  • O modelo solicitou as três etapas juntas. O cálculo foi executado antes de o segundo filtro terminar, então usou 1.483 clientes em vez de 592.
  • 10 das 13 execuções com falha no benchmark vêm disso: 3 respostas erradas em cada um, LangChain e LangGraph, 1 no Microsoft Agent Framework e 3 execuções do CrewAI interrompidas por um erro de ferramenta. Em 6 das respostas erradas, o modelo disse que o resultado não era confiável em vez de fornecer um número.
  • O modelo muitas vezes percebeu a inconsistência e repetiu etapas. O Microsoft Agent Framework repetiu etapas em 59% das execuções e foi o framework mais caro nesta tarefa depois do smolagents ($1,96 por 1.000 execuções). O Google ADK nunca repetiu uma etapa e foi o mais rápido (8.05 s).
• Tarefa 5 (reconhecer as colunas JSON e de texto e processar cada uma com a ferramenta certa):
  • Aqui os frameworks não diferiram. Em todas as 1.300 execuções, o modelo inspecionou as duas colunas antes de processá-las e escolheu a ferramenta certa.
  • A diferença novamente veio da execução paralela. Em 85% das execuções do CrewAI e 69% das execuções do Microsoft Agent Framework, uma ferramenta foi executada antes de seus dados estarem prontos e etapas foram repetidas.
  • As respostas estavam corretas, mas o CrewAI foi o framework mais caro nesta tarefa depois do smolagents ($2,08 por 1.000 execuções).

Usamos a configuração padrão de cada framework. Executar ferramentas ao mesmo tempo só economiza tempo quando as ferramentas são lentas, como chamadas de API que levam segundos cada uma. Nossas ferramentas terminam em milissegundos, então aqui isso trouxe os erros acima e nenhum ganho de velocidade. Se suas ferramentas forem lentas e independentes, mantenha o padrão. Se elas compartilham dados, há duas opções:

• Configure o framework para executar as ferramentas uma de cada vez. SequentialToolExecutor no Strands Agents e max_tool_threads=1 no smolagents fazem isso. No LlamaIndex, allow_parallel_tool_calls=False faz o modelo solicitar uma ferramenta por resposta.
• Escreva ferramentas que não dependam umas das outras, por exemplo combinando “filtrar” e “calcular” em uma única ferramenta.

Como instruções e histórico chegam ao modelo

A maioria dos frameworks envia nossas instruções como estão e envia as etapas anteriores como mensagens de ferramenta padrão. O smolagents coloca nossas instruções dentro de seu próprio modelo de 6.780 caracteres e envia as etapas anteriores novamente como texto simples. Essa diferença apareceu em três lugares:

• A primeira solicitação é maior: 4.428 tokens em média no smolagents, contra 1.917-2.822 nos outros frameworks.
• O modelo raciocinou mais: o mesmo modelo produziu 1.050 tokens de raciocínio por execução em média no smolagents, contra 122-228 nos outros frameworks. Tokens de raciocínio são cobrados como saída e levam tempo para gerar. Em nosso benchmark de orquestração agêntica, o modelo também raciocinou em todas as execuções do smolagents.
• Há mais chamadas de LLM: 6.52 por execução em média no smolagents, contra 3.73-4.78 nos outros. A maior parte disso vem de seu comportamento diferente na Tarefa 4 (abaixo).

A diferença aumenta em tarefas com mais etapas. A Tarefa 2 pediu ao agente para calcular e comparar dois grupos: a receita perdida de clientes com e sem suporte técnico. O agente filtra e calcula cada grupo separadamente, então a tarefa leva várias etapas, e o modelo e o histórico são enviados novamente a cada etapa.

• O smolagents enviou 31.200 tokens por execução em média nesta tarefa; os outros frameworks enviaram entre 9.244 e 14.161.
• O smolagents terminou a tarefa em 24.34 s e a $4,38 por 1.000 execuções, 2-3 vezes os outros frameworks. Duas execuções do smolagents atingiram o limite de chamadas de LLM sem resposta.
• A maioria dos outros frameworks terminou em 10-12 s. O Google ADK foi o mais rápido, com 7.58 s e 3.39 chamadas de LLM, e o CAMEL foi o mais barato, a $1.34.

Usamos o modelo padrão do smolagents. Você pode passar um mais curto com o parâmetro prompt_templates.

Comportamento quando uma ferramenta falha

A Tarefa 4 testou o que o agente faz quando uma ferramenta está quebrada. A ferramenta que calcula a taxa de churn por forma de pagamento falha nas três primeiras chamadas (erro de conexão, timeout, limite de taxa) e funciona na quarta. Cada mensagem de erro diz “tentar novamente”. O agente tem duas opções: tentar a ferramenta novamente ou filtrar e calcular cada forma de pagamento separadamente.

• Em doze frameworks, o modelo tentou novamente a ferramenta após cada erro em 97% a 100% das execuções e obteve o resultado na quarta tentativa. A tarefa levou 5.7-7.1 chamadas de LLM e 7.9-10.4 s em média.
• No smolagents, o mesmo modelo desistiu da ferramenta após o segundo ou terceiro erro em 96% das execuções e calculou as quatro formas de pagamento uma a uma. A tarefa levou 13.76 chamadas de LLM e 41.07 s em média, e custou $9,96 por 1.000 execuções, contra $1,90-2.75 nos outros frameworks.
• A mensagem de erro foi a mesma em todos os frameworks. O que difere no smolagents é que ele mostra o erro e as etapas anteriores como texto simples dentro de seu próprio modelo. Achamos que a diferença de comportamento vem disso, mas não testamos separadamente.

O modelo também afeta esse comportamento: em uma verificação com GPT-5.2 e uma execução por framework, 6 dos 13 frameworks desistiram da ferramenta e seguiram o outro caminho.

Mostramos os erros ao modelo como eles eram. Se erros temporários, como erros de conexão, timeouts e limites de taxa, forem tratados com novas tentativas dentro da ferramenta, o modelo nunca os vê, e o comportamento deixa de depender do framework.

Como as definições de ferramentas são escritas para o modelo

Demos a todos os frameworks as mesmas funções Python com as mesmas descrições. Cada framework as transforma nas definições de ferramentas que o modelo lê, à sua própria maneira. Isso mudou o tamanho da primeira solicitação: 1.917 tokens em média no Agno, 2.754 no AutoGen. A maior parte da diferença vem das definições de ferramentas:

• Agno, LangChain e LangGraph usam apenas a primeira frase da descrição da função como descrição da ferramenta e colocam as descrições dos parâmetros nos parâmetros. Suas definições são as mais curtas.
• AutoGen, Microsoft Agent Framework, CrewAI e Google ADK enviam a descrição completa da função, incluindo as descrições de parâmetros e retorno.
• O LlamaIndex também adiciona a assinatura da função no início.
• Pydantic IA escreve a descrição em tags XML e adiciona a descrição de retorno.

Dois frameworks adicionam texto às instruções. O CrewAI coloca as instruções em um modelo de papel, histórico e objetivo, e o Google ADK adiciona uma linha que começa com “Você é um agente” no final. Essas adições são menores do que as diferenças nas definições de ferramentas.

As definições de ferramentas são enviadas novamente a cada solicitação, então a diferença adiciona custo a cada etapa. Agno e AutoGen fizeram quase o mesmo número de chamadas de LLM por execução (4.40 e 4.45), mas o AutoGen enviou 37% mais tokens ao modelo em média (14.932 contra 10.899).

Demos a todos os frameworks as mesmas funções e descrições. Manter as descrições de funções curtas ou dar ao framework uma descrição de ferramenta separada reduz essa diferença. No CrewAI, o texto adicionado às instruções pode ser alterado com system_template e prompt_template.

Sobrecarga do código do framework

O próprio código do framework adiciona 0.04-0.14 s a uma execução em média, menos de 2% do tempo total.

A inicialização leva cerca de 1 s no Google ADK, 0.6 s no CAMEL e menos de 0.35 s nos outros. O tempo de inicialização não está incluído nos resultados do benchmark.

Em sistemas que iniciam do zero a cada solicitação, como funções serverless, o tempo de inicialização é adicionado a cada solicitação. Carregar o framework uma vez quando a aplicação inicia e manter o processo em execução elimina isso.

Suporte a múltiplos agentes

Este benchmark usou um único agente, mas todos os 13 frameworks suportam executar vários agentes juntos. Verificamos as informações desta seção e das três seguintes no código-fonte das versões que testamos. As abordagens se dividem em três grupos:

• Definido como um fluxo: LangGraph (nós e arestas), Microsoft Agent Framework (WorkflowBuilder), Google ADK (SequentialAgent, ParallelAgent, LoopAgent), Strands Agents (Graph e Swarm) e LlamaIndex (AgentWorkflow com transferências entre agentes).
• Definido como uma equipe: CrewAI (um Crew sequencial ou um com agente gerente), AutoGen (RoundRobinGroupChat, SelectorGroupChat, Swarm), Agno (Team) e CAMEL (Workforce, RolePlaying).
• Passar o trabalho para outro agente: OpenAI Agents SDK (handoffs), smolagents (managed_agents), Pydantic IA e LangChain (entregar um agente a outro como ferramenta).

Medimos como esses frameworks lidam com um fluxo de cinco agentes em nosso benchmark de orquestração agêntica.

MCP suporte

MCP (Model Context Protocol) dá aos agentes uma forma padrão de se conectar a ferramentas e fontes de dados externas. Todos os 13 frameworks podem usar ferramentas de servidores MCP.

MCP client incluído no pacote próprio do framework:

• Agno
• CAMEL
• CrewAI
• Google ADK
• LangChain (dependência extra: langchain[mcp])
• Microsoft Agent Framework
• OpenAI Agents SDK
• Pydantic IA
• smolagents (dependência extra: smolagents[mcp])
• Strands Agents

Pacote separado necessário:

• AutoGen: autogen-ext
• LangGraph: nenhum client MCP próprio; usa o LangChain com suporte MCP ou langchain-mcp-adapters
• LlamaIndex: llama-index-tools-mcp

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

Aprovação humana (human-in-the-loop)

Algumas ações não devem acontecer sem a aprovação de uma pessoa, como enviar um e-mail ou excluir um registro. Os frameworks suportam isso de três maneiras.

Pedir aprovação antes de uma ferramenta ser executada:

• Agno: requires_confirmation
• Google ADK: require_confirmation
• LangChain: HumanInTheLoopMiddleware
• Microsoft Agent Framework: approval_mode
• OpenAI Agents SDK: needs_approval
• Pydantic IA: requires_approval

Pausar o fluxo e esperar a resposta de uma pessoa:

• LangGraph: interrupt
• LlamaIndex: eventos que esperam entrada humana
• Strands Agents: interrupções

Conectar uma pessoa como agente ou ferramenta:

• AutoGen: UserProxyAgent
• CAMEL: HumanToolkit
• CrewAI: feedback por meio de human_input no final de uma tarefa
• smolagents: UserInputTool

Memória

Todos os frameworks mantêm o histórico dentro de uma tarefa. A diferença está na memória persistente entre tarefas e conversas.

Memória persistente integrada:

• Agno: MemoryManager
• AutoGen: Memory
• CAMEL: LongtermAgentMemory
• CrewAI: a configuração de memória em um Crew
• Google ADK: serviços de memória
• LangChain: checkpointers e stores
• LangGraph: checkpointers e stores
• LlamaIndex: Memory
• Microsoft Agent Framework: provedores de contexto e histórico
• OpenAI Agents SDK: sessões
• Strands Agents: gerenciadores de sessão

Sem memória persistente integrada (a aplicação armazena o histórico e o passa ao agente na próxima execução):

• Pydantic IA
• smolagents

Melhores frameworks agênticos

LangGraph

Ele define um agente como um grafo de nós e arestas, e o desenvolvedor gerencia explicitamente o estado passado entre as etapas. Possui versões em Python e JavaScript, e as execuções podem ser rastreadas na plataforma LangSmith do LangChain.

A execução mais longa do LangGraph na Tarefa 3 fez 25 chamadas de ferramenta antes de chegar à resposta correta, e 16 delas foram repetições. Tirando o smolagents, a execução mais longa em qualquer outro framework parou em 21 chamadas de ferramenta.

LangChain

O framework de propósito geral da equipe do LangChain para aplicações de LLM. Desde a versão 1.0, os agentes são construídos com create_agent e executados no runtime do LangGraph. O middleware pode alterar o loop do agente, e middlewares prontos cobrem resumir históricos longos, mascarar dados pessoais, tentar novamente após erros e recorrer a outro modelo.

Como o create_agent roda no LangGraph, ele enviou ao modelo as mesmas instruções e definições de ferramentas que o LangGraph, e os dois frameworks terminaram com quase o mesmo tempo e custo.

CrewAI

Ele define agentes por papel, objetivo e histórico e os executa com tarefas como uma equipe (um crew). Sobre os crews, os Flows conectam etapas por meio de eventos, e a empresa também oferece uma plataforma empresarial paga.

Foi o framework mais rápido na Tarefa 4 (7.85 s) e fez o menor número de chamadas de LLM lá (5.68 em média).

AutoGen

O framework do Microsoft Research no qual os agentes trabalham enviando mensagens uns aos outros. Ele tem um design em camadas (Core, AgentChat e Extensions), e o AutoGen Studio, uma interface sem código, vem como um pacote separado. A Microsoft recomenda o Microsoft Agent Framework para novos projetos.

Por padrão, o AssistantAgent para após uma rodada de chamadas de ferramenta e retorna o resultado da ferramenta como resposta (max_tool_iterations=1). Tarefas de várias etapas precisam de um valor maior, e nós o aumentamos.

Microsoft Agent Framework

O framework da Microsoft que une o AutoGen e o Semantic Kernel. Ele suporta Python e .NET. Oferece rastreamento via OpenTelemetry e middleware para chamadas de agente, e uma interface de desenvolvimento chamada DevUI vem como um pacote separado.

Foi o framework mais rápido na Tarefa 5 (6.50 s), embora muitas vezes repetisse etapas.

OpenAI Agents SDK

O framework da OpenAI e o sucessor do Swarm, construído em torno de agentes, ferramentas, handoffs e guardrails. Possui versões em Python e TypeScript. Por padrão, ele envia um rastreamento de cada execução ao painel de rastreamento da OpenAI (nós o desativamos para o benchmark). Inclui módulos separados para agentes de voz e tempo real. Usa a API Responses da OpenAI por padrão, portanto modelos de outros provedores precisam da classe de modelo Chat Completions.

Google ADK

Funciona diretamente com o Gemini e com outros modelos por meio do LiteLLM, que foi o que usamos. Inclui uma interface de desenvolvimento local (adk web) e uma ferramenta de avaliação (adk eval), e os agentes podem ser implantados a partir da linha de comando no Vertex AI Agent Engine, Cloud Run ou GKE.

Foi o framework mais rápido em média (6.79 s) e ficou entre os três mais rápidos em todas as cinco tarefas. Também fez o menor número de chamadas de LLM por execução (3.73 em média).

Agno

Ele vem com um grande catálogo de kits de ferramentas prontos e oferece o AgentOS, um runtime para disponibilizar e gerenciar agentes como uma API em sua própria infraestrutura.

No Agno, o modelo quase nunca escreveu comentários ao lado de suas chamadas de ferramenta: fez isso em 0,2% das rodadas de chamadas de ferramenta, contra 3% a 26% nos outros frameworks. Esses comentários são cobrados como tokens de saída.

Pydantic IA

Ele valida os argumentos de ferramentas e a saída dos agentes com modelos Pydantic e pede ao modelo para corrigir um argumento inválido. Um mecanismo tipado deps passa dependências, como conexões de banco de dados, para as ferramentas. As execuções podem ser rastreadas com o Pydantic Logfire e tornadas duráveis contra interrupções com Temporal, DBOS ou Prefect.

smolagents

Sua abordagem mais conhecida é o CodeAgent, que chama ferramentas escrevendo código Python em vez de JSON e executa esse código localmente ou em ambientes isolados, como E2B, Docker ou Modal. Ferramentas e agentes podem ser compartilhados no Hugging Face Hub. Testamos o ToolCallingAgent, que faz chamadas de ferramenta em JSON, portanto o CodeAgent não faz parte desses resultados.

Como ele retorna a resposta por meio de uma ferramenta separada final_answer, 99,6% de suas saídas eram JSON simples. Nos outros frameworks, 17% a 41% das respostas vieram envolvidas em um bloco de código markdown.

LlamaIndex

Ele inclui componentes para carregar, dividir, indexar e consultar documentos, e um mecanismo de consulta pode ser dado a um agente como ferramenta com QueryEngineTool. Para agentes, oferece FunctionAgent e AgentWorkflow, que conecta vários agentes. Possui versões em Python e TypeScript.

Foi o framework mais caro do gráfico nas Tarefas 2 e 4, as tarefas com mais etapas ($1,91 e $2,75 por 1.000 execuções). Suas longas definições de ferramentas são enviadas novamente a cada etapa, então a diferença aumenta com o número de etapas.

Strands Agents

Ele deixa o planejamento e a escolha de ferramentas para o modelo e mantém o loop do agente simples. Se nenhum modelo for definido, ele usa um modelo Claude no Amazon Bedrock, e tem provedores integrados para Anthropic, OpenAI, Gemini, Mistral, Ollama e LiteLLM. Ele rastreia execuções com OpenTelemetry.

Em todas as 100 execuções da Tarefa 1, o modelo primeiro chamou a ferramenta de cálculo sem carregar os dados, recebeu um erro e carregou os dados em uma etapa separada. Por causa dessa etapa extra, o Strands foi o framework mais lento do gráfico na Tarefa 1 (5.18 s).

CAMEL

Um framework agêntico da comunidade CAMEL-IA que surgiu de pesquisas com múltiplos agentes; o OWL é construído sobre ele. Além de kits de ferramentas prontos, inclui módulos para geração de dados sintéticos e benchmarks, portanto também se destina ao uso em pesquisa.

Foi o framework mais lento do gráfico na Tarefa 3 (14.43 s). Nessa tarefa, o modelo fez 4.73 chamadas de LLM e produziu 598 tokens de raciocínio por execução em média no CAMEL, contra 3.22 e 207 no Google ADK.

Metodologia do benchmark

Todas as tarefas usam os mesmos dados: 5.000 clientes amostrados do dataset de churn de clientes de telecom da IBM. Adicionamos uma coluna JSON (dados de dispositivos) e uma coluna de texto (notas de suporte) ao dataset. O agente primeiro carrega os dados, depois filtra e calcula com ferramentas, e retorna a resposta em um formato JSON fixo.

• Tarefa 1, cálculo básico: Taxa de churn por tipo de contrato. Mede quanto overhead o framework adiciona ao trabalho mais simples.
• Tarefa 2, comparação de dois grupos: Receita mensal perdida de clientes com e sem suporte técnico. Mede se dois resultados separados permanecem corretos ao longo das etapas.
• Tarefa 3, limites: Taxa de churn de clientes com menos de 1 ano de permanência que pagam mais de $70 por mês. Mede a conversão de frases nos números certos e a aplicação de dois filtros um após o outro.
• Tarefa 4, ferramenta quebrada: Taxa de churn por forma de pagamento. A ferramenta necessária falha três vezes e funciona na quarta. Mede o que o agente faz quando uma ferramenta falha.
• Tarefa 5, dados mistos: Contagens de dispositivos (da coluna JSON) e palavras-chave de reclamações (da coluna de texto) para clientes que cancelaram e pagam mais de $100 por mês. Mede se o agente reconhece os tipos de coluna e escolhe a ferramenta certa.

Configuração

• Modelo: Claude Haiku 5.5 por meio do OpenRouter com o provedor Anthropic, esforço de raciocínio médio.
• 100 execuções por framework e tarefa, 6.500 execuções no total. Data: 27 de outubro de 2026.
• Limites por execução: 15 chamadas de LLM nas Tarefas 1-3, 25 nas Tarefas 4-5 e 420 s.
• Todos os frameworks receberam as mesmas instruções, o mesmo texto de tarefa e as mesmas ferramentas. Configuramos cada framework da maneira padrão e não alteramos seu comportamento padrão. Apenas aumentamos os limites de etapas o suficiente para as tarefas terminarem e alteramos uma configuração em cada um, CrewAI, smolagents e AutoGen, para que pudessem funcionar com Claude.
• Todas as solicitações passaram pelo mesmo proxy de registro. O proxy aplicou o mesmo modelo e configuração de raciocínio a todas as solicitações e removeu configurações de amostragem que alguns frameworks adicionam, como a temperatura de 0.1 que o LlamaIndex envia.
• Cada execução rodou em seu próprio processo após uma passada de aquecimento não medida. As execuções rodaram três por vez em ordem aleatória.
• Comparamos cada resposta com a resposta correta calculada pelas mesmas ferramentas.
• Os resultados para nossa amostra de 5.000 clientes diferem dos resultados públicos conhecidos do dataset, portanto o modelo não pode responder de memória.
• Versões testadas: LangGraph 1.2.17, LangChain 1.4.7, CrewAI 1.15.30, AutoGen AgentChat 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, CAMEL 0.2.90.

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{dilmegani2026,
  author = {Dilmegani, Cem and Şipi, Nazlı},
  title  = {{Top 13 frameworks de IA agêntica de código aberto}},
  year   = {2026},
  month  = oct,
  howpublished    = {\url{https://aimultiple.com/agentic-frameworks}},
  note   = {AIMultiple. Acessado em 30 outubro 2026}
}

Registro de alterações

10 atualizações

Todas10Geral9Metodologia1

20262025

1. 2 mar

   Substituídos os resultados e a análise do benchmark na seção "Agentic AI frameworks benchmark".

2. 22 jan

   Removida uma mudança de metodologia que descrevia como as tarefas eram integradas em arquiteturas baseadas em agentes.

Cem Dilmegani

Analista Principal

Siga-nos

Cem é o analista principal da AIMultiple desde 2017.

O trabalho de Cem na AIMultiple foi citado por publicações globais líderes, incluindo Business Insider, Forbes, Morning Brew e Washington Post, por empresas globais como Deloitte e HPE, ONGs como o World Economic Forum e organizações supranacionais como a European Commission. [1], [2], [3], [4], [5]

Ao longo de sua carreira, Cem atuou como consultor de tecnologia, comprador de tecnologia e empreendedor de tecnologia. Ele aconselhou empresas sobre suas decisões de tecnologia na McKinsey & Company e na Altman Solon por mais de uma década. Ele também publicou um relatório da McKinsey sobre digitalização.

Ele liderou a estratégia de tecnologia e as compras de uma operadora de telecomunicações, reportando-se ao CEO. Ele também liderou o crescimento comercial da empresa de deep tech Hypatos, que atingiu uma receita recorrente anual de 7 dígitos e uma avaliação de 9 dígitos partindo do zero em 2 anos. O trabalho de Cem na Hypatos foi coberto por publicações de tecnologia líderes como TechCrunch e Business Insider.

Cem fala regularmente em conferências internacionais de tecnologia. Ele se formou como engenheiro da computação pela Bogazici University e possui um MBA pela Columbia Business School.

Ver perfil completo

Pesquisado por

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

Comentários 1

Compartilhe suas ideias

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

Chaitanya

Dec 19, 2025 at 01:47

Thank you for this informative and detailed article! It helped me get a reading on these frameworks.

Responder