Framework per AI Agentica a Confronto: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Gli agenti AI sono passati dalle demo di ricerca ai sistemi in produzione. Si prevede che oltre il 60% delle applicazioni AI aziendali includera componenti agentiche entro il 2026. Ma costruire agenti da zero - gestendo loop di tool, stato, memoria, gestione degli errori e coordinamento multi-agente - e complesso. Ed e qui che entrano in gioco i framework.

Quattro framework dominano nel 2026: LangGraph, CrewAI, OpenAI Agents SDK e Claude Agent SDK. Ciascuno adotta un approccio fondamentalmente diverso allo stesso problema: dare agli LLM la capacita di ragionare, pianificare, usare tool e collaborare.

Panoramica Rapida

LangGraph: Il Costruttore di Grafi

LangGraph modella i workflow degli agenti come grafi ciclici diretti. Definisci nodi (funzioni che eseguono il lavoro) e archi (transizioni tra di essi, opzionalmente condizionali). Lo stato fluisce attraverso il grafo e viene persistito tramite checkpointing.

Questo e il framework piu esplicito e controllabile - colleghi ogni passo tu stesso.

Concetti Chiave

• StateGraph: la definizione del grafo con stato tipizzato
• Nodes: funzioni Python che trasformano lo stato
• Edges: connessioni tra nodi, possono essere condizionali
• Checkpointing: persistenza integrata per workflow di lunga durata

Esempio di Codice

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Punti di Forza

• Controllo granulare su ogni passo e transizione
• Checkpointing integrato e human-in-the-loop
• Parita completa con TypeScript
• Funziona con qualsiasi provider LLM
• Ideale per workflow complessi con branching condizionale e loop

Punti Deboli

• Curva di apprendimento ripida - bisogna comprendere i concetti della teoria dei grafi
• Verboso per casi d'uso semplici - un agente base richiede piu boilerplate rispetto ad altri framework
• Il debugging dei flussi del grafo puo essere impegnativo senza LangSmith

Prezzi

Open-source (MIT). LangSmith (piattaforma di osservabilita gestita) ha piani a pagamento per il monitoraggio in produzione.

CrewAI: L'Assemblatore di Team

CrewAI utilizza una metafora umana: assembli un crew di agenti specializzati, ciascuno con un ruolo, un obiettivo e una storia. Gli agenti collaborano su task usando tool, coordinati da un processo (sequenziale, gerarchico o consensuale).

Pensalo come assumere un team dove ogni membro ha un titolo e una specialita specifici.

Concetti Chiave

• Agent: una persona con ruolo, obiettivo, storia e tool
• Task: un incarico con descrizione, output atteso e agente assegnato
• Crew: un gruppo di agenti che lavorano insieme
• Process: strategia di esecuzione (sequenziale, gerarchica, consensuale)
• Flow: livello di orchestrazione event-driven per collegare piu crew

Esempio di Codice

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Punti di Forza

• Astrazione basata su ruoli intuitiva - facile da comprendere
• Oltre 100 integrazioni di tool integrate
• Memoria condivisa tra agenti (a breve termine, a lungo termine, per entita)
• Community piu grande (~40k stelle GitHub)
• Processo gerarchico con un agente "manager" che delega e valida

Punti Deboli

• Meno controllo granulare rispetto a LangGraph - si definiscono i ruoli, non i percorsi di esecuzione esatti
• Il processo gerarchico puo essere imprevedibile quando gli agenti non concordano
• Il debugging delle conversazioni multi-agente e piu difficile rispetto ai flussi a singolo agente

Prezzi

Core open-source (gratuito). CrewAI Platform: $99/mese (Teams) fino a $120k/anno (Enterprise). Prezzo basato sui crew attivi e sulle esecuzioni mensili.

OpenAI Agents SDK: Il Router

L'OpenAI Agents SDK (successore spirituale di Swarm) si concentra sugli handoff - agenti che trasferiscono conversazioni ad altri agenti specializzati. E il framework piu minimale: agenti, tool, handoff e guardrail. Tutto qui.

Concetti Chiave

