I loop degli agenti IA: come un agente di codice si auto-corregge da solo

Il modo in cui la maggior parte delle persone usa ancora un agente di codice IA assomiglia a una partita di ping-pong. Tu fai un prompt, lui risponde, tu noti cosa non va, fai di nuovo un prompt. Sei tu il motore di correzione, e stai dentro al loop a ogni singolo turno.

Un loop ribalta tutto questo. Tu descrivi quello che vuoi, l'agente si mette al lavoro, scrive la propria checklist, individua i suoi punti deboli e ripete finché il risultato non regge. Smetti di essere quello che intercetta gli errori. È l'agente a intercettare i propri.

Questo cambiamento non è hype. Le persone che hanno costruito questi strumenti ci si appoggiano. Boris Cherny e Cat Wu, i creatori di Claude Code, parlano di programmare in agent loops. Geoffrey Huntley, che ha battezzato il "Ralph loop", fa girare gli agenti in un semplice ciclo while di notte. Il pattern ora ha un nome, e vale la pena capirlo prima di copiare tre prompt visti su Instagram.

Dal ping-pong di prompt al loop

Un singolo prompt è un colpo solo. Chiedi, ottieni una risposta, la transazione finisce lì. Per migliorarla devi accorgerti del divario e fare di nuovo un prompt. Porta tutto questo alla scala di una vera feature e ti ritrovi a fare decine di micro-correzioni a mano.

Un loop di agente IA chiude quel divario dentro l'agente. Tu fissi un obiettivo, l'agente pianifica, agisce, guarda il risultato e corregge, ancora e ancora, finché l'obiettivo non è raggiunto. Non sei sparito: rileggi alla fine. Ma non sei più il collo di bottiglia a ogni iterazione.

Il ping-pong di prompt mette te dentro al loop a ogni turno. Un vero loop ci mette l'agente.

Cos'è davvero un loop di agente IA

Ogni loop agentico gira sugli stessi quattro tempi: pianificare, agire, osservare, correggere. L'agente decide il passo successivo, lo compie (scrive codice, lancia un comando, legge un file), legge cosa è successo e si aggiusta. Claude scrive codice, lancia i test, vede un fallimento, corregge, rilancia i test. Questo feedback è tutto il trucco. È ciò che rende il loop auto-correttivo, e non semplicemente ripetitivo.

La versione più solida del loop distribuisce questi tempi su tre ruoli: uno che pianifica, uno che costruisce, uno che rilegge. Tenerli separati è ciò che impedisce all'agente di correggere il proprio compito con lo stesso respiro con cui lo scrive.

Il loop in tre comandi che puoi copiare oggi

Ecco il setup che gira in questo momento, rifatto come tre slash command di Claude Code. Incolli ciascuno una volta, l'agente crea il comando, poi li lanci nell'ordine.

Il pianificatore, /spec:

Intervistami una domanda alla volta finché non capisci bene cosa voglio.
Poi scrivi un piano preciso in specs/project.md: l'obiettivo, i requisiti
esatti, i casi limite, e cosa rientra o non rientra nel perimetro.
Tienilo breve e netto, non un romanzo.

Il costruttore, /build:

Leggi specs/project.md e costruisci esattamente quello che descrive, niente di più.
Quando hai finito, elenca ogni requisito del piano e segna quali
hai coperto.

Il revisore, /review:

Confronta ciò che è stato costruito con specs/project.md, requisito per requisito.
Per ognuno, di' se è coperto. Scrivi le correzioni necessarie e
rimandale a /build. Approva solo quando tutto il piano è coperto.

Tre comandi, un loop: spec scrive il piano, build lo implementa, review lo confronta con il piano e rimanda le correzioni a build. Continua a ciclare finché ogni requisito non è soddisfatto.

Il piano è la fonte di verità. La revisione misura la costruzione rispetto a lui, non rispetto a una sensazione.

Sotto al cofano è spec-driven coding: è la spec scritta, non la cronologia della chat, a fare da metro per l'agente. Lo Spec Kit open-source di GitHub formalizza la stessa idea con /specify, /plan, /tasks e /implement, e gira indifferentemente su Claude Code, Copilot, Cursor, Codex CLI e Gemini CLI.

Perché un contesto fresco fa funzionare il loop: il Ralph loop

Geoffrey Huntley ha battezzato la versione più cruda di tutto questo a metà 2025: il Ralph loop. L'idea è un semplice ciclo shell che serve all'agente lo stesso prompt rispetto a una spec scritta, lo lascia scegliere un task e consegnarlo, poi avvia un agente del tutto nuovo con un contesto pulito e gli serve di nuovo il prompt identico.

while restano_todo; do
  agent --prompt "Lavora sul prossimo task di todo.md" --non-interactive
done

