Cos'è un AI Agent (e Perché Non È un Chatbot)

"Se risponde a domande, non puoi chiamarlo agente."

Non lo dico io. Lo dice OpenAI, nella loro guida ufficiale alla costruzione di agenti. La citazione esatta: "if you're building a chatbot-like experience where the AI system is answering questions, you can't really call it an agent."

Eppure nel 2026, qualsiasi cosa abbia un LLM dentro viene venduta come "agente AI". Un form che chiama GPT? Agente. Un chatbot con un system prompt lungo? Agente. Un wrapper attorno a un'API con tre righe di Python? Agente, ovviamente.

Spoiler: la maggior parte non lo è. E la differenza non è marketing — è architetturale. Capirla cambia il modo in cui usi questi strumenti e il modo in cui li costruisci.

La Differenza in 30 Secondi

Un chatbot fa questo:

Tu scrivi → Il modello risponde → Fine.

Un agente fa questo:

Tu dai un obiettivo → Il modello pensa → Agisce → Osserva il risultato → Pensa di nuovo → Agisce di nuovo → ... → Obiettivo raggiunto.

Il chatbot è una singola chiamata request-response. Gli fai una domanda, ti dà una risposta. Se la risposta è sbagliata, glielo dici tu e lui riprova. Il loop è manuale — lo guidi tu, passo passo.

L'agente è un loop autonomo. Gli dai un obiettivo e lui decide da solo come raggiungerlo. Legge file, esegue comandi, verifica i risultati, corregge gli errori, e continua finché non ha finito. Il loop è automatico — gira da solo finché serve.

La stessa differenza che c'è tra chiedere indicazioni a un passante ("gira a destra, poi a sinistra") e dare un indirizzo a un navigatore. Il passante ti risponde una volta. Il navigatore ricalcola il percorso ogni volta che sbagli svolta.

Tecnicamente, È un While Loop

Se scrivi codice, la differenza diventa lampante. Un chatbot è una funzione:

risposta = llm.generate(prompt)
return risposta

Un agente è un ciclo:

while not obiettivo_raggiunto:
    pensiero = llm.ragiona(contesto)
    azione = llm.scegli_tool(pensiero)
    risultato = esegui_tool(azione)
    contesto.aggiungi(risultato)

Questo è il cuore di tutto. Il corso di HuggingFace sugli agenti lo dice esplicitamente: un agente è un while loop che continua finché l'obiettivo non è raggiunto. Ogni iterazione ha tre fasi — pensiero, azione, osservazione — e il ciclo si ripete finché il modello decide che ha finito.

Claude Code, l'agente CLI di Anthropic, funziona esattamente così. La loro documentazione descrive il pattern core come: while(tool_call) -> execute tool -> feed results -> repeat. Un "turn" è un giro completo del loop: Claude genera output con una tool call, il runtime la esegue, il risultato torna a Claude, e il ciclo riparte. I turn continuano finché Claude produce output senza tool call — cioè ha finito.

Il modello usato può essere identico. ChatGPT e il Codex agent di OpenAI usano varianti della stessa famiglia di modelli. La differenza non è nel cervello — è nell'architettura che lo circonda. Il chatbot chiama il modello una volta. L'agente lo chiama in loop, passandogli ogni volta i risultati del giro precedente.

Le 4 Componenti di un Agente

Ogni agente serio ha quattro pezzi. Tutti e quattro servono — togli uno e hai qualcosa di meno.

1. Il Modello (il cervello)

È l'LLM. Claude, GPT, Gemini, Llama — quello che ragiona, che decide cosa fare, che genera le chiamate ai tool. Non è l'agente — è il motore dell'agente. Come un cervello senza mani non può afferrare nulla, un LLM senza tool non può agire sul mondo.

Google lo definisce "il fondamento dell'intelligenza dell'agente". LangChain lo chiama "il sistema che decide il flusso di controllo dell'applicazione." Il punto è lo stesso: il modello è chi prende le decisioni, ma da solo non basta.

2. Il Tool Use (le mani)

Qui la cosa si fa interessante. Un LLM da solo può solo generare testo. Con i tool, può leggere file, eseguire comandi, chiamare API, cercare nel web, scrivere su database. Passa da "motore di ragionamento isolato" a "sistema che agisce sul mondo".

Se hai letto l'articolo sul tool use, sai già come funziona sotto il cofano: il modello genera un JSON strutturato, un runtime esterno lo esegue, il risultato torna al modello. Il modello non "esegue" nulla — genera la stringa giusta, e qualcun altro fa il lavoro.

Il tool use è ciò che distingue un agente da un chatbot a livello tecnico. OpenAI lo mette tra le tre componenti fondamentali. Google dice che è "ciò che distingue gli agenti dalle semplici chiamate LLM". Senza tool, hai un modello che parla. Con i tool, hai un modello che fa.

