CrewAI vs LangGraph: quale scegliere e perché

Due modelli mentali, non due liste di funzioni

La differenza si dice in una frase: CrewAI descrive una squadra di ruoli, LangGraph descrive un grafo di stati con nodi e archi. Tutto il resto, dalla curva di apprendimento al consumo di token, discende da qui.

In CrewAI scrivi chi lavora: un agente ha un ruolo, un obiettivo e una storia, un compito ha una descrizione e la forma dell'output attesa. Il framework traduce questi campi in prompt e cicli di ragionamento, e il percorso concreto emerge durante l'esecuzione. In LangGraph scrivi come si muove l'esecuzione: ogni nodo è una funzione Python che riceve lo stato e ne restituisce gli aggiornamenti, ogni arco è una transizione dichiarata, e il modello linguistico interviene solo dove tu lo chiami.

La domanda giusta quindi non è quale dei due sia più capace, perché con entrambi si costruiscono gli stessi sistemi. È chi tiene il volante: l'agente, con la libertà e l'imprevedibilità che ne seguono, o il tuo codice, con la verbosità e il controllo che ne seguono.

Lo stesso compito, scritto nei due

Il modo più onesto di confrontarli è fare la stessa cosa due volte: un passo di ricerca che raccoglie fatti su un tema, un passo di scrittura che li condensa. Prima la versione CrewAI.

from crewai import Agent, Task, Crew, Process

ricercatore = Agent(
    role="Ricercatore",
    goal="Raccogliere fatti verificabili su {tema}",
    backstory="Separa i fatti dalle opinioni.",
    llm="gpt-5.4-mini",
)
redattore = Agent(
    role="Redattore",
    goal="Condensare i fatti in una sintesi utile",
    backstory="Scrive breve e taglia gli aggettivi.",
    llm="gpt-5.4-mini",
)

ricerca = Task(
    description="Raccogli i fatti principali su {tema}.",
    expected_output="Elenco puntato di fatti, con i numeri.",
    agent=ricercatore,
)
sintesi = Task(
    description="Condensa i fatti raccolti in 5 righe.",
    expected_output="5 righe di testo, senza premesse.",
    agent=redattore,
)

crew = Crew(
    agents=[ricercatore, redattore],
    tasks=[ricerca, sintesi],
    process=Process.sequential,
)
esito = crew.kickoff(inputs={"tema": "tariffe UE 2026"})
print(esito.raw)

Ora la stessa pipeline in LangGraph: uno stato tipizzato, due funzioni come nodi, gli archi che li collegano.

from typing_extensions import TypedDict
from langchain.chat_models import init_chat_model
from langgraph.graph import StateGraph, START, END

llm = init_chat_model("openai:gpt-5.4-mini")

class Stato(TypedDict):
    tema: str
    fatti: str
    testo: str

def ricerca(stato: Stato):
    r = llm.invoke(f"Elenca fatti verificabili su {stato['tema']}.")
    return {"fatti": r.content}

def scrittura(stato: Stato):
    r = llm.invoke(f"Condensa in 5 righe:\n{stato['fatti']}")
    return {"testo": r.content}

builder = StateGraph(Stato)
builder.add_node("ricerca", ricerca)
builder.add_node("scrittura", scrittura)
builder.add_edge(START, "ricerca")
builder.add_edge("ricerca", "scrittura")
builder.add_edge("scrittura", END)

grafo = builder.compile()
esito = grafo.invoke({"tema": "tariffe UE 2026"})
print(esito["testo"])

Le due versioni fanno la stessa cosa, ma dicono cose diverse. Nel file CrewAI non c'è un percorso: c'è una lista di compiti e un processo che la percorre, e i campi testuali diventano prompt. Quanti giri fa ogni agente per arrivare al risultato lo decide l'agente. Nel file LangGraph non c'è niente di implicito: lo stato è dichiarato campo per campo, ogni chiamata al modello sta scritta dentro un nodo, e il prompt lo componi tu. È più codice, ed è tutto ispezionabile. Su un caso lineare come questo la differenza sembra estetica; cresce appena entrano ramificazioni, cicli e riprese dopo errore.

Dieci criteri a confronto

I criteri sotto sono quelli che pesano davvero quando il progetto passa dal prototipo alla produzione. Il segno di spunta indica chi è più forte su quel terreno, non chi vince il confronto.

Il punto che quasi nessuno spiega: Crew, Flow o grafo

