I 13 migliori framework open-source di IA agentica

smolagents non è nel grafico. Con una media di 20.55 s e $4,52 per 1.000 esecuzioni, ha avuto di gran lunga il tempo e il costo più alti, e includerlo rendeva illeggibili le differenze tra gli altri framework. Spieghiamo perché di seguito.

• I tre framework più economici sono Agno ($1,41), CAMEL ($1,45) e Google ADK ($1,48). Tutti e tre eseguono gli strumenti uno dopo l'altro e non incorrono mai negli errori causati dagli strumenti che non si attendono tra loro. LangChain ($1,49) e LangGraph ($1,50) eseguono gli strumenti contemporaneamente ma costano più o meno lo stesso, perché scrivono alcune delle definizioni degli strumenti più brevi.
• Microsoft Agent Framework è veloce (7.57 s) ma è il framework più costoso nel grafico ($1,88). Esegue gli strumenti contemporaneamente, quindi il 64% delle sue esecuzioni incontra un errore e ripete i passaggi, e scrive definizioni degli strumenti lunghe.
• Il divario di costo tra i 12 framework nel grafico è piccolo: al massimo $0,47 per 1.000 esecuzioni.
• Dal 98% al 99% del tempo è dedicato all'attesa del modello. Il codice proprio del framework non ha quasi nessun effetto sul tempo.

Abbiamo eseguito per la prima volta questo benchmark a febbraio 2026 con quattro framework su GPT-5.2: LangChain, LangGraph, AutoGen e CrewAI. Allora CrewAI impiegava circa il doppio del tempo rispetto agli altri tre (52.7 s in media contro 27.5-29.6 s), e il framework più pesante usava il 64% di token in più rispetto al più leggero. Con le versioni attuali, i quattro framework hanno una media di 8.20-8.39 s e il divario di token è del 26%.

Consulta la nostra metodologia del benchmark per i dettagli su come abbiamo eseguito i test e analizzato i risultati.

Esecuzione parallela e sequenziale degli strumenti

Il modello a volte richiede più strumenti contemporaneamente. Agno, CAMEL e Google ADK eseguono questi strumenti uno dopo l'altro: il successivo inizia quando il precedente termina. Gli altri dieci framework li avviano tutti contemporaneamente per impostazione predefinita. Quando gli strumenti dipendono l'uno dall'altro, avviarli insieme causa problemi, perché il secondo strumento non aspetta che il primo finisca. In un'applicazione reale, è come se uno strumento scrivesse un record del database mentre un altro tentasse di leggere lo stesso record.

Il comportamento sequenziale si applica alle chiamate sincrone che abbiamo utilizzato. arun() di Agno, astep() di CAMEL e gli strumenti asincroni in Google ADK eseguono le chiamate contemporaneamente.

Lo abbiamo osservato in tre attività:

• Task 1 (caricare i dati, poi calcolare):
  • Il modello ha richiesto entrambi i passaggi insieme. Nei framework che eseguono gli strumenti contemporaneamente, il calcolo è iniziato prima che i dati fossero caricati ed è fallito, e il modello lo ha richiesto di nuovo.
  • Si tratta di una chiamata LLM in più. L'attività ha richiesto 2.5-3 s e $0,48-0.64 per 1.000 esecuzioni in Agno, Google ADK e CAMEL, contro 3.5-5.2 s e $0,74-1.05 nei dieci framework che eseguono gli strumenti contemporaneamente.
