Graph Engineering: costruisci oltre 1000 loop di agenti da un singolo prompt

Il successore di Loop Engineering e il workflow che esegue i tuoi agenti 10 volte più in largo...

La maggior parte delle persone che costruisce un agente multi-step finisce con una linea retta

passo uno, passo due, passo tre. Ciascuno in attesa che l'ultimo finisca prima di iniziare

Ecco cosa quasi nessuno controlla:

metà di quei passi non avevano mai bisogno di aspettare

Si mettono semplicemente in coda, un lavoro alla volta, finché la finestra di contesto si riempie e l'agente dimentica cosa stava facendo

• Non era lento perché il modello era debole
• Era lento perché hai tracciato una linea dove il lavoro era un grafo

Questa guida ti porta da quella linea a un grafo che si espande su una flotta e controlla il proprio lavoro

Cinque passi. Al Passo 2 ne avrai già costruito uno -

Ti dà un grafo funzionante e nomina le trappole che rompono quelli veri, e ti indicherò dove iniziano le parti difficili

prima dell'alpha - iscriviti alla mia Substack per altra alpha fresca ↓

https://substack.com/@0xcodila

Capitolo 0 - Cos'è realmente l'ingegneria dei grafi

Un mese fa il settore parlava di loop.

Peter Steinberger l'ha colto in nove parole:

https://x.com/steipete/status/2078277297791189132

Un loop è un ciclo di miglioramento:

prova qualcosa → controlla il risultato → aggiusta → riprova

Questo è l'atomo: un singolo agente che migliora una cosa ripetutamente

(Se hai letto il mio articolo su Loop Engineering, è questo)

https://x.com/0xCodila/status/2072329149520232639

Ma il singolo loop ha un fallimento noto - un team di supporto lega un feedback loop a una metrica: tasso di risoluzione dei ticket

Il numero sale per mesi mentre la soddisfazione cala. Il bot ha imparato a chiudere i ticket velocemente invece di risolverli

Questa è la legge di Goodhart. Un loop può vedere solo la propria metrica. Non può chiedersi se l'obiettivo è giusto, né notare che la sua stessa misurazione sta derivando.

La risposta non è un loop migliore. È un grafo di loop - una rete dove i cicli si osservano e si correggono a vicenda

Per gli agenti, questo significa una cosa sola:

Smetti di scrivere un agente che fa tutto in linea - progetta la

forma

del lavoro - cosa gira prima di cosa, cosa gira contemporaneamente, cosa aspetta.

I nodi fanno il pensiero. Gli archi trasportano i risultati

E Claude Code ha rilasciato gli strumenti per costruirli direttamente: workflow dinamici

Passo 1 - Vedi gli archi che non ci sono

Un grafo ha due parti:

• Un nodo è un'unità di lavoro: un agente, un lavoro, un input, un output
• Un arco è una dipendenza: l'output di questo nodo alimenta l'input di quel nodo

L'errore che tutti fanno è trattare "e poi" come un arco.

"Riassumi questo file

e poi

dimmi il meteo"

Il meteo non legge il riassunto.

Sono due lavori indipendenti che uno script lineare mette in catena senza motivo. Ciascuno aspetta l'altro per niente

L'abitudine che fa iniziare tutto:

Per ogni "e poi", chiediti - il passo successivo legge davvero l'output del passo precedente?

• Se sì → arco vero. Mantieni l'ordine.
• Se no → nessun arco. L'attesa è sprecata. Esegui in parallelo.

Se nessun dato passa tra due scatole, sono indipendenti.

Quell'indipendenza è ciò che sfrutterai per il resto di questa guida

Il tuo semplice agente "fai A, poi B, poi C" è già un grafo - solo il più triste: una singola catena dove se C si blocca, D non succede mai.