La parte non ovvia è il reset del contesto. Una sessione lunga marcisce: la finestra si riempie di vecchi ragionamenti, vicoli ciechi e contenuti di file ormai obsoleti, e il modello comincia in sordina a lasciar cadere istruzioni. Ogni iterazione di Ralph è un nuovo agente che legge il repo attuale e la lista dei task dal disco, fa un'unità di lavoro, fa commit ed esce pulito. Huntley l'ha chiamato come il personaggio dei Simpsons di proposito: sembra troppo stupido per funzionare, e funziona. Se hai mai visto una sessione lunga iniziare ad allucinare, sai già perché una finestra fresca batte una saturata.

I comandi /loop e /goal di Claude Code

Claude Code integra direttamente delle primitive di loop. /goal fissa uno stato finale persistente, com'è fatto il "finito", e Claude valuta i suoi progressi rispetto a quello dopo ogni passata, invece di limitarsi a lanciare il passo successivo. /loop ripete un task a una cadenza o finché una condizione non regge, con forme come /loop every 10m o /loop until: <condizione>. Usati insieme creano un loop auto-diretto e auto-terminante: Claude lavora sul divario tra lo stato attuale e l'obiettivo, e si ferma quando l'obiettivo è soddisfatto o tu premi Ctrl+C.

Il dettaglio che conta: un loop mantiene la continuità. Ricorda cosa ha provato e perché ha fallito, così ogni passata si appoggia alla precedente invece di ripetere lo stesso vicolo cieco. È il compromesso opposto rispetto al reset a contesto pulito di Ralph, e sono validi entrambi. La continuità per un'auto-correzione serrata, il contesto fresco quando la finestra marcisce. Sapere quale tirare fuori è la vera competenza.

Lo stesso loop, da ogni provider

I loop non sono una feature di Claude, sono la direzione verso cui sta andando tutto il settore. I nomi cambiano, la forma no.

Codex CLI ha spinto il loop più in là di tutti in pubblico. Il team di OpenAI ha presentato il suo /goal come la propria versione del Ralph loop, e Andrew Chen di a16z l'ha lasciato girare un'intera notte su un driver di periferica, 14 ore di fila senza alcun intervento. Ha anche notato che avrebbe "moltiplicato per 10.000 il consumo di token", che è il costo onesto di lasciar macinare un agente per mezza giornata.

Il rovescio della medaglia: un loop amplifica tutto

Un loop non amplifica solo il buon output, amplifica anche un piano sbagliato. Punta un agente auto-correttivo su una spec vaga e costruirà con sicumera la cosa sbagliata, la rileggerà rispetto alla stessa spec vaga e approverà. Il piano è la leva. Una spec netta ti fa risparmiare dieci prompt, una nebulosa ne spreca cento.

Due modalità di fallimento da tenere d'occhio. Il costo va fuori controllo: ogni iterazione brucia token, e un loop senza limiti su un obiettivo poco chiaro può bruciarne tanti. E il loop può girare all'infinito, cantando vittoria o inseguendo un bersaglio che non potrà mai soddisfare. Mettigli dei limiti: una condizione until chiara, un tetto di token, o un punto di controllo umano prima del merge. Un loop senza uno stop non è autonomia, è una fuga in avanti.

Far girare i loop su un'intera flotta

Un solo agente auto-correttivo è facile da sorvegliare. La leva emerge quando ne fai girare diversi contemporaneamente, ciascuno in loop sul proprio task, ed è esattamente lì che sorvegliare un terminale smette di scalare.

È per questo che AgentsRoom è stato costruito. È un cockpit multi-agente: ogni agente ha un ruolo, un pallino di stato in tempo reale e un colore tutto suo, e tu supervisioni l'intera flotta da un'unica finestra. Lascia cadere un ticket nel backlog e un agente lo raccoglie, svolge il suo loop plan-build-review e ti restituisce un diff pulito. È lo spec-driven AI coding in pratica: il ticket è la spec, l'agente svolge il loop, tu rileggi il risultato.

Siccome i loop lunghi fanno marcire il contesto, AgentsRoom lo tiene d'occhio. Ogni agente scrive uno stato di una riga alla fine di ogni turno, e quando un agente smette di aggiornarlo per due turni di fila compare un avviso con un riavvio in un clic su un contesto pulito, lo stesso reset di finestra su cui si appoggia il Ralph loop. Scopri come funziona nella pagina rilevamento della deriva di contesto.

E siccome il loop è agnostico rispetto al provider, non sei legato a nessuno. Lancia un ticket su Claude Code, il successivo su Codex, un altro su Gemini CLI, tutto nella stessa dashboard, ciascuno in loop nel proprio git worktree così che gli agenti paralleli non si scontrino mai. Falli partire prima di staccare e rileggi i diff al mattino: è tutto il senso degli agenti di codice in background e del turno di notte.

Fissa l'obiettivo una volta sola, lascia che il loop lo chiuda, rileggi alla fine. Scarica AgentsRoom, consulta la matrice di compatibilità dei provider e leggi di più sulla revisione per agente e sul supporto multi-provider.