La maggior parte dei confronti in circolazione mette il crew autonomo contro il grafo esplicito e si ferma lì. È un confronto vero ma parziale, perché CrewAI ha due metà: i Crew, dove gli agenti decidono il percorso, e i Flow, dove il percorso lo scrivi tu con decoratori su metodi Python. E i Flow coprono buona parte del terreno di LangGraph.

La sovrapposizione non è totale. LangGraph resta più basso di livello e più generale: i checkpoint sono per passo su backend a scelta, con ispezione dello stato a ogni snapshot e la possibilità di riportare l'esecuzione a un punto precedente. I Flow sono più compatti e restano dentro un framework che ha anche i crew. Ma la conseguenza pratica è chiara: nel 2026 il confronto vero non è "CrewAI contro LangGraph" ma due confronti distinti, "Crew contro grafo" sul terreno dell'autonomia e "Flow contro grafo" sul terreno del controllo. Se stai valutando LangGraph solo per avere passaggi espliciti, prima leggi la guida ai Flows: forse quello che cerchi è già nella metà deterministica di CrewAI.

Costi e prestazioni: si paga in token

Sul prezzo dei framework non c'è partita perché non c'è prezzo: entrambi sono librerie con licenza MIT, senza limiti d'uso. Il costo vero sono i token del modello, e qui la differenza di modello mentale diventa differenza di bolletta.

Un crew autonomo tende a consumare più di un grafo esplicito, perché i passaggi non sono fissati: l'agente può fare giri di ragionamento in più, ripetere una chiamata a uno strumento, allungare il contesto a ogni scambio. Due esecuzioni identiche possono costare cifre diverse. In un grafo il numero di chiamate lo fissa la struttura, e il costo per esecuzione diventa stimabile in anticipo. CrewAI aiuta a misurare il fenomeno: l'oggetto restituito da kickoff() espone token_usage con il conteggio dell'intera esecuzione, ed è il primo numero da guardare prima di mettere un crew in produzione. I Flow, di nuovo, stanno nel mezzo: passaggi espliciti, consumo paragonabile a un grafo.

Il fattore ecosistema

LangGraph è sviluppato dal team di LangChain e vive dentro quel mondo: la documentazione sta su docs.langchain.com, i modelli si istanziano di solito con init_chat_model delle librerie LangChain, e l'osservabilità naturale è LangSmith. La documentazione precisa che LangGraph si può usare senza LangChain, ed è vero; in pratica ne eredita l'ampiezza, cioè integrazioni per quasi tutto, e il peso, cioè un albero di dipendenze e di concetti che arriva insieme alle integrazioni. LangChain è il progetto più stellato della categoria, 144.400 stelle contro le 39.900 di LangGraph al 17 agosto 2026, e fa da moltiplicatore di tutorial, esempi e risposte già scritte.

CrewAI ha fatto la scelta opposta: nato sopra LangChain, ne ha rimosso la dipendenza ed è oggi autonomo. I modelli passano da LiteLLM, che fa da traduttore verso decine di fornitori. Il repository conta circa 57.200stelle, più di LangGraph preso da solo, meno dell'ecosistema in cui LangGraph è immerso. Se la tua squadra usa già componenti LangChain, LangGraph è in casa; se vuoi un albero di dipendenze corto e un solo vocabolario da imparare, il punto va a CrewAI.

Si possono usare insieme?

Tecnicamente sì, e senza acrobazie: sono due librerie Python nello stesso interprete. Un crew si avvia con una chiamata di metodo, quindi un nodo LangGraph può eseguire crew.kickoff() e scrivere il risultato nello stato del grafo; allo stesso modo un passo di un Flow può invocare un grafo compilato. Nessun ostacolo tecnico.

La risposta onesta però è che di solito non conviene. Orchestratore dentro orchestratore significa due modelli di stato da tenere allineati, due superfici di debug quando qualcosa si rompe, due insiemi di versioni da aggiornare. Il caso in cui ha senso è preciso: un processo governato da un grafo LangGraph che delega un solo sottocompito aperto, per esempio una ricerca multi passaggio, a un piccolo crew, trattandolo come una funzione costosa che restituisce testo. Se invece ti accorgi di volere i crew dentro una struttura esplicita, la strada corta è restare in CrewAI e usare un Flow che chiama i crew nei punti giusti: è lo schema per cui i Flow sono nati.

Il verdetto

Nessuno dei due è la scelta giusta in assoluto, e chi lo sostiene sta vendendo qualcosa. La discriminante è il tipo di processo che devi costruire e quanto controllo pretende.