Un ciclo nasconde una decisione dentro una scatola nera: cosa viene eseguito dopo.
Ogni volta che un ciclo di un agente decide se riprovare, escalare o proseguire, quella decisione avviene all'interno del ragionamento del modello, invisibile a te, non verificabile a posteriori e impossibile da ispezionare senza rileggere l'output grezzo del modello e sperare che si sia spiegato onestamente. Un grafo rende quella stessa decisione esplicita. Scritta. Ispezionabile ancora prima che l'esecuzione inizi.
Non è una distinzione da poco. È l'argomento reale alla base di un vero paper su arXiv pubblicato nell'aprile 2026 che ha ridefinito come dovrebbero essere costruiti i sistemi basati su agenti, e vale la pena essere trasparenti su una cosa prima che questo corso prosegua ulteriormente. L'autore stesso del paper include una nota di equità che afferma chiaramente che si tratta di un design non implementato, e se fornirà i benefici promessi nella pratica rimane una domanda empirica aperta. Questo corso insegna il framework onestamente, inclusa questa avvertenza, perché comprendere una proposta reale e rigorosamente argomentata che non è ancora stata dimostrata su larga scala è più utile che fingere che sia un dato di fatto consolidato.
Alla fine di questo corso capirai cos'è effettivamente l'ingegneria dei grafi, perché esiste come livello superiore ai cicli, i tre impegni su cui si basa ogni grafo in questo framework, e come costruire il tuo primo grafo, insieme a un resoconto onesto di dove le prove attualmente sono e non sono.
Perché I Cicli Hanno Un Limite
Per capire perché esistono i grafi, devi capire precisamente dove i cicli smettono di essere sufficienti.
Un ciclo, nel senso agentico che conta qui, è un ciclo in cui un agente tenta un compito, osserva il risultato e decide cosa fare dopo, ripetuto fino al raggiungimento di una certa condizione. Funziona notevolmente bene per un'enorme gamma di compiti. È anche, strutturalmente, una scatola nera nel momento esatto che conta di più: la decisione su cosa succede dopo.
Quando l'agente di un ciclo decide di riprovare un passo fallito, quella decisione è arrivata dal modello che ragiona sul proprio contesto e produce una scelta. Non puoi ispezionare la decisione prima che avvenga. Puoi solo osservare il risultato dopo. Se l'agente riprova lo stesso approccio fallimentare cinque volte di fila, bruciando costi ogni volta, nulla nella struttura del ciclo lo ha impedito, perché la decisione di riprovare viveva interamente nel giudizio del modello stesso, non in una regola esterna e verificabile.
Questo va bene per compiti a basso rischio ed economici dove un eventuale tentativo sprecato non costa nulla di significativo. Diventa una vera responsabilità per lavori a lungo termine, costosi o ad alto rischio, esattamente la categoria di compiti a cui i sistemi agentici vengono sempre più affidati. L'argomento centrale del paper è che, man mano che i sistemi agentici assumono lavori più consequenziali, l'opacità di "cosa viene eseguito dopo" smette di essere una scatola nera accettabile e inizia a essere il vero punto di fallimento che vale la pena ingegnerizzare direttamente.
Cos'è Realmente Un Grafo
Un grafo, in questo framework, sostituisce la decisione implicita del modello sul passo successivo con una struttura esplicita definita prima che l'esecuzione inizi.
Invece di un agente che ragiona per arrivare a "Dovrei riprovare" o "Dovrei escalare" all'interno di una finestra di contesto opaca, il grafo definisce, in anticipo, esattamente quali stati esistono, quali transizioni tra stati sono valide e quali condizioni specifiche innescano ogni transizione. L'agente fa ancora un lavoro reale all'interno di ogni stato. Ciò che non fa più è decidere invisibilmente la forma del processo complessivo mentre procede.
La struttura in cinque mosse che descrive ogni singolo turno attraverso un grafo come questo: Pianifica, Esegui, Recupera, Escala, Ripeti. Pianifica è dove il compito viene scomposto in una sequenza definita. Esegui è dove l'agente svolge effettivamente il lavoro per il passo corrente. Recupera è ciò che accade quando l'esecuzione fallisce, seguendo un protocollo definito piuttosto che un tentativo improvvisato. Escala è il punto esplicito e definito in cui il grafo passa il controllo a un umano invece di continuare a tentare il recupero automatico. Ripeti chiude il ciclo, passando al passo successivo nel piano.
Nota cosa è cambiato rispetto a un ciclo. Ognuna di queste cinque mosse è ora uno stato nominato e ispezionabile in un grafo, con transizioni definite tra di loro, piuttosto che una decisione che avviene silenziosamente all'interno di una singola chiamata al modello.
I Tre Impegni
Ogni grafo in questo framework si basa su tre impegni specifici. Comprendere profondamente questi tre è il vero nucleo dell'ingegneria dei grafi come disciplina, più di qualsiasi dettaglio implementativo specifico.
Impegno Uno: Piano Immutabile
Il piano di esecuzione non può cambiare a metà esecuzione. Una volta che un piano è generato e bloccato, esiste come una versione fissa per la durata di quella esecuzione. L'agente non può modificare silenziosamente il proprio piano a metà dell'esecuzione in base a qualcosa che ha notato, come spesso fa un agente all'interno di un ciclo senza alcuna registrazione esterna della modifica in atto.
Sembra restrittivo, e lo è di proposito. La restrizione è il punto centrale. Un agente che può modificare liberamente il proprio piano a metà esecuzione è esattamente quell'agente il cui comportamento diventa impossibile da verificare a posteriori, perché il piano che rivedresti dopo non è il piano che è stato effettivamente seguito, ma è qualsiasi cosa in cui il piano si è trasformato alla fine. Bloccare il piano scambia flessibilità reale con ispezionabilità reale. Questo compromesso non è gratuito, e vale la pena considerarlo onestamente piuttosto che trattarlo come un miglioramento netto in ogni caso. Una situazione genuinamente nuova che il piano originale non aveva previsto viene gestita peggio da un piano immutabile che da un ciclo che può adattarsi liberamente. L'impegno è una scommessa deliberata che, per la categoria di compiti a cui questo framework si rivolge, prevedibile e verificabile batte massimamente adattivo.
Impegno Due: Livelli Separati
Pianificazione, esecuzione e recupero vivono in tre livelli indipendenti invece di un unico ciclo aggrovigliato in cui tutti e tre avvengono all'interno dello stesso processo di ragionamento continuo.
Il livello di pianificazione produce il piano immutabile dall'impegno uno e non fa nient'altro, non esegue passi e non gestisce i fallimenti. Il livello di esecuzione esegue i passi definiti e riporta i risultati, non decide cosa succede in caso di fallimento, solo cosa è successo. Il livello di recupero riceve le segnalazioni di fallimento e applica un protocollo definito, non esegue direttamente nuovo lavoro, decide solo come rispondere a ciò che è già successo.
Questa separazione rispecchia, deliberatamente, lo stesso principio alla base della separazione tra un Costruttore e un Giudice in un ciclo di verifica, un ruolo che produce lavoro non dovrebbe essere lo stesso ruolo che valuta o decide su quel lavoro, perché unire i due erode l'indipendenza che rende il controllo significativo in primo luogo. Qui la separazione è triplice invece che doppia, ma il ragionamento sottostante è identico: un sistema che pianifica, esegue e recupera tutto all'interno di un unico processo indifferenziato non può verificare in modo significativo nessuna di queste funzioni singolarmente, perché non sono mai realmente distinte nella traccia che rivedresti dopo.
Impegno Tre: Escalation Stretta
Il recupero segue un protocollo fisso invece di riprovare all'infinito sperando che qualcosa funzioni.
Questo è l'impegno che affronta più direttamente la modalità di fallimento del blowout di token che affligge i cicli senza condizioni di arresto reali. Un protocollo di escalation stretto definisce, in anticipo, esattamente quanti tentativi di recupero sono consentiti, esattamente cosa conta come un tentativo di recupero riuscito o fallito, e esattamente cosa succede nel momento in cui viene raggiunto il limite definito, passando il controllo a un umano, non tentando un'ennesima variazione creativa sullo stesso approccio fallimentare.
L'analisi del paper su 70 sistemi reali ha scoperto che una larga parte delle implementazioni di Cicli Agenti non aveva limiti formali sui tentativi di recupero, il che significa che il comportamento reale quando qualcosa andava storto era determinato da ciò che il modello decideva al momento, non da una regola che un umano aveva effettivamente rivisto e approvato in anticipo. L'escalation stretta chiude direttamente questo specifico divario.
Costruire Il Tuo Primo Grafo
Ecco il percorso pratico per costruirne effettivamente uno, traducendo i tre impegni in qualcosa che puoi implementare piuttosto che solo capire concettualmente.
Inizia definendo i tuoi stati in modo esplicito, su carta, prima di scrivere qualsiasi codice o prompt. Per un compito tipico, di solito assomiglia almeno a: Pianificazione, Esecuzione Passo N, Recupero da Fallimento, Escalato, Completato. Scrivi, per ogni stato, esattamente cosa succede mentre il sistema è in quello stato ed esattamente quali condizioni causano una transizione fuori da esso.
Scrivi il passo di generazione del piano in modo che il suo output sia un artefatto fisso e versionato, non un documento vivente che il resto del sistema può modificare silenziosamente. Una versione semplice e pratica di questo è generare il piano come un elenco numerato di passi discreti, ciascuno con un criterio di successo esplicito, e trattare quell'elenco come di sola lettura per il resto dell'esecuzione. Qualsiasi esigenza reale di discostarsi da esso dovrebbe innescare un'escalation esplicita a un umano, non una revisione interna silenziosa.
Costruisci il livello di esecuzione in modo che riporti solo risultati, superato, fallito, con dettagli specifici, e non prenda mai una decisione su cosa succede dopo. Questo rispecchia esattamente il ruolo del Costruttore da un ciclo di verifica, produrre lavoro e riportarlo onestamente, senza essere anche il ruolo che decide se riprovare.
Costruisci il livello di recupero con un protocollo esplicito e numerato. Tenta un approccio alternativo specifico. Se fallisce, tenta un secondo approccio specifico e diverso. Se fallisce, scala. Il protocollo dovrebbe essere abbastanza concreto che un umano che lo legge in anticipo può prevedere esattamente cosa farà il sistema in ogni fase, piuttosto che un'istruzione vaga come "prova a risolverlo un numero ragionevole di volte."
Collega lo stato di escalation in modo che raggiungerlo sia un evento reale e visibile, non qualcosa registrato silenziosamente e dimenticato. Un umano dovrebbe essere notificato, con la cronologia completa di ciò che è stato tentato e perché ogni tentativo è fallito, la stessa disciplina raccomandata per le condizioni di arresto nei cicli di verifica in generale.
Dove Questo Framework Aiuta Realmente, E Dove No
Essere onesti sui limiti dell'ingegneria dei grafi è più utile che trattarlo come un aggiornamento universale rispetto ai cicli in ogni situazione, e il paper stesso supporta questa visione più misurata.
I grafi aiutano realmente in compiti in cui lo spazio delle cose che possono andare storte è ragionevolmente compreso in anticipo, dove la verificabilità è più importante dell'adattabilità massima, e dove il costo di un ciclo di tentativi senza limiti e incontrollato sarebbe realmente costoso, sia in termini di costo computazionale che di conseguenza di un risultato negativo che raggiunge un utente reale o un sistema reale.
I grafi sono una scelta peggiore per compiti genuinamente aperti ed esplorativi in cui non puoi prevedere in modo significativo la forma del fallimento in anticipo, e dove il valore del sistema deriva proprio dalla sua capacità di improvvisare una risposta a qualcosa che nessuno aveva previsto. Bloccare un piano immutabile, per un compito che richiede fondamentalmente una ri-pianificazione adattiva man mano che emergono nuove informazioni, scambia via la capacità esatta che rendeva il compito degno di essere automatizzato con un agente in primo luogo.
La posizione onesta e difendibile, e quella che l'autore stesso del paper prende, è che questo è un reale compromesso che vale la pena comprendere profondamente, non una sostituzione strettamente superiore ai cicli in ogni caso. Usa un ciclo dove l'adattabilità è più importante della verificabilità. Usa un grafo dove è vero il contrario. La maggior parte dei sistemi reali trae beneficio dall'avere entrambi i pattern disponibili e dalla scelta deliberata tra di essi per ogni compito, piuttosto che adottare l'uno o l'altro come impostazione predefinita permanente.
Un Esempio Pratico: Migrazione di Codice Strutturata a Grafo
Per rendere concrete la struttura in cinque mosse e i tre impegni, ecco come si applicano a un compito reale e comune: migrare un modulo legacy a una nuova versione del framework attraverso un codebase.
Lo stato Pianificazione viene eseguito una volta, all'inizio. Analizza il modulo, identifica ogni file che deve cambiare e produce un elenco fisso e numerato di passi di migrazione, ciascuno con un criterio di successo esplicito, ad esempio, il passo 4 ha successo quando il file aggiornato compila e la suite di test esistente per quel file passa senza modifiche. Questo piano viene bloccato. È l'impegno uno, immutabile, in pratica.
Lo stato Esecuzione lavora attraverso i passi del piano in ordine. Per ogni passo, applica la modifica specifica definita nel piano e riporta il risultato, superato o fallito, con l'output effettivo del compilatore o il risultato del test allegato come prova, mai un auto-valutato "sembra corretto". Questo è il livello di esecuzione dell'impegno due, strettamente separato dalla decisione su cosa succede se fallisce.
Quando un passo fallisce, il grafo passa a Recupero, che segue un protocollo definito piuttosto che un tentativo improvvisato. Tentativo uno: riapplica la stessa modifica con un ambito più ristretto, isolando esattamente quale parte del file ha causato il fallimento della compilazione. Tentativo due, se il primo fallisce: ricorre a un pattern di migrazione alternativo documentato per questo tipo specifico di fallimento, tratto da una piccola libreria di correzioni note piuttosto che inventato di nuovo ogni volta. Se entrambi i tentativi definiti falliscono, il grafo passa a Escalato, questo è l'impegno tre, escalation stretta, non un terzo tentativo improvvisato.
Lo stato Escalato notifica direttamente un umano, con la cronologia completa allegata: quale passo è fallito, cosa hanno tentato entrambi i tentativi di recupero e l'output di errore specifico di ciascuno. Un umano esamina questo fallimento specifico con il contesto completo, piuttosto che scoprire giorni dopo che un agente aveva silenziosamente riprovato lo stesso approccio fallimentare in un ciclo per tutto il tempo, bruciando costi senza alcuna registrazione del perché.
Ripeti chiude il ciclo per i passi riusciti, spostando il grafo all'elemento successivo nel piano bloccato fino a quando l'elenco non è esaurito, a quel punto l'esecuzione raggiunge Completato.
Nota cosa ti offre questo rispetto al compito equivalente eseguito come un ciclo non strutturato. Ogni decisione, se riprovare, come e quando arrendersi, è visibile nella struttura definita del grafo ancora prima che l'esecuzione inizi, non scopribile solo leggendo una trascrizione dopo e deducendo cosa il modello doveva stare pensando. Un revisore del codice, o un revisore della conformità, può guardare la sola definizione del grafo e sapere esattamente cosa il sistema è in grado di fare in ogni scenario di fallimento, senza mai averlo visto eseguire.
Ingegneria dei Grafi vs Ingegneria dei Cicli: Quando Usare L'uno o L'altro
Dato che entrambi i pattern sono reali, documentati e ciascuno ha punti di forza genuini, ecco un quadro decisionale pratico per scegliere tra di loro per un compito specifico, piuttosto che trattare l'uno o l'altro come impostazione predefinita permanente.
Ricorri a un ciclo quando il compito è genuinamente esplorativo, quando non puoi prevedere in anticipo la forma di ciò che potrebbe andare storto, e quando la capacità del modello di improvvisare una risposta a qualcosa di imprevisto è esattamente la capacità su cui stai facendo affidamento. Compiti di ricerca, debug aperti in cui la causa principale è genuinamente sconosciuta all'inizio e lavoro creativo in cui una struttura rigida danneggerebbe attivamente l'output, tutti favoriscono l'adattabilità di un ciclo rispetto alla verificabilità di un grafo.
Ricorri a un grafo quando il compito è sufficientemente compreso in anticipo che puoi effettivamente enumerare le modalità di fallimento probabili, quando il costo di un ciclo di tentativi senza limiti e non verificato sarebbe realmente costoso, e quando un revisore umano, che sia un team di conformità, un revisore della sicurezza, o semplicemente il tuo futuro sé stesso che esegue il debug di un incidente di produzione, avrà bisogno di ispezionare esattamente cosa il sistema era in grado di fare senza rileggere una trascrizione completa dell'esecuzione. Migrazioni, transazioni finanziarie, tutto ciò che tocca dati regolamentati e lavoro di agente a lungo termine incustodito dove un fallimento silenzioso potrebbe accumularsi per ore prima che qualcuno se ne accorga, tutti favoriscono la struttura di un grafo rispetto alla flessibilità di un ciclo.
I due pattern non si escludono a vicenda nemmeno all'interno di un singolo sistema più grande. Un design comune e pragmatico usa un grafo al livello esterno, per la struttura complessiva del compito e le sue condizioni di arresto, mentre permette a un ciclo di eseguire all'interno di un singolo stato Esegui per il sotto-compito genuinamente esplorativo di capire come implementare un passo specifico. Questo ti dà la verificabilità di un grafo al livello in cui conta di più, la forma complessiva di ciò che il sistema può fare, preservando al contempo l'adattabilità di un ciclo al livello in cui l'improvvisazione genuina è effettivamente preziosa, i dettagli di un pezzo di lavoro limitato.
Testare Un Grafo Prima Di Fidarti
Prima di fare affidamento su un sistema strutturato a grafo per qualcosa di reale, eseguilo attraverso stress test specificamente progettati attorno ai tre impegni, poiché ogni impegno ha il suo modo di fallire silenziosamente se implementato in modo approssimativo.
Per testare l'impegno del piano immutabile, costruisci deliberatamente uno scenario a metà di un'esecuzione in cui il passo successivo "ovviamente corretto", se il sistema ragionasse liberamente, si discosterebbe dal piano bloccato. Conferma che il sistema escali effettivamente a un umano piuttosto che adattare silenziosamente il piano da solo. Se si adatta silenziosamente, il piano non è mai stato realmente immutabile in pratica, indipendentemente da come è strutturato il codice.
Per testare l'impegno dei livelli separati, controlla se i rapporti di fallimento del livello di esecuzione contengono traccia di una decisione su cosa dovrebbe succedere dopo, frasi come "questo probabilmente ha bisogno di un approccio diverso" incorporate in quello che dovrebbe essere un rapporto neutro di superato o fallito. Se il livello di esecuzione sta già formando opinioni sul recupero, la separazione dal livello di recupero non è reale, è solo stata rinominata.
Per testare l'escalation stretta, alimenta deliberatamente il sistema con un fallimento che nessuno dei due tentativi di recupero definiti può risolvere, e conferma che escali pulitamente al limite definito piuttosto che tentare un terzo approccio indefinito. Questo è l'equivalente nell'ingegneria dei grafi di testare la condizione di arresto di un ciclo contro un compito genuinamente irrisolvibile, e coglie la stessa classe di fallimento silenziosamente costoso.
Oltre a questi tre test mirati, tieni traccia di una metrica specifica nell'uso reale che l'alternativa basata su ciclo tipicamente non può darti in modo pulito: il tasso con cui le esecuzioni raggiungono lo stato Escalato, suddiviso per quale specifico tentativo di recupero è fallito ogni volta. Un grafo che scala costantemente allo stesso specifico passo di recupero ti sta dicendo che il protocollo definito di quel passo è mal calibrato, non che il compito sottostante è uniformemente difficile, lo stesso valore diagnostico che fornisce il monitoraggio dei trigger delle condizioni di arresto per i cicli, solo disponibile qui con più granularità perché il punto di fallimento è uno stato nominato e ispezionabile piuttosto che un momento inferito all'interno di una trascrizione opaca.
Errori Comuni Quando Si Costruisce Un Primo Grafo
Una manciata di errori specifici si ripresenta frequentemente per le persone che costruiscono il loro primo sistema strutturato a grafo, e conoscerli in anticipo fa risparmiare tempo di debug reale in seguito.
Trattare il piano come immutabile solo di nome. Bloccare il piano sulla carta mentre si permette ancora al livello di esecuzione di discostarsene silenziosamente in pratica produce il peggio di entrambi i mondi, nessuna reale adattabilità e nessuna reale verificabilità, poiché la traccia non corrisponde più al piano bloccato che rivedresti.
Collassare i tre livelli di nuovo in uno perché sembra più veloce da costruire. La tentazione di permettere al livello di esecuzione di decidere anche sul recupero, saltando la separazione dell'impegno due, vanifica lo scopo reale del framework. Se pianificazione, esecuzione e recupero non sono genuinamente indipendenti, hai costruito un ciclo che indossa il vocabolario di un grafo, non un vero grafo.
Scrivere un protocollo di recupero abbastanza vago da non essere realmente un protocollo. "Prova un numero ragionevole di approcci alternativi" non è un protocollo di escalation stretto, è un'istruzione morbida con la stessa modalità di fallimento di un ciclo senza limiti, solo descritta usando il linguaggio dell'ingegneria dei grafi. Un vero protocollo nomina il numero specifico di tentativi e le condizioni specifiche per ciascuno.
Saltare la valutazione onesta dell'idoneità. Costruire un grafo per un compito genuinamente aperto ed esplorativo perché l'ingegneria dei grafi è il framework più recente e dal suono più rigoroso, piuttosto che perché il compito trae effettivamente beneficio dal compromesso, produce un sistema che è più difficile da costruire di un ciclo e peggiore nel lavoro reale di quanto sarebbe stato un ciclo.
Lo Stato Onesto Delle Prove
Concludendo con l'avvertenza con cui questo corso è iniziato, perché conta di più qui che nella maggior parte degli articoli tecnici. I tre impegni descritti sopra sono una proposta reale e attentamente ragionata, analizzata contro 70 sistemi reali per identificare esattamente dove i cicli falliscono silenziosamente. Non sono ancora stati convalidati come in grado di fornire i loro benefici promessi su larga scala in produzione, per esplicita dichiarazione dell'autore.
Questo non rende il framework inutile. Lo rende un design genuinamente promettente che vale la pena comprendere e con cui sperimentare deliberatamente, monitorando i tuoi risultati onestamente piuttosto che presumere che l'argomento teorico si traduca automaticamente in pratica. Se costruisci un sistema strutturato a grafo usando questo corso, la cosa più preziosa che puoi fare è misurare se riduce effettivamente le specifiche modalità di fallimento che mira, tentativi senza limiti, deriva del piano a metà esecuzione non rilevata, decisioni di recupero non verificate, rispetto al tuo uso reale, piuttosto che presumere il miglioramento perché l'argomento è convincente sulla carta.
Quella disciplina, trattare un framework ben ragionato come un'ipotesi da testare piuttosto che un dato di fatto da adottare acriticamente, è essa stessa la vera meta-abilità alla base di tutto in questo corso. Ingegneria dei grafi, ingegneria dei cicli, qualsiasi pratica nominata in questo campo in rapida evoluzione, vale la pena impararla correttamente e vale la pena testarla onestamente rispetto ai propri risultati, piuttosto che adottata puramente perché ha un nome e un paper alle spalle.
Segui @cyrilXBT per aggiornamenti su questo framework man mano che implementazioni e risultati reali inizieranno effettivamente ad apparire.