• Agent: modello + istruzioni + tool + handoff
• Handoff: un trasferimento a un altro agente (modellato come un tool che l'LLM puo chiamare)
• Guardrail: validazione di input/output che gira in parallelo con l'agente
• Runner: esegue il loop dell'agente
• Tracing: osservabilita integrata per tutte le chiamate LLM, invocazioni di tool e handoff

Esempio di Codice

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Punti di Forza

• Pattern di handoff pulito - naturale per workflow di routing/triage
• I guardrail girano in parallelo con l'esecuzione (fail-fast, non bloccanti)
• Dashboard di tracing integrata per il debugging
• Nonostante il nome, supporta modelli non-OpenAI
• Astrazione minima - facile da capire e estendere

Punti Deboli

• Gestione dello stato meno matura rispetto a LangGraph
• Nessuna persistenza o checkpointing integrati
• L'ecosistema di tool di terze parti e piu ridotto
• Il design incentrato sugli handoff potrebbe non adattarsi a ogni architettura

Prezzi

Open-source (MIT). Si paga per token in base al modello utilizzato.

Claude Agent SDK: Lo Sviluppatore

Il Claude Agent SDK adotta un approccio diverso: invece di definire workflow o ruoli, si fornisce all'agente un set di tool e lo si lascia capire come portare a termine il compito. Utilizza lo stesso loop autonomo che alimenta Claude Code - leggi, agisci, verifica, itera.

Concetti Chiave

• query(): il punto di ingresso principale che avvia il loop dell'agente
• Tool integrati: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Tool personalizzati via MCP: definisci tool come server MCP in-process
• Sub-agent: agenti specializzati a cui il genitore puo delegare
• Sessions: mantengono il contesto attraverso piu interazioni

Esempio di Codice

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Punti di Forza

• Integrazione MCP di prima classe - connettiti a qualsiasi ecosistema di server MCP
• Tool integrati per operazioni su file, terminale e accesso web
• Compattazione automatica del contesto per codebase di grandi dimensioni
• Parallelismo dei sub-agent per task complessi
• Stesso motore di Claude Code - testato in battaglia su workflow di sviluppo reali

Punti Deboli

• Solo modelli Claude - nessun supporto multi-provider
• Framework piu recente con una community piu piccola
• Richiede il runtime Node.js anche per l'SDK Python
• Meno controllo esplicito del workflow rispetto a LangGraph

Prezzi

Open-source. Tariffe standard per token dell'API Claude. Managed Agents (versione hosted): $0.08 per ora di sessione oltre ai costi per token.

Quando Scegliere Quale

Scegli LangGraph se:

• Hai bisogno di un controllo preciso su ogni passo del workflow
• Il tuo caso d'uso prevede logica condizionale complessa e loop
• Vuoi persistenza integrata e checkpoint human-in-the-loop
• Devi usare piu provider LLM nello stesso workflow

Scegli CrewAI se:

• Vuoi un'astrazione intuitiva basata sui ruoli
• Il tuo task coinvolge piu agenti con specialita distinte
• Hai bisogno che gli agenti collaborino e si passino il contesto
• Dai valore alla community piu grande e al maggior numero di integrazioni

Scegli OpenAI Agents SDK se:

• Il tuo pattern principale e il routing delle conversazioni verso specialisti
• Hai bisogno di guardrail che validino input/output in parallelo
• Vuoi l'astrazione piu semplice possibile con boilerplate minimo
• Tracing e osservabilita integrati sono importanti

Scegli Claude Agent SDK se:

• I tuoi agenti devono leggere, scrivere ed eseguire codice
• Vuoi un'integrazione di prima classe con server MCP
• Hai bisogno di agenti autonomi che iterano e si auto-correggono
• Usi gia Claude e vuoi l'integrazione piu profonda

Si Possono Combinare i Framework?

Si. Un pattern comune e usare un framework per l'orchestrazione e un altro per i singoli agenti:

• LangGraph per il grafo del workflow complessivo
• CrewAI per un nodo specifico che richiede collaborazione multi-agente
• Claude Agent SDK per sotto-task legati al coding via MCP
• OpenAI Agents SDK per triage e routing lato cliente

I framework non si escludono a vicenda. Usa quello che si adatta meglio a ogni parte del tuo sistema.

Conclusione

Ogni framework fa una scommessa chiara:

• LangGraph ottimizza per il controllo - tu decidi ogni transizione
• CrewAI ottimizza per la collaborazione - gli agenti lavorano come un team
• OpenAI Agents SDK ottimizza per la semplicita - astrazione minima, handoff puliti
• Claude Agent SDK ottimizza per l'autonomia - dagli i tool e lascialo lavorare

La scelta giusta dipende dal tuo workflow, dal tuo team e dal tuo stack esistente. Scegli quello che corrisponde al tuo caso d'uso principale, imparalo bene e integra gli altri quando raggiungi il loro punto di forza.