1~
2Gli 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.
3~
4Quattro 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.
5~
6## Panoramica Rapida
7~
8| Aspetto | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Creato da** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architettura** | Basata su grafi | Basata su ruoli | Basata su handoff | Loop autonomo |
12| **Filosofia** | Massimo controllo | Collaborazione di team | Astrazione minima | Dai un computer all'agente |
13| **Linguaggi** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Supporto modelli** | Qualsiasi (OpenAI, Claude, locale) | Qualsiasi | Qualsiasi (nonostante il nome) | Solo Claude |
15| **Stelle GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Ideale per** | Workflow stateful complessi | Specializzazione multi-agente | Routing e triage | Coding e task su file |
17~
18## LangGraph: Il Costruttore di Grafi
19~
20LangGraph 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.
21~
22Questo e il framework piu esplicito e controllabile  -  colleghi ogni passo tu stesso.
23~
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33~
34### Concetti Chiave
35~
36- **StateGraph**: la definizione del grafo con stato tipizzato
37- **Nodes**: funzioni Python che trasformano lo stato
38- **Edges**: connessioni tra nodi, possono essere condizionali
39- **Checkpointing**: persistenza integrata per workflow di lunga durata
40~
41### Esempio di Codice
42~
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46~
47llm = ChatOpenAI(model="gpt-4o")
48~
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52~
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58~
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66~
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73~
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77~
78### Punti di Forza
79~
80- Controllo granulare su ogni passo e transizione
81- Checkpointing integrato e human-in-the-loop
82- Parita completa con TypeScript
83- Funziona con qualsiasi provider LLM
84- Ideale per workflow complessi con branching condizionale e loop
85~
86### Punti Deboli
87~
88- Curva di apprendimento ripida  -  bisogna comprendere i concetti della teoria dei grafi
89- Verboso per casi d'uso semplici  -  un agente base richiede piu boilerplate rispetto ad altri framework
90- Il debugging dei flussi del grafo puo essere impegnativo senza LangSmith
91~
92### Prezzi
93~
94Open-source (MIT). LangSmith (piattaforma di osservabilita gestita) ha piani a pagamento per il monitoraggio in produzione.
95~
96## CrewAI: L'Assemblatore di Team
97~
98CrewAI 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).
99~
100Pensalo come assumere un team dove ogni membro ha un titolo e una specialita specifici.
101~
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112~
113### Concetti Chiave
114~
115- **Agent**: una persona con ruolo, obiettivo, storia e tool
116- **Task**: un incarico con descrizione, output atteso e agente assegnato
117- **Crew**: un gruppo di agenti che lavorano insieme
118- **Process**: strategia di esecuzione (sequenziale, gerarchica, consensuale)
119- **Flow**: livello di orchestrazione event-driven per collegare piu crew
120~
121### Esempio di Codice
122~
123```python
124from crewai import Agent, Task, Crew, Process
125~
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134~
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143~
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150~
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158~
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165~
166result = crew.kickoff()
167print(result.raw)
168```
169~
170### Punti di Forza
171~
172- Astrazione basata su ruoli intuitiva  -  facile da comprendere
173- Oltre 100 integrazioni di tool integrate
174- Memoria condivisa tra agenti (a breve termine, a lungo termine, per entita)
175- Community piu grande (~40k stelle GitHub)
176- Processo gerarchico con un agente "manager" che delega e valida
177~
178### Punti Deboli
179~
180- Meno controllo granulare rispetto a LangGraph  -  si definiscono i ruoli, non i percorsi di esecuzione esatti
181- Il processo gerarchico puo essere imprevedibile quando gli agenti non concordano
182- Il debugging delle conversazioni multi-agente e piu difficile rispetto ai flussi a singolo agente
183~
184### Prezzi
185~
186Core open-source (gratuito). CrewAI Platform: $99/mese (Teams) fino a $120k/anno (Enterprise). Prezzo basato sui crew attivi e sulle esecuzioni mensili.
187~
188## OpenAI Agents SDK: Il Router
189~
190L'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.
191~
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202~
203### Concetti Chiave
204~
205- **Agent**: modello + istruzioni + tool + handoff
206- **Handoff**: un trasferimento a un altro agente (modellato come un tool che l'LLM puo chiamare)
207- **Guardrail**: validazione di input/output che gira in parallelo con l'agente
208- **Runner**: esegue il loop dell'agente
209- **Tracing**: osservabilita integrata per tutte le chiamate LLM, invocazioni di tool e handoff
210~
211### Esempio di Codice
212~
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216~
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220~
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231~
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237~
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243~
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251~
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256~
257### Punti di Forza
258~
259- Pattern di handoff pulito  -  naturale per workflow di routing/triage
260- I guardrail girano in parallelo con l'esecuzione (fail-fast, non bloccanti)
261- Dashboard di tracing integrata per il debugging
262- Nonostante il nome, supporta modelli non-OpenAI
263- Astrazione minima  -  facile da capire e estendere
264~
265### Punti Deboli
266~
267- Gestione dello stato meno matura rispetto a LangGraph
268- Nessuna persistenza o checkpointing integrati
269- L'ecosistema di tool di terze parti e piu ridotto
270- Il design incentrato sugli handoff potrebbe non adattarsi a ogni architettura
271~
272### Prezzi
273~
274Open-source (MIT). Si paga per token in base al modello utilizzato.
275~
276## Claude Agent SDK: Lo Sviluppatore
277~
278Il 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.
279~
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289~
290### Concetti Chiave
291~
292- **query()**: il punto di ingresso principale che avvia il loop dell'agente
293- **Tool integrati**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Tool personalizzati via MCP**: definisci tool come server MCP in-process
295- **Sub-agent**: agenti specializzati a cui il genitore puo delegare
296- **Sessions**: mantengono il contesto attraverso piu interazioni
297~
298### Esempio di Codice
299~
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303~
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315~
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321~
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334~
335### Punti di Forza
336~
337- Integrazione MCP di prima classe  -  connettiti a qualsiasi ecosistema di server MCP
338- Tool integrati per operazioni su file, terminale e accesso web
339- Compattazione automatica del contesto per codebase di grandi dimensioni
340- Parallelismo dei sub-agent per task complessi
341- Stesso motore di Claude Code  -  testato in battaglia su workflow di sviluppo reali
342~
343### Punti Deboli
344~
345- Solo modelli Claude  -  nessun supporto multi-provider
346- Framework piu recente con una community piu piccola
347- Richiede il runtime Node.js anche per l'SDK Python
348- Meno controllo esplicito del workflow rispetto a LangGraph
349~
350### Prezzi
351~
352Open-source. Tariffe standard per token dell'API Claude. Managed Agents (versione hosted): $0.08 per ora di sessione oltre ai costi per token.
353~
354## Quando Scegliere Quale
355~
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363~
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369~
370### Scegli LangGraph se:
371- Hai bisogno di un controllo preciso su ogni passo del workflow
372- Il tuo caso d'uso prevede logica condizionale complessa e loop
373- Vuoi persistenza integrata e checkpoint human-in-the-loop
374- Devi usare piu provider LLM nello stesso workflow
375~
376### Scegli CrewAI se:
377- Vuoi un'astrazione intuitiva basata sui ruoli
378- Il tuo task coinvolge piu agenti con specialita distinte
379- Hai bisogno che gli agenti collaborino e si passino il contesto
380- Dai valore alla community piu grande e al maggior numero di integrazioni
381~
382### Scegli OpenAI Agents SDK se:
383- Il tuo pattern principale e il routing delle conversazioni verso specialisti
384- Hai bisogno di guardrail che validino input/output in parallelo
385- Vuoi l'astrazione piu semplice possibile con boilerplate minimo
386- Tracing e osservabilita integrati sono importanti
387~
388### Scegli Claude Agent SDK se:
389- I tuoi agenti devono leggere, scrivere ed eseguire codice
390- Vuoi un'integrazione di prima classe con server MCP
391- Hai bisogno di agenti autonomi che iterano e si auto-correggono
392- Usi gia Claude e vuoi l'integrazione piu profonda
393~
394## Si Possono Combinare i Framework?
395~
396Si. Un pattern comune e usare un framework per l'orchestrazione e un altro per i singoli agenti:
397~
398- **LangGraph** per il grafo del workflow complessivo
399- **CrewAI** per un nodo specifico che richiede collaborazione multi-agente
400- **Claude Agent SDK** per sotto-task legati al coding via MCP
401- **OpenAI Agents SDK** per triage e routing lato cliente
402~
403I framework non si escludono a vicenda. Usa quello che si adatta meglio a ogni parte del tuo sistema.
404~
405## Conclusione
406~
407Ogni framework fa una scommessa chiara:
408~
409- **LangGraph** ottimizza per il controllo  -  tu decidi ogni transizione
410- **CrewAI** ottimizza per la collaborazione  -  gli agenti lavorano come un team
411- **OpenAI Agents SDK** ottimizza per la semplicita  -  astrazione minima, handoff puliti
412- **Claude Agent SDK** ottimizza per l'autonomia  -  dagli i tool e lascialo lavorare
413~
414La 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.
415~