Come funziona il loop di un agente

« Agente » è la parola più consumata dell'anno. Ma sotto il rumore c'è una meccanica concreta e piuttosto semplice, e capirla è la differenza tra usare un agente con criterio e pregare che funzioni. La definizione che ha retto meglio è quella di Anthropic, che Simon Willison riassume in una frase : un agente è un modello che usa strumenti in un loop (simonwillison.net). Niente loop, niente agente — solo una chiamata isolata a un modello.

Un agente non è un workflow

Prima del loop, una distinzione che risparmia molti guai. Anthropic separa due cose che il gergo confonde: un workflow è un sistema in cui il modello e gli strumenti sono orchestrati da percorsi di codice che scrivi in anticipo; un agente è un sistema in cui il modello stesso decide la propria traiettoria e quale strumento usare, a partire dal feedback dell'ambiente, in loop (Building Effective AI Agents). Il workflow è prevedibile ed economico; l'agente è flessibile e costoso. La maggior parte dei problemi si risolve con il primo — l'agente si riserva a quando non puoi cablare il percorso in anticipo ma puoi verificare il risultato.

Il mattone: l'« augmented LLM »

Il pezzo di base non è il modello nudo, ma quello che Anthropic chiama augmented LLM: un modello con accesso a recupero (cercare dati), strumenti (eseguire azioni) e memoria. Lilian Weng lo descrive con il modello come « cervello » e tre pilastri attorno — pianificazione (scomporre in sotto-obiettivi, correggersi), memoria (breve e lungo termine) e uso degli strumenti (LLM Powered Autonomous Agents). Il loop è ciò che mette tutto questo in movimento.

Pensare, agire, osservare

Il pattern che ordina il loop viene da un paper del 2022: ReAct (Reason + Act). L'idea è intrecciare ragionamento e azione invece di separarli: il modello ragiona un passo (« mi serve il prezzo attuale, non lo so a memoria »), esegue un'azione (chiama uno strumento di ricerca), osserva il risultato, e quel risultato alimenta il ragionamento successivo (Yao et al., 2022). Il ragionamento pianifica e gestisce le eccezioni; l'azione porta informazione dal mondo esterno che il modello non aveva.

Il round trip, in concreto

In pratica, quell'« agire » ha una forma molto precisa nelle API attuali. Quando il modello vuole usare uno strumento, non lo esegue: ferma il suo turno con un segnale — nell'API di Claude, stop_reason: "tool_use" — e restituisce un blocco che descrive quale strumento vuole e con quali argomenti. Il tuo codice esegue quell'operazione e restituisce il risultato in un blocco tool_result, che rientra nel contesto all'iterazione successiva (Tool use with Claude). OpenAI documenta la stessa danza in cinque passi: richiesta con strumenti → il modello chiede una chiamata → la tua app la esegue → seconda richiesta con l'output → risposta finale o altre chiamate (Function calling).

Tolto il dettaglio di ciascun fornitore, l'intero loop sta in poche righe:

# Il loop di un agente, in essenza
messaggi = [prompt_utente]

while True:
    risposta = modello.genera(messaggi, strumenti)
    messaggi.append(risposta)

    if risposta.motivo_stop == "fine":
        break                        # il modello ha deciso di aver finito

    # il modello ha chiesto uno o più strumenti: li esegue IL TUO codice
    risultati = [esegui(ch) for ch in risposta.chiamate]
    messaggi.append(risultati)       # le osservazioni tornano nel contesto

Tutto qui. Non c'è altra magia nel nucleo: un while che alterna generazione del modello ed esecuzione di strumenti, accumulando l'intera conversazione in messaggi finché il modello segnala di aver finito. Ciò che cambia tra un giocattolo e un agente serio non è il loop — è ciò che circonda quelle due righe.

Perché il contesto cresce a ogni giro

Nota che messaggi fa una cosa sola: crescere. Ogni giro aggiunge la risposta del modello e il risultato di ogni strumento. Nei task lunghi questo si accumula in fretta, ed è lì che compare il primo problema reale. Anthropic lo dice senza giri: « un agente che gira in loop genera sempre più dati… che vanno raffinati ciclicamente » (Effective context engineering). La finestra di contesto è un budget di attenzione finito, e oltre un certo punto arriva il context rot: più token infili, peggio il modello recupera ciò che contava. Per questo gli agenti seri compattano, riassumono o prendono note — non per eleganza, ma perché il loop, senza gestione, annega nella sua stessa storia.

Dove si rompe

Il loop è semplice, e proprio per questo ha guasti prevedibili. Vale la pena conoscerli prima di mandare un agente in produzione:

• Il costo cresce a ogni iterazione. Ogni giro rimanda tutta la storia accumulata e ne aggiunge altra. Un agente che fa venti giri non costa venti chiamate piccole: costa venti chiamate sempre più grandi.
• Gli errori si propagano. Un ragionamento sbagliato al giro 3 entra nel contesto e contamina i giri 4, 5, 6… Il modello si trascina il proprio errore come fosse un fatto. Per questo Anthropic raccomanda il pattern più semplice che passa la valutazione, non il più agentico (Building Effective AI Agents).
• Lo stop non è gratis. Il while True dell'esempio dipende dal modello che emette « fine ». Un agente può continuare a girare, ripetere azioni, o non riconoscere di aver finito. Sul serio servono un limite di iterazioni, un rilevamento di loop e una condizione di stop esplicita — l'obiettivo è raggiungere una meta, non iterare all'infinito.

Cosa portarsi a casa

Un agente è un while attorno a un modello che chiama strumenti e accumula ciò che osserva. Capire quella meccanica non lo rende meno utile — lo rende usabile con criterio: sai che il costo scala con i giri, che il contesto si degrada se non lo gestisci, che un errore precoce avvelena il resto, e che controlli il punto esatto in cui uno strumento viene eseguito o no. Nulla di tutto ciò si vede da fuori, dove c'è solo « un agente che fa cose ». Si vede da dentro il loop. E guardare dentro, prima di fidarsi, è proprio la via di mezzo che questo sito persegue: né rifiutare gli agenti per riflesso, né eseguirli alla cieca.