3. La Memoria (i ricordi)

Un chatbot generico non ricorda nulla tra una sessione e l'altra. Gli chiedi di fixare un bug oggi, domani non sa chi sei. Un agente ha bisogno di memoria — sia a breve termine (la cronologia della sessione corrente) sia a lungo termine (le preferenze del progetto, le convenzioni, le lezioni apprese).

Claude Code gestisce la memoria su due livelli: la conversazione corrente resta nella context window (memoria a breve termine), e quando la finestra si riempie un compressor automatico riassume la cronologia per liberare spazio. In parallelo, una funzione di auto-memory estrae le lezioni apprese e le salva in un file MEMORY.md che persiste tra le sessioni (memoria a lungo termine).

La memoria è il pezzo che trasforma un tool usa-e-getta in un collaboratore che migliora nel tempo.

4. Il Planning (la strategia)

Dare un obiettivo complesso a un LLM senza planning è come dare un progetto architettonico a un muratore senza disegni. Il planning è la capacità di scomporre un obiettivo grande in sotto-task eseguibili, determinare l'ordine giusto, e adattarsi quando qualcosa va storto.

Anthropic chiama il planning una delle capacità chiave: l'agente "plan and operate independently, potentially returning to the human for further information or judgement." Non è solo fare una lista di step — è rivalutare il piano ad ogni iterazione sulla base dei risultati ottenuti.

Queste quattro componenti formano un ciclo: il reasoning e la memoria informano il planning. Il planning coordina il tool use. I risultati del tool use aggiornano la memoria. E il ciclo riparte.

Il Pattern ReAct: Pensiero, Azione, Osservazione

Nel 2022, Shunyu Yao e colleghi hanno pubblicato un paper che ha cambiato tutto: "ReAct: Synergizing Reasoning and Acting in Language Models". Presentato a ICLR 2023, è diventato il pattern fondamentale di ogni agente moderno.

L'idea è semplice ma potente: ad ogni step, l'agente non decide solo cosa fare — prima articola perché.

Il ciclo ReAct ha tre fasi:

Thought — L'agente ragiona ad alta voce. "Devo trovare dove è definita la funzione handleAuth. Probabilmente è in src/auth/ o src/middleware/. Inizio cercando con grep."

Action — L'agente agisce. Chiama un tool: grep -r "handleAuth" src/.

Observation — L'agente legge il risultato. "Trovata in src/middleware/auth.ts alla riga 47. Ha una dipendenza da src/utils/jwt.ts."

E il ciclo riparte con un nuovo Thought: "Ora devo leggere anche jwt.ts per capire l'intera catena."

Perché il "Thought" conta? Perché obbliga il modello a decomporre il problema prima di agire. Senza il pensiero esplicito, il modello tenderebbe a lanciare azioni basandosi solo sulla probabilità statistica. Con il pensiero, il modello traccia il progresso, gestisce eccezioni, adatta il piano.

I paper precedenti separavano ragionamento e azione: Chain of Thought faceva ragionare il modello ma non agire, e i tool-use system facevano agire il modello ma senza ragionare esplicitamente. ReAct li ha fusi. È il momento in cui l'agente ha smesso di essere un concetto e ha iniziato a essere un'architettura.

Come Funziona un Agente Coding: Claude Code

La teoria è bella. Vediamo come funziona nella pratica, con un esempio concreto.

Scenario: dai a Claude Code il task "aggiungi validazione Zod allo schema utente e aggiorna i test".

Ecco cosa succede nel loop:

Turn 1 — Claude ragiona: "Devo trovare lo schema utente attuale." Chiama Grep per cercare "userSchema" nel codebase. Il runtime esegue la ricerca, restituisce i file trovati.

Turn 2 — Claude legge il risultato: schema in src/schemas/user.ts. Chiama Read per leggere il file. Il runtime lo legge, restituisce il contenuto.

Turn 3 — Claude ora vede lo schema. Ragiona: "Manca la validazione email e il campo age ha bisogno di un range." Chiama Write per modificare il file con lo schema Zod aggiornato.

Turn 4 — Claude pensa ai test. Chiama Grep per trovare i test esistenti dello schema utente.

Turn 5 — Legge i test, li aggiorna con i nuovi casi per la validazione Zod.

Turn 6 — Esegue npm test per verificare. Due test falliscono.

Turn 7 — Legge l'output degli errori. Il test "valid user" fallisce perché il mock non include il campo age. Corregge il mock.

Turn 8 — Riesegue i test. Tutti passano. Output senza tool call: "Ho aggiunto validazione Zod allo schema utente con..." — il loop si chiude.