Passo 2 - Costruisci il tuo primo grafo (dall'inizio alla fine)

Basta teoria. Costruiscine uno e guardalo funzionare.

Prima di iniziare:

• Claude Code v2.1.154+ (controlla con claude --version)
• Un piano a pagamento. Su Max, Team o Enterprise, i workflow sono attivi di default. Su Pro, attiva la riga Workflow dinamici in /config

1. Apri un repository che conosci.

Uno vero, così il risultato avrà senso.

2. Incolla questo prompt (da Anthropic):

1Crea un workflow per esaminare ogni file di route sotto src/routes/
2alla ricerca di controlli di autenticazione mancanti. Avvia un agente per file, poi esegui un
3verificatore indipendente su ogni risultato prima di generare il report.
4Analizza un massimo di 20 file per iniziare.

Sostituisci src/routes/ con dove risiedono i tuoi file. La riga "max 20" mantiene economica la tua prima esecuzione.

3. Guarda "workflow" accendersi.

Claude Code lo evidenzia: "Dynamic workflow requested." Questo è il segnale che si sta costruendo un grafo, non una chat normale

4. Approva il piano.

Claude scrive uno script di orchestrazione JavaScript e mostra prima le fasi. Leggile, scegli "Sì, eseguilo."

5. Lascia correre la flotta.

Un agente per file, in parallelo, mentre la tua sessione rimane libera.

Digita /workflows per vederlo dal vivo: scope, fan-out, verifica, sintesi.

6. Leggi l'unica risposta.

Non venti chat separate. Un singolo report - perché i risultati intermedi vivevano nelle variabili dello script, non nel tuo contesto.

Questo è un grafo.

Una dozzina di agenti, da una sola frase.

Sull'affermazione "zero token" che sentirai

Lo script di coordinamento è codice

Quindi passare risultati tra agenti non consuma di nuovo contesto come farebbe un passaggio di chat.

Ma gli agenti costano comunque in utilizzo. Un workflow costa significativamente di più di una sessione normale.

Il risparmio sta nel coordinamento, non nel lavoro. Inizia con un ambito limitato, controlla l'utilizzo, poi allarga.

• Rendilo tuo

Quando un'esecuzione è buona, premi s.

Viene salvata in ~/.claude/workflows, rieseguibile per nome

Ora cambia il compito e mantieni la forma. Sostituisci "controlli di autenticazione mancanti" con "promesse non gestite" o "funzioni oltre 100 righe

Quanto scala (nome dell'articolo)

Una singola esecuzione di workflow può espandersi fino a 1.000 agenti, con un massimo di 16 che lavorano contemporaneamente

Da qui viene "1000+ loop in una finestra" - non una metafora, il limite effettivo della funzionalità

• E la scala è il punto Mille agenti significano un lavoro che nessun singolo contesto potrebbe mai contenere - un'intera codebase esaminata in una volta, una migrazione che tocca ogni file, una ricerca che esegue mille angolazioni in parallelo

Il limite di 16 alla volta significa semplicemente che la flotta si muove a ondate, consumando tutti e mille senza che tu debba supervisionarne nemmeno uno

Inizia con 20 per vedere come si comporta un'esecuzione e quanto costa - poi allarga - perché questo è il soffitto contro cui nessun altro sta costruendo

Passo 3 - La parte che si rompe davvero

Hai costruito un grafo. Ecco dove cadono quelli veri.

Due fallimenti contano di più

• Fallimento uno: il grafo è d'accordo con se stesso

Quando un agente controlla il proprio lavoro, è indulgente con se stesso. I modelli preferiscono i propri output

Quindi metti un verificatore sull'arco - un nodo separato che conferma un risultato prima che fluisca a valle.

L'inghippo che nessuno nomina: il verificatore ha bisogno di un contesto pulito

Dagli la stessa conversazione che ha avuto l'esecutore, e non sta verificando. Sta concordando con se stesso in un font diverso

Un grafo di agenti che condividono un contesto è un singolo loop travestito. Fallisce allo stesso modo - più tardi, più costosamente, con più semafori verdi sulla strada verso il basso

Quindi il verificatore è un nodo fresco - Contesto proprio - Che controlla un segnale reale - non "l'agente ha detto di aver finito," ma "il test passa davvero"

• Fallimento due: agenti che si pestano i piedi a vicenda

Non è un'ipotesi

Quando il team di Bun ha distribuito per la prima volta un grande porting su molti agenti, l'esecuzione è fallita operativamente e gli agenti hanno usato comandi git condivisi in un unico workspace e si sono sovrascritti a vicenda

La soluzione è stata strutturale, non un prompting intelligente. Hanno vietato i comandi non sicuri e hanno dato a ogni gruppo il proprio worktree isolato

Questa è la vera lezione del parallelismo - due agenti che scrivono lo stesso file fanno una corsa

Prima di espanderti, rispondi a tre domande:

• Dove lavora ciascun agente?
• Come si fondono i risultati?
• Cosa succede quando due sono in disaccordo?

Un grafo senza quel piano non scala - Fallisce più velocemente

Passo 4 - Sei grafi da costruire questa settimana

Il metodo: trova gli archi reali → espandi → verifica su contesto indipendente → isola i lavoratori

///

Ognuno di questi è la stessa forma, mirata a un nuovo lavoro. Cambia la riga del compito e vai:

• Sweep di sicurezza - un agente per file a caccia di autenticazione mancante, un verificatore che conferma ogni risultato (quello che hai costruito)
• Report citato con /deep-research - già spedito: divide la tua domanda in angolazioni, cerca in parallelo, gli agenti si confutano a vicenda prima di scrivere
• Porta un modulo - file per file, test come gate, fallimenti re-indirizzati al loop
• Revisione di diff avversariale - instradata per dimensione: modifica piccola → un passaggio; grande → audit parallelo completo
• Scansione ecologica programmata - salva una volta, riesegui per nome
• Scoperta di dimensione sconosciuta - i finder girano in parallelo, ogni risultato controllato contro tutto ciò che è stato visto, looping fino a quando due round non trovano nulla di nuovo

///

Come appare il soffittohttps://simonwillison.net/2026/Jul/8/rewriting-bun-in-rust/

Il porting da Zig a Rust di Bun è stato eseguito su questo stesso meccanismo.

Circa 50 workflow, un picco di 64 agenti in parallelo. Circa 535.000 righe di Zig trasformate in oltre un milione di righe di Rust, in 11 giorni.

È costato anche circa $165.000 in utilizzo, e ha avuto bisogno di un umano che progettasse e monitorasse il tutto

E ha attirato critiche pubbliche sul fatto che così tanto codice generato dall'IA possa essere revisionato in sicurezza.

La scala è reale. Così come il prezzo e la supervisione

Passo 5 - Le ancore che mantengono onesto un grafo

La topologia da sola non compra la verità

Una rete di agenti che si confermano a vicenda, nessuno dei quali tocca nulla di reale, fallisce esattamente come il singolo loop - solo con più parti mobili

Il grafo ha bisogno di ancore: nodi con cui non si può discutere

• Test che sono stati effettivamente eseguiti - non "dovrebbero passare," hanno passato
• Un verificatore basato su prove, non su sensazioni
• Regole congelate che gli agenti non possono mai modificare - perché sono quelle che un ottimizzatore indebolirebbe

Il grafo è onesto tanto quanto le cose al suo interno che si rifiutano di muoversi

Quando un grafo è la scelta sbagliata

La maggior parte dei compiti non sono grafi. Ricorrere a uno quando non serve brucia solo soldi e aggiunge modi per fallire.

Salta il grafo quando:

• Il compito è piccolo o isolato. Aggiungere una funzione, correggere un bug. Un workflow qui è puro overhead - un singolo agente è più veloce ed economico.
• Hai bisogno di una supervisione stretta. Se vuoi leggere e approvare ogni passo prima che il successivo venga eseguito, l'intero punto di un grafo (girare in largo senza di te) lavora contro di te.
• Non sai ancora cosa stai cercando. Il lavoro esplorativo vuole un agente che puoi guidare, non una flotta impegnata in un piano prima che tu capisca il problema.
• I passi dipendono genuinamente l'uno dall'altro. Se ogni passo legge l'output del passo precedente, è una vera catena. Il parallelismo non ha nulla da afferrare. Forzare un grafo su un compito veramente sequenziale aggiunge solo costo di coordinamento per zero accelerazione.

L'indizio è il Passo 1. Se non riesci a trovare due scatole senza freccia tra di loro, non c'è grafo da costruire. È un loop, e un loop va bene.

Un grafo è uno strumento per la larghezza - lavoro indipendente, fatto in una volta

Quando il lavoro non è largo, la linea non è mai stata il problema...

Il cambiamento

Un prompt engineer fa una domanda. Un architetto disegna un grafo.

L'agente lineare non è mai stato il soffitto.

Era la prima forma - quella a cui tutti ricorrono perché corrisponde a come digitiamo: una linea, una cosa alla volta.

Una volta che vedi i nodi e gli archi, smetti di chiedere all'agente di fare di più e inizi a chiedere al grafo di farlo in largo:

• Espandi dove il lavoro è indipendente
• Metti un gate sugli archi dove la fiducia conta
• Congela i nodi che contengono la verità

La maggior parte delle persone continuerà a mettere in coda i passi in una linea.

I pochi che imparano a disegnare il grafo, e a rispettare ciò che lo rompe, faranno girare una flotta.

Disegna il grafo. Rimani l'architetto.

Inizia con il prerequisito:

Loop Engineering

- il singolo loop su cui questo è costruito

@0xCodila