• Task 3 (applicare due filtri uno dopo l'altro, poi calcolare):
  • Il modello ha richiesto tutti e tre i passaggi insieme. Il calcolo è stato eseguito prima che il secondo filtro finisse, quindi ha usato 1.483 clienti invece di 592.
  • 10 delle 13 esecuzioni fallite nel benchmark derivano da questo: 3 risposte errate ciascuna in LangChain e LangGraph, 1 in Microsoft Agent Framework e 3 esecuzioni di CrewAI interrotte da un errore dello strumento. In 6 delle risposte errate, il modello ha detto che il risultato era inaffidabile invece di fornire un numero.
  • Il modello ha spesso notato l'incoerenza e ripetuto i passaggi. Microsoft Agent Framework ha ripetuto i passaggi nel 59% delle esecuzioni ed è stato il framework più costoso in questa attività dopo smolagents ($1,96 per 1.000 esecuzioni). Google ADK non ha mai ripetuto un passaggio ed è stato il più veloce (8.05 s).
• Task 5 (riconoscere le colonne JSON e di testo e processare ciascuna con lo strumento giusto):
  • Qui i framework non differivano. In tutte le 1.300 esecuzioni, il modello ha esaminato entrambe le colonne prima di processarle e ha scelto lo strumento giusto.
  • La differenza è venuta di nuovo dall'esecuzione parallela. Nel 85% delle esecuzioni di CrewAI e nel 69% delle esecuzioni di Microsoft Agent Framework, uno strumento è stato eseguito prima che i suoi dati fossero pronti e i passaggi sono stati ripetuti.
  • Le risposte erano corrette, ma CrewAI è stato il framework più costoso in questa attività dopo smolagents ($2,08 per 1.000 esecuzioni).

Abbiamo usato l'impostazione predefinita di ciascun framework. Eseguire gli strumenti contemporaneamente fa risparmiare tempo solo quando gli strumenti sono lenti, come le chiamate API che richiedono secondi ciascuna. I nostri strumenti terminano in millisecondi, quindi qui ha portato agli errori sopra descritti e a nessun guadagno di velocità. Se i tuoi strumenti sono lenti e indipendenti, mantieni l'impostazione predefinita. Se condividono dati, ci sono due opzioni:

• Configurare il framework per eseguire gli strumenti uno alla volta. SequentialToolExecutor in Strands Agents e max_tool_threads=1 in smolagents fanno questo. In LlamaIndex, allow_parallel_tool_calls=False fa sì che il modello richieda uno strumento per risposta.
• Scrivere strumenti che non dipendono l'uno dall'altro, ad esempio combinando “filtrare” e “calcolare” in un unico strumento.

Come le istruzioni e la cronologia arrivano al modello

La maggior parte dei framework invia le nostre istruzioni così come sono e invia i passaggi precedenti come messaggi standard degli strumenti. smolagents colloca le nostre istruzioni all'interno del suo modello di 6.780 caratteri e invia di nuovo i passaggi precedenti come testo semplice. Questa differenza si è manifestata in tre punti:

• La prima richiesta è più grande: 4.428 token in media in smolagents, contro 1.917-2.822 negli altri framework.
• Il modello ha pensato di più: lo stesso modello ha prodotto 1.050 token di ragionamento in media per esecuzione in smolagents, contro 122-228 negli altri framework. I token di ragionamento vengono fatturati come output e richiedono tempo per essere generati. Nel nostro benchmark di orchestrazione agentica, il modello ha pensato anche in ogni esecuzione di smolagents.
• Ci sono più chiamate LLM: 6.52 per esecuzione in media in smolagents, contro 3.73-4.78 negli altri. La maggior parte di questo deriva dal suo comportamento diverso sull'attività 4 (sotto).

Il divario cresce sulle attività con più passaggi. L'attività 2 chiedeva all'agente di calcolare e confrontare due gruppi: i ricavi persi dai clienti con e senza supporto tecnico. L'agente filtra e calcola ciascun gruppo separatamente, quindi l'attività richiede diversi passaggi, e il modello e la cronologia vengono inviati di nuovo a ogni passaggio.

• smolagents ha inviato 31.200 token per esecuzione in media in questa attività; gli altri framework hanno inviato tra 9.244 e 14.161.
• smolagents ha terminato l'attività in 24.34 s e a $4,38 per 1.000 esecuzioni, 2-3 volte gli altri framework. Due esecuzioni di smolagents hanno raggiunto il limite di chiamate LLM senza una risposta.
• La maggior parte degli altri framework ha terminato in 10-12 s. Google ADK è stato il più veloce con 7.58 s con 3.39 chiamate LLM, e CAMEL è stato il più economico a $1.34.

Abbiamo usato il modello predefinito di smolagents. Puoi passare un modello più breve con il parametro prompt_templates.

Comportamento quando uno strumento fallisce

L'attività 4 ha testato cosa fa l'agente quando uno strumento è rotto. Lo strumento che calcola il tasso di abbandono per metodo di pagamento fallisce nelle prime tre chiamate (errore di connessione, timeout, limite di velocità) e funziona alla quarta. Ogni messaggio di errore dice “riprova”. L'agente ha due opzioni: riprovare lo strumento, oppure filtrare e calcolare separatamente ciascun metodo di pagamento.

• In dodici framework, il modello ha riprovato lo strumento dopo ogni errore nel 97% al 100% delle esecuzioni e ha ottenuto il risultato al quarto tentativo. L'attività ha richiesto 5.7-7.1 chiamate LLM e 7.9-10.4 s in media.
• In smolagents, lo stesso modello ha rinunciato allo strumento dopo il secondo o terzo errore nel 96% delle esecuzioni e ha calcolato i quattro metodi di pagamento uno per uno. L'attività ha richiesto 13.76 chiamate LLM e 41.07 s in media, ed è costata $9,96 per 1.000 esecuzioni, contro $1,90-2.75 negli altri framework.
• Il messaggio di errore era lo stesso in ogni framework. Ciò che differisce in smolagents è che mostra l'errore e i passaggi precedenti come testo semplice all'interno del proprio modello. Pensiamo che la differenza di comportamento derivi da questo, ma non l'abbiamo testato separatamente.

Anche il modello influisce su questo comportamento: in un controllo con GPT-5.2 e una sola esecuzione per framework, 6 dei 13 framework hanno rinunciato allo strumento e hanno preso l'altra strada.

Abbiamo mostrato gli errori al modello così come erano. Se gli errori temporanei come errori di connessione, timeout e limiti di velocità vengono ritentati all'interno dello strumento, il modello non li vede mai, e il comportamento non dipende più dal framework.

Come vengono scritte le definizioni degli strumenti per il modello

Abbiamo fornito a ogni framework le stesse funzioni Python con le stesse descrizioni. Ogni framework le trasforma nelle definizioni degli strumenti che il modello legge, a modo suo. Questo ha cambiato la dimensione della prima richiesta: 1.917 token in media in Agno, 2.754 in AutoGen. La maggior parte della differenza deriva dalle definizioni degli strumenti:

• Agno, LangChain e LangGraph usano solo la prima frase della descrizione della funzione come descrizione dello strumento e inseriscono le descrizioni dei parametri sui parametri. Le loro definizioni sono le più brevi.
• AutoGen, Microsoft Agent Framework, CrewAI e Google ADK inviano la descrizione completa della funzione, incluse le descrizioni dei parametri e del valore restituito.
• LlamaIndex aggiunge anche la firma della funzione all'inizio.
• Pydantic IA scrive la descrizione in tag XML e aggiunge la descrizione del valore restituito.

Due framework aggiungono testo alle istruzioni. CrewAI colloca le istruzioni in un modello di ruolo, retroscena e obiettivo, e Google ADK aggiunge alla fine una riga che inizia con “Sei un agente”. Queste aggiunte sono più piccole delle differenze nelle definizioni degli strumenti.

Le definizioni degli strumenti vengono inviate di nuovo a ogni richiesta, quindi la differenza aggiunge costo a ogni passaggio. Agno e AutoGen hanno effettuato quasi lo stesso numero di chiamate LLM per esecuzione (4.40 e 4.45), eppure AutoGen ha inviato il 37% di token in più al modello in media (14.932 contro 10.899).

Abbiamo fornito a ogni framework le stesse funzioni e descrizioni. Mantenere brevi le descrizioni delle funzioni o fornire al framework una descrizione separata dello strumento riduce questa differenza. In CrewAI, il testo aggiunto alle istruzioni può essere modificato con system_template e prompt_template.

Sovraccarico del codice del framework

Il codice proprio del framework aggiunge in media 0.04-0.14 s a un'esecuzione, meno del 2% del tempo totale.

L'avvio richiede circa 1 s in Google ADK, 0.6 s in CAMEL e meno di 0.35 s negli altri. Il tempo di avvio non è incluso nei risultati del benchmark.

Nei sistemi che partono da zero per ogni richiesta, come le funzioni serverless, il tempo di avvio viene sommato a ogni richiesta. Caricare il framework una volta all'avvio dell'applicazione e mantenere il processo in esecuzione lo elimina.

Supporto multi-agente

Questo benchmark ha usato un singolo agente, ma tutti i 13 framework supportano l'esecuzione di più agenti insieme. Abbiamo verificato le informazioni in questa sezione e nelle tre successive rispetto al codice sorgente delle versioni testate. Gli approcci si dividono in tre gruppi:

• Definiti come flusso: LangGraph (nodi e archi), Microsoft Agent Framework (WorkflowBuilder), Google ADK (SequentialAgent, ParallelAgent, LoopAgent), Strands Agents (Graph e Swarm) e LlamaIndex (AgentWorkflow con passaggi di consegna tra agenti).
• Definiti come team: CrewAI (un Crew sequenziale o uno con un agente manager), AutoGen (RoundRobinGroupChat, SelectorGroupChat, Swarm), Agno (Team) e CAMEL (Workforce, RolePlaying).
• Passaggio del lavoro a un altro agente: OpenAI Agents SDK (handoffs), smolagents (managed_agents), Pydantic IA e LangChain (dare un agente a un altro come strumento).

Abbiamo misurato come questi framework gestiscono un flusso a cinque agenti nel nostro benchmark di orchestrazione agentica.

Supporto MCP

Il MCP (Model Context Protocol) offre agli agenti un modo standard per connettersi a strumenti esterni e fonti di dati. Tutti i 13 framework possono usare strumenti dai server MCP.

Client MCP incluso nel pacchetto del framework:

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

Pacchetto separato necessario:

• AutoGen: autogen-ext
• LangGraph: nessun client MCP proprio; usa il supporto MCP di LangChain oppure langchain-mcp-adapters
• LlamaIndex: llama-index-tools-mcp

Non perderti i nostri benchmark e approfondimenti basati sui dati. Il pulsante apre Google; selezionare AIMultiple conferma che desideri vedere AIMultiple più spesso nei risultati di ricerca di Google.

Aggiungi come fonte preferita

Approvazione umana (human-in-the-loop)

Alcune azioni non dovrebbero avvenire senza l'approvazione di una persona, come inviare un'email o eliminare un record. I framework supportano questo in tre modi.

Richiedere l'approvazione prima che uno strumento venga eseguito:

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

Mettere in pausa il flusso e attendere la risposta di una persona:

• LangGraph: interrupt
• LlamaIndex: eventi che attendono l'input umano
• Strands Agents: interrupt

Collegare una persona come agente o strumento:

• AutoGen: UserProxyAgent
• CAMEL: HumanToolkit
• CrewAI: feedback tramite human_input alla fine di un'attività
• smolagents: UserInputTool

Memoria

Ogni framework mantiene la cronologia all'interno di un'attività. La differenza sta nella memoria persistente tra attività e conversazioni.

Memoria persistente integrata:

• Agno: MemoryManager
• AutoGen: Memory
• CAMEL: LongtermAgentMemory
• CrewAI: l'impostazione di memoria su un Crew
• Google ADK: servizi di memoria
• LangChain: checkpointer e store
• LangGraph: checkpointer e store
• LlamaIndex: Memory
• Microsoft Agent Framework: provider di contesto e cronologia
• OpenAI Agents SDK: sessioni
• Strands Agents: gestori di sessione

Nessuna memoria persistente integrata (l'applicazione memorizza la cronologia e la passa all'agente all'esecuzione successiva):

• Pydantic IA
• smolagents

I migliori framework agentici

LangGraph

Definisce un agente come un grafo di nodi e archi, e lo sviluppatore gestisce esplicitamente lo stato passato tra i passaggi. Ha versioni Python e JavaScript, e le esecuzioni possono essere tracciate nella piattaforma LangSmith di LangChain.

La più lunga esecuzione di LangGraph nell'attività 3 ha effettuato 25 chiamate agli strumenti prima di raggiungere la risposta corretta, e 16 di esse erano ripetizioni. A parte smolagents, la più lunga esecuzione in qualsiasi altro framework si è fermata a 21 chiamate agli strumenti.

LangChain

Il framework generico del team di LangChain per applicazioni LLM. Dalla versione 1.0, gli agenti vengono creati con create_agent ed eseguiti sul runtime LangGraph. Il middleware può modificare il ciclo dell'agente e il middleware pronto copre il riepilogo di cronologie lunghe, la mascheratura dei dati personali, i nuovi tentativi dopo errori e il fallback su un altro modello.

Poiché create_agent gira su LangGraph, ha inviato al modello le stesse istruzioni e definizioni degli strumenti di LangGraph, e i due framework hanno ottenuto quasi lo stesso tempo e costo.

CrewAI

Definisce gli agenti per ruolo, obiettivo e retroscena e li esegue con le attività come una squadra (un crew). Oltre ai crew, i Flows collegano i passaggi tramite eventi e l'azienda offre anche una piattaforma enterprise a pagamento.

È stato il framework più veloce nell'attività 4 (7.85 s) e ha effettuato il minor numero di chiamate LLM in quella attività (5.68 in media).

AutoGen

Il framework di Microsoft Research in cui gli agenti lavorano inviandosi messaggi. Ha un design a strati (Core, AgentChat ed Extensions) e AutoGen Studio, un'interfaccia no-code, è disponibile come pacchetto separato. Microsoft raccomanda Microsoft Agent Framework per i nuovi progetti.

Per impostazione predefinita, AssistantAgent si ferma dopo un giro di chiamate agli strumenti e restituisce il risultato dello strumento come risposta (max_tool_iterations=1). Le attività multi-passaggio richiedono un valore più alto e noi l'abbiamo aumentato.

Microsoft Agent Framework

Il framework di Microsoft che unisce AutoGen e Semantic Kernel. Supporta Python e .NET. Offre tracciamento OpenTelemetry e middleware per le chiamate degli agenti, e un'interfaccia di sviluppo chiamata DevUI è disponibile come pacchetto separato.

È stato il framework più veloce nell'attività 5 (6.50 s), anche se ha spesso ripetuto i passaggi.

OpenAI Agents SDK

Il framework di OpenAI e successore di Swarm, costruito attorno ad agenti, strumenti, handoff e guardrail. Ha versioni Python e TypeScript. Per impostazione predefinita, invia una traccia di ogni esecuzione alla dashboard di tracciamento di OpenAI (l'abbiamo disattivato per il benchmark). Include moduli separati per agenti vocali e in tempo reale. Utilizza le API Responses di OpenAI per impostazione predefinita, quindi i modelli di altri provider necessitano della classe di modelli Chat Completions.

Google ADK

Funziona direttamente con Gemini e con altri modelli tramite LiteLLM, che è quello che abbiamo usato. Viene fornito con un'interfaccia di sviluppo locale (adk web) e uno strumento di valutazione (adk eval), e gli agenti possono essere distribuiti dalla riga di comando su Vertex AI Agent Engine, Cloud Run o GKE.

È stato il framework più veloce in media (6.79 s) e si è classificato tra i tre più veloci in tutte e cinque le attività. Ha anche effettuato il minor numero di chiamate LLM per esecuzione (3.73 in media).

Agno

Viene fornito con un ampio catalogo di toolkit pronti e offre AgentOS, un runtime per servire e gestire gli agenti come API sulla propria infrastruttura.

In Agno, il modello non ha quasi mai scritto commenti accanto alle sue chiamate agli strumenti: lo ha fatto nello 0,2% dei turni di chiamata agli strumenti, contro il 3% al 26% negli altri framework. Questi commenti vengono fatturati come token di output.

Pydantic IA

Valida gli argomenti degli strumenti e l'output dell'agente con i modelli Pydantic e chiede al modello di correggere un argomento non valido. Un meccanismo tipizzato deps passa le dipendenze come le connessioni al database agli strumenti. Le esecuzioni possono essere tracciate con Pydantic Logfire e rese durevoli contro le interruzioni con Temporal, DBOS o Prefect.

smolagents

Il suo approccio più noto è CodeAgent, che chiama gli strumenti scrivendo codice Python invece di JSON ed esegue quel codice localmente o in ambienti isolati come E2B, Docker o Modal. Strumenti e agenti possono essere condivisi su Hugging Face Hub. Abbiamo testato ToolCallingAgent, che effettua chiamate agli strumenti in JSON, quindi CodeAgent non fa parte di questi risultati.

Poiché restituisce la risposta tramite uno strumento final_answer separato, il 99,6% dei suoi output era JSON semplice. Negli altri framework, dal 17% al 41% delle risposte arrivava racchiuso in un blocco di codice markdown.

LlamaIndex

Include componenti per caricare, dividere, indicizzare e interrogare documenti e un motore di interrogazione può essere fornito a un agente come strumento con QueryEngineTool. Per gli agenti, offre FunctionAgent e AgentWorkflow, che collega diversi agenti. Ha versioni Python e TypeScript.

È stato il framework più costoso nel grafico nelle attività 2 e 4, le attività con il maggior numero di passaggi ($1,91 e $2,75 per 1.000 esecuzioni). Le sue lunghe definizioni degli strumenti vengono inviate di nuovo a ogni passaggio, quindi il divario cresce con il numero di passaggi.

Strands Agents

Lascia la pianificazione e la scelta degli strumenti al modello e mantiene semplice il ciclo dell'agente. Se non è impostato alcun modello, usa un modello Claude su Amazon Bedrock, e dispone di provider integrati per Anthropic, OpenAI, Gemini, Mistral, Ollama e LiteLLM. Traccia le esecuzioni con OpenTelemetry.

In tutte le 100 esecuzioni dell'attività 1, il modello ha prima chiamato lo strumento di calcolo senza caricare i dati, ha ricevuto un errore e ha caricato i dati in un passaggio separato. A causa di questo passaggio aggiuntivo, Strands è stato il framework più lento nel grafico nell'attività 1 (5.18 s).

CAMEL

Un framework agentico della comunità CAMEL-IA nato dalla ricerca multi-agente; OWL è costruito su di esso. Oltre ai toolkit pronti, include moduli per la generazione di dati sintetici e benchmark, quindi si rivolge anche all'uso nella ricerca.

È stato il framework più lento nel grafico nell'attività 3 (14.43 s). In questa attività, il modello ha effettuato 4.73 chiamate LLM e prodotto 598 token di ragionamento per esecuzione in media in CAMEL, contro 3.22 e 207 in Google ADK.

Metodologia del benchmark

Tutte le attività usano gli stessi dati: 5.000 clienti campionati dal dataset di churn dei clienti Telco di IBM. Abbiamo aggiunto una colonna JSON (dati del dispositivo) e una colonna di testo (note di supporto) al dataset. L'agente prima carica i dati, poi filtra e calcola con gli strumenti e restituisce la risposta in un formato JSON fisso.

• Attività 1, calcolo di base: Tasso di abbandono per tipo di contratto. Misura quanto sovraccarico il framework aggiunge al lavoro più semplice.
• Attività 2, confronto tra due gruppi: Ricavi mensili persi dai clienti con e senza supporto tecnico. Misura se due risultati separati rimangono corretti attraverso i passaggi.
• Attività 3, soglie: Tasso di abbandono dei clienti con meno di 1 anno di anzianità che pagano oltre $70 al mese. Misura la conversione delle frasi nei numeri giusti e l'applicazione di due filtri uno dopo l'altro.
• Attività 4, strumento rotto: Tasso di abbandono per metodo di pagamento. Lo strumento richiesto fallisce tre volte e funziona alla quarta. Misura cosa fa l'agente quando uno strumento fallisce.
• Attività 5, dati misti: Conteggi dei dispositivi (dalla colonna JSON) e parole chiave dei reclami (dalla colonna di testo) per i clienti che hanno abbandonato e pagano oltre $100 al mese. Misura se l'agente riconosce i tipi di colonna e sceglie lo strumento giusto.

Configurazione

• Modello: Claude Haiku 5.5 tramite OpenRouter con il provider Anthropic, sforzo di ragionamento medio.
• 100 esecuzioni per framework e attività, 6.500 esecuzioni in totale. Data: 27 ottobre 2026.
• Limiti per esecuzione: 15 chiamate LLM nelle attività 1-3, 25 nelle attività 4-5 e 420 s.
• Ogni framework ha ricevuto le stesse istruzioni, lo stesso testo dell'attività e gli stessi strumenti. Abbiamo configurato ogni framework nel modo standard e non abbiamo modificato il suo comportamento predefinito. Abbiamo solo aumentato i limiti dei passaggi quanto bastava per far terminare le attività e modificato un'impostazione ciascuno in CrewAI, smolagents e AutoGen per farli funzionare con Claude.
• Tutte le richieste sono passate attraverso lo stesso proxy di registrazione. Il proxy ha applicato lo stesso modello e la stessa impostazione di ragionamento a ogni richiesta e ha rimosso le impostazioni di campionamento che alcuni framework aggiungono, come la temperatura di 0.1 che invia LlamaIndex.
• Ogni esecuzione è stata eseguita nel proprio processo dopo un passaggio di riscaldamento non misurato. Le esecuzioni sono state eseguite tre alla volta in ordine mescolato.
• Abbiamo confrontato ogni risposta con la risposta corretta calcolata dagli stessi strumenti.
• I risultati per il nostro campione di 5.000 clienti differiscono dai risultati pubblici ben noti del dataset, quindi il modello non può rispondere a memoria.
• Versioni testate: 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.

Cita questo benchmark

Scegli il formato adatto a dove pubblicherai. Incollare la versione con link nel tuo CMS preserva il backlink.

@misc{dilmegani2026,
  author = {Dilmegani, Cem and Şipi, Nazlı},
  title  = {{I 13 migliori framework open-source di IA agentica}},
  year   = {2026},
  month  = oct,
  howpublished    = {\url{https://aimultiple.com/agentic-frameworks}},
  note   = {AIMultiple. Consultato il 30 ottobre 2026}
}

Registro delle modifiche

10 aggiornamenti

Tutte10Generale9Metodologia1

20262025

1. 2 mar

   Sostituiti i risultati e l'analisi del benchmark nella sezione "Agentic AI frameworks benchmark".

2. 22 gen

   Rimossa una modifica metodologica che descriveva come le attività venivano integrate nelle architetture basate su agenti.

Cem Dilmegani

Analista principale

Segui

Cem è analista principale presso AIMultiple dal 2017.

Il lavoro di Cem presso AIMultiple è stato citato da importanti testate internazionali tra cui Business Insider, Forbes, Morning Brew e Washington Post, da aziende globali come Deloitte e HPE, da ONG come il World Economic Forum e da organizzazioni sovranazionali come la Commissione europea. [1], [2], [3], [4], [5]

Nel corso della sua carriera, Cem ha lavorato come consulente tecnologico, acquirente tecnologico e imprenditore tecnologico. Ha consigliato le aziende sulle loro decisioni tecnologiche presso McKinsey & Company e Altman Solon per più di un decennio. Ha inoltre pubblicato un report McKinsey sulla digitalizzazione.

Ha guidato la strategia tecnologica e gli approvvigionamenti di una società di telecomunicazioni rispondendo direttamente al CEO. Ha inoltre guidato la crescita commerciale dell'azienda deep tech Hypatos, che ha raggiunto ricavi ricorrenti annuali a 7 cifre e una valutazione a 9 cifre partendo da zero in 2 anni. Il lavoro di Cem in Hypatos è stato ripreso da importanti testate tecnologiche come TechCrunch e Business Insider.

Cem interviene regolarmente a conferenze tecnologiche internazionali. Si è laureato come ingegnere informatico presso l'Università di Bogazici e possiede un MBA della Columbia Business School.

Visualizza il profilo completo

Ricercato da

Nazlı Şipi

Ricercatrice IA

Segui

Nazlı è un'analista di dati presso AIMultiple. Ha precedente esperienza nell'analisi dei dati in diversi settori, dove ha lavorato per trasformare dataset complessi in informazioni operative.

Visualizza il profilo completo

Commenti 1

Condividi i tuoi pensieri

Il tuo indirizzo email non verrà pubblicato. Tutti i campi sono obbligatori. I commenti vengono lasciati nella loro lingua originale.

Nome

Indirizzo e-mail

Commento

0/450

Pubblica un commento

Chaitanya

Dec 19, 2025 at 01:47

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

Rispondere