Otto turn. Otto giri del while loop. Un chatbot avrebbe generato il codice al primo messaggio e ti avrebbe lasciato integrarlo, testarlo e fixarlo a mano. L'agente ha fatto tutto il ciclo: ha trovato i file, modificato il codice, eseguito i test, trovato i bug, corretto, ri-testato.

Claude Code è un agente con un loop principale single-threaded per scelta. Il loop di base è un singolo flusso di messaggi con tool call sequenziali, privilegiando debuggability e reliability — anche se supporta sub-agent delegati per task paralleli. Codex di OpenAI fa una scelta simile: un singolo harness che orchestra il loop agente in un sandbox cloud isolato, con la possibilità di usare sub-agent specializzati (worker, explorer). Cursor Agent va in un'altra direzione: un sistema multi-agente con Planner che esplorano il codebase e Worker che completano i task, fino a otto agenti in parallelo.

Architetture diverse, stesso principio: un loop autonomo che pensa, agisce, osserva, ripete.

I 5 Livelli di Autonomia

Non tutti gli agenti sono uguali. Come le auto a guida autonoma hanno livelli da 0 a 5, anche gli agenti AI si distribuiscono su uno spettro di autonomia.

Livello 0 — Nessuna automazione. Sviluppo tradizionale. Scrivi tutto tu. Nessun AI coinvolto.

Livello 1 — Assistente. Tool come Copilot che suggeriscono completamenti. L'AI propone, tu decidi. È il tab-complete intelligente: utile, ma l'umano guida ogni singolo passo.

Livello 2 — Automazione parziale con supervisione. Qui siamo oggi con Claude Code, Cursor Agent, Codex. L'agente completa feature intere su file multipli. Tu dai l'obiettivo e rivedi il risultato. "Hands-off but eyes-on" — mani staccate dalla tastiera, occhi sul monitor.

Livello 3 — Autonomia condizionata. L'agente opera indipendentemente entro confini definiti. Esempio: refactoring di tutto il codice che passa i test esistenti, senza toccare le API pubbliche. L'umano definisce i paletti, l'AI lavora dentro quei paletti.

Livello 4 — Alta autonomia. L'agente gestisce la maggior parte dei task da solo su intere codebase. L'umano interviene solo per eccezioni e decisioni architetturali critiche.

Livello 5 — Autonomia totale. Dall'architettura al deployment alla manutenzione. L'umano specifica solo gli obiettivi di business. Non ci siamo ancora — e capire come controllare agenti a questi livelli è una delle sfide aperte più importanti.

Il punto non è arrivare al livello 5 il prima possibile. Il punto è sapere a che livello stai lavorando e comportarti di conseguenza. Supervisionare un agente di livello 2 come se fosse di livello 4 è il modo più veloce per ritrovarsi con codice rotto in produzione.

Chat, Code, Claw

Andrej Karpathy — membro fondatore di OpenAI, ex capo AI di Tesla, quello che non scrive codice da dicembre 2025 — ha proposto una tassonomia in tre livelli che fotografa bene dove siamo.

Chat — Il primo livello. Sistemi conversazionali: gli fai una domanda, ti rispondono. ChatGPT, Claude.ai nella versione base, Gemini in modalità chat. Utili, ma non agenti.

Code — Il secondo livello. Chatbot con capacità di tool use: cercano nel web, eseguono codice, leggono file. Claude Code, Cursor Agent, Codex CLI. Sono gli agenti che conosci — si attivano quando li invochi e si fermano quando il task è completato.

Claw — Il terzo livello. Agenti persistenti che girano anche quando non guardi. La differenza chiave, nelle parole di Karpathy: "un agente parte quando lo invochi e si ferma quando il task finisce. Un claw gira continuamente — monitora, reagisce, impara, esegue — che tu stia guardando o no."

Lo stesso Karpathy ha un "claw" personale, Dobby, che controlla la sua smart home via WhatsApp. Non è fantascienza — è un agente con un loop persistente, memoria a lungo termine e accesso a tool reali.

La gerarchia completa che propone: LLM (il modello grezzo) -> Agent (esegue task in una sessione) -> Claw (loop indipendente, gira in background) -> Swarm (reti distribuite di agenti autonomi che collaborano).

La maggior parte di noi oggi lavora al livello "Code". Ma il confine con "Claw" si sta assottigliando — e la differenza tra usare agenti e farsi usare dagli agenti passa dalla comprensione di cosa significa davvero "agentic engineering".

Quando un Agente Serve (e Quando No)

Non tutto ha bisogno di un agente. E sapere quando usarne uno e quando no è la parte più pratica di tutto l'articolo.

Usa un chatbot quando:

La risposta è in una singola interazione. "Spiegami la differenza tra map e flatMap in TypeScript." Non serve un loop — serve una risposta.
Vuoi mantenere il controllo totale. Stai esplorando un'idea, vuoi ragionare ad alta voce, non vuoi che nessuno tocchi i tuoi file.
Il task è ambiguo e iterativo per natura. Brainstorming, design di API, revisione architetturale. Qui il dialogo umano-AI è il valore, non l'automazione.

Usa un agente quando:

Il task ha più step e richiede verifica. "Implementa questa feature, scrivi i test, assicurati che passino." L'agente itera fino a che tutto funziona.
Serve interazione con l'ambiente. Leggere file, eseguire comandi, cercare nel codebase, scrivere codice. Un chatbot può solo suggerire — un agente può fare.
Il feedback loop è meccanico. Se il ciclo è "prova -> errore -> correggi -> riprova", un agente lo fa più veloce di te. Non perché è più intelligente — perché non si stanca e non si distrae.

Il dato dello Stack Overflow Developer Survey 2025 è indicativo: l'84% degli sviluppatori usa o prevede di usare tool AI, ma il 52% non usa agenti o preferisce strumenti più semplici. Non è ignoranza — per molti task, un chatbot è sufficiente e più controllabile.

Tra chi li usa, però, il 69% riporta un aumento di produttività. La differenza sta nel saper scegliere lo strumento giusto per il task giusto.

I Numeri: Dove Siamo Davvero

I benchmark raccontano una storia di progresso veloce ma incompleto.

SWE-bench misura la capacità degli agenti di risolvere issue reali da repository open source. Sul benchmark originale, prima degli agenti lo stato dell'arte era l'1.96%. Devin, a inizio 2024, ha portato il risultato al 13.86% (7x il baseline). Sul sottoinsieme curato SWE-bench Verified (500 task validati da umani), a marzo 2026 Claude Opus 4.5 ha raggiunto l'80.9%.

Da meno del 2% a oltre l'80% in due anni. Ma quel 20% restante — i bug complessi, i refactoring architetturali, le decisioni di design non banali — è il pezzo difficile.

E c'è un dato che fa da contrappeso. Un team di Google Research e MIT ha testato 180 configurazioni multi-agente su 5 architetture e 3 famiglie di LLM. Il risultato: i sistemi multi-agente non strutturati amplificano gli errori fino a 17.2 volte rispetto a un singolo agente. Più agenti non significa automaticamente risultati migliori. Spesso significa risultati peggiori, più velocemente.

Il mercato degli agenti AI vale 7.92 miliardi di dollari nel 2025, con una proiezione a 52 miliardi entro il 2030. Il 57% delle organizzazioni ha già agenti in produzione secondo il report LangChain 2025 (era il 51% nel 2024). Non è una moda — è un cambio di paradigma. Ma un cambio di paradigma che richiede comprensione tecnica, non hype.

Cosa Significa per Chi Sviluppa

Se sei arrivato fin qui, la distinzione chatbot-agente non è più una questione teorica. Ha implicazioni pratiche sul tuo lavoro quotidiano.

Smetti di chiamare tutto "agente". Se il tuo tool fa una singola chiamata LLM e restituisce il risultato, è un chatbot. Non c'è niente di male — i chatbot sono utili. Ma confondere le categorie porta a aspettative sbagliate e frustrazione.

Impara a lavorare al livello giusto di autonomia. Un task da livello 1 (suggerimento di completamento) non ha bisogno di un agente di livello 2 che modifica 10 file. Un task da livello 3 (refactoring autonomo) non si risolve con un chatbot che ti dà codice da copiare e incollare.

Il loop è il superpotere, ma anche il rischio. Ogni giro del while loop consuma contesto, token, tempo. Un agente che gira per 20 turn su una strada sbagliata ha sprecato risorse e inquinato la sua stessa context window. Sapere quando interrompere il loop è importante quanto sapere quando avviarlo.

I tool che usi sono agenti. Se usi Claude Code, Cursor Agent, Codex — stai già lavorando con agenti. Non chatbot con un nome diverso: agenti reali con loop autonomi, tool use, planning. Capire come funzionano sotto il cofano — il while loop, il pattern ReAct, la gestione del contesto — ti rende un utente migliore. Perché sai cosa aspettarti, sai dove possono fallire, e sai come guidarli quando il loop va nella direzione sbagliata.

Il confine tra chatbot e agente non è una linea netta — è uno spettro, come dicono Andrew Ng e LangChain: "ci sono diversi gradi di agenticità". Ma i due estremi sono chiari. Un chatbot ti risponde. Un agente lavora per te. E sapere la differenza è il primo passo per usare entrambi nel modo giusto.

Fonti: