Come costruire agenti AI che si auto-migliorano con la Loop Engineering

Ecco la traduzione in italiano del testo fornito, seguendo tutte le linee guida specificate.

La maggior parte degli agenti AI non fallisce perché il modello è debole.

Falliscono perché il sistema intorno al modello è debole.

Un prompt è vago.

Una chiamata a uno strumento si rompe.

L'agente riprova la cosa sbagliata.

Dimentica ciò che ha imparato due passaggi fa.

Ripete la stessa azione sbagliata.

Dichiara il successo troppo presto.

E nessuno ha costruito il ciclo di feedback che avrebbe potuto cogliere l'errore.

Questo è il vero problema.

Se vuoi costruire agenti AI che migliorano effettivamente nel tempo, hai bisogno di più che di prompt migliori, più strumenti o più autonomia.

Hai bisogno di loop engineering.

Il loop engineering è la disciplina di progettare come un agente:

• osserva ciò che è successo
• valuta se ha funzionato
• aggiorna la sua mossa successiva
• memorizza feedback utili
• riprova o scala in modo intelligente
• migliora invece di diventare solo più impegnato

Questo cambiamento è importante.

Perché la prossima generazione di agenti AI utili non sarà definita da quanto appaiono impressionanti in una singola esecuzione dimostrativa.

Saranno definiti dalla loro capacità di:

• riprendersi dagli errori
• imparare dai fallimenti ripetuti
• migliorare la qualità senza bisogno di supervisione umana costante
• rimanere limitati, misurabili e affidabili in produzione

Questo è l'argomento di questo articolo.

Vuoi altri sistemi AI pratici come questo? ByteBuilders condivide analisi brevi e utili su Claude, flussi di lavoro AI, prompt, automazione e sistemi di ingegneria reali.

Iscriviti qui:

https://bytebuilders.beehiiv.com/subscribe

Se capisci il loop engineering, smetti di costruire agenti fragili che funzionano solo quando tutto va per il verso giusto.

Inizi a costruire sistemi che migliorano perché sono stati progettati per imparare.

Primo, cosa significa realmente "auto-miglioramento"

Molte persone sentono "agente auto-migliorante" e immaginano un sistema che si riaddestra magicamente o si evolve in qualcosa di autonomo e misterioso.

Questa non è la definizione utile.

Un agente auto-migliorante è di solito molto più semplice.

È un agente che può usare segnali dai tentativi precedenti per prendere decisioni migliori al tentativo successivo.

Questo può avvenire attraverso:

• nuovi tentativi con un contesto migliore
• revisione basata sulla valutazione
• memoria dei fallimenti precedenti
• correzioni nell'uso degli strumenti
• punteggio dell'output
• cicli di feedback umano
• aggiornamenti delle regole
• modelli di successo memorizzati

In altre parole:

l'auto-miglioramento di solito non è evoluzione del modello. È evoluzione del ciclo.

Il modello di base può rimanere lo stesso.

Ciò che migliora è il comportamento del sistema intorno al modello.

Questa è una prospettiva molto più pratica e favorevole all'ingegneria.

Perché la maggior parte degli agenti non migliora da sola

Un numero sorprendente di agenti non è effettivamente progettato per migliorare.

Sono progettati per continuare.

Non è la stessa cosa.

Molti sistemi di agenti oggi sono fondamentalmente:

1. leggere il compito
2. pensare
3. chiamare lo strumento
4. continuare fino a quando non vengono fermati

Il problema è che questa struttura spesso manca di:

• criteri di successo espliciti
• classificazione dei fallimenti
• nuovi tentativi consapevoli dello stato
• memoria di ciò che è già fallito
• confronto tra tentativi
• valutazione dell'output
• regole di escalation

Quindi l'agente non migliora.

Semplicemente va in loop.

Questa è la differenza tra iterazione grezza e iterazione intelligente.

Il loop engineering è ciò che crea questa differenza.

Il loop engineering è il vero livello architetturale

Il modo più semplice per capire il loop engineering è questo:

Il prompting dice al modello cosa fare.

Il loop engineering dice al sistema come comportarsi dopo aver provato.

Questo include domande come:

• Cosa dovrebbe fare l'agente dopo una chiamata a uno strumento fallita?
• Quando dovrebbe riprovare rispetto a cambiare strategia?
• Quanti tentativi sono consentiti?
• Cosa dovrebbe essere memorizzato?
• Cosa dovrebbe essere valutato automaticamente?
• Quando dovrebbe intervenire un umano?
• Cosa conta come miglioramento?

Ecco perché il loop engineering appartiene alla conversazione sull'architettura, non solo a quella sul prompt.

Il ciclo principale alla base degli agenti auto-miglioranti

La maggior parte degli agenti auto-miglioranti utili segue una struttura ripetuta che assomiglia a questa

1Obiettivo
2  ↓
3Pianifica
4  ↓
5Agisci
6  ↓
7Osserva il risultato
8  ↓
9Valuta la qualità
10  ↓
11Memorizza il segnale
12  ↓
13Riprova / rivedi / scala / finalizza

Questa è la base.

Il sistema migliora quando ogni passaggio attraverso il ciclo modifica la decisione successiva in modo utile.

Non tutti gli agenti hanno bisogno di una versione complessa.

Ma ogni agente affidabile ha bisogno di una qualche versione di questo.

La differenza tra un agente ingenuo e un agente con loop engineering

Dimensione

Agente Ingenuo

Agente con Loop Engineering

Gestione del compito

tenta il compito una volta o continua ciecamente

lavora attraverso cicli limitati

Risposta agli errori

riprova a caso o fallisce duramente

riprova in base al fallimento classificato

Memoria

poco o nessuno stato utile

memorizza il contesto utilizzabile

Valutazione

presuppone che il completamento significhi successo

controlla gli output rispetto ai criteri

Miglioramento

accidentale

progettato

Ruolo umano

solo fallback di emergenza

punto di escalation deliberato

Affidabilità

incoerente

progressivamente più forte nel tempo

Questo è il cambiamento.

L'agente con loop engineering non è necessariamente "più intelligente" a livello di modello.

Opera semplicemente all'interno di un sistema migliore.

I cinque elementi costitutivi degli agenti auto-miglioranti

Se vuoi che un agente migliori, hai bisogno di un ciclo con una struttura.

Questi cinque elementi costitutivi sono i più importanti.

1. Criteri di successo chiari

Se il sistema non sa che aspetto ha "buono", non può migliorare verso quello.

I criteri di successo possono essere:

• formato di output esatto
• soglia di correttezza
• requisito di risposta fondata
• segnale di completamento dello strumento
• risultato del test superato
• approvazione umana
• punteggio specifico del compito

Senza questo, l'agente non ha nulla di stabile su cui ottimizzare.

1. Livello di valutazione

Il livello di valutazione è ciò che dice all'agente se il suo tentativo ha funzionato.

Questo può essere:

• controlli basati su regole
• validazione dello schema
• test unitari
• punteggio LLM-as-judge
• controlli di fondatezza del recupero
• validazione della logica di business
• revisione umana

Questa è la differenza tra "ha prodotto una risposta" e "ha prodotto una risposta utile".

1. Memoria di feedback

L'auto-miglioramento richiede memoria, ma non solo la cronologia grezza.

L'agente ha bisogno di memoria utilizzabile.

Una buona memoria di feedback include cose come:

• motivo dell'ultimo fallimento
• errore dello strumento precedente
• percorso di successo noto migliore
• strategia negativa nota da evitare
• preferenza o correzione dell'utente
• riepilogo compresso dei tentativi precedenti

Non tutto il contesto dovrebbe persistere.

Solo il contesto che aiuta la decisione successiva.

1. Revisione della strategia

Dopo la valutazione, l'agente deve decidere cosa cambiare.

Questo può includere:

• provare un nuovo strumento
• restringere il compito
• fare una domanda chiarificatrice
• recuperare più informazioni
• passare dall'azione alla spiegazione
• scalare a un umano

È qui che il sistema diventa effettivamente adattivo.

1. Limiti e condizioni di arresto

Un agente auto-migliorante ha comunque bisogno di controllo.

Altrimenti non ottieni miglioramento.

Ottieni caos.

Imposta limiti per:

• nuovi tentativi
• costo
• latenza
• azioni distruttive
• soglie di approvazione umana
• regole di abbandono del compito

Un ciclo limitato è più prezioso di uno senza vincoli.

Che aspetto ha il loop engineering nella pratica

Ecco un modello semplice che funziona bene per molti agenti.

Ciclo 1: tentativo

L'agente prova il compito con il contesto corrente.

Ciclo 2: valuta

Viene eseguito un controllo.

Esempi:

• lo schema è stato validato?
• il codice ha superato i test?
• la risposta ha citato la fonte richiesta?
• lo strumento ha restituito i campi corretti?

Ciclo 3: diagnostica

Se è fallito, classifica il perché.

Esempi:

• contesto mancante
• argomenti dello strumento errati
• fallimento del recupero
• presupposto allucinato
• output incompleto
• conflitto di policy

Ciclo 4: adatta

Modifica il tentativo successivo.

Esempi:

• recupera più contesto
• riscrivi il compito in modo più ristretto
• prova uno strumento diverso
• aggiungi regole di validazione
• chiedi all'utente il dettaglio mancante

Ciclo 5: memorizza il segnale utile

Salva solo ciò che aiuta le esecuzioni future.

Poi ripeti.

Questo è il loop engineering in termini operativi.

Un diagramma pratico per agenti con loop engineering

1Obiettivo Utente
2   ↓
3Interprete del Compito
4   ↓
5Pianificatore
6   ↓
7Livello Strumenti / Azioni
8   ↓
9Risultato
10   ↓
11Valutatore
12   ├── superato → finalizza
13   ├── fallito: contesto mancante → recupera di più
14   ├── fallito: uso errato dello strumento → rivedi azione
15   ├── fallito: bassa confidenza → scala
16   └── fallito: recuperabile → riprova con memoria

È qui che la qualità dell'agente diventa sistematica invece che accidentale.

Da dove dovrebbero provenire i segnali di auto-miglioramento

Questa è una delle domande di progettazione più importanti.

Se inserisci i segnali sbagliati nel ciclo, l'agente potrebbe ottimizzare nella direzione sbagliata.

Fonti forti di segnali di miglioramento includono:

Segnali deterministici

• test superati o falliti
• schema validato o fallito
• stato API è successo o errore
• l'output contiene i campi richiesti o no
• regola di policy soddisfatta o violata

Segnali del flusso di lavoro

• conteggio dei nuovi tentativi
• latenza dello strumento
• passaggio in cui si è verificato il fallimento
• soglia di confidenza superata
• frequenza di escalation

Segnali umani

• pollice su / pollice giù
• output corretto
• bozza accettata versus rifiutata
• modelli di override manuale
• note del revisore

Segnali comparativi

• qualità dell'output versione A versus versione B
• confronto delle varianti di recupero
• confronto del percorso dello strumento
• miglioramento del punteggio su esecuzioni ripetute

I migliori agenti auto-miglioranti di solito combinano almeno due di queste categorie.

I cicli migliori migliorano il flusso di lavoro, non solo la risposta

È qui che la progettazione diventa più matura.

Un'implementazione debole usa i cicli solo per rigenerare il testo.

Un'implementazione più forte usa i cicli per migliorare l'intero flusso di lavoro.

Ciò significa che l'agente può migliorare cambiando:

• cosa recupera
• quali strumenti usa
• l'ordine dei passaggi
• cosa ricorda
• cosa ignora
• se chiede chiarimenti prima
• se si ferma prima

Questo è molto più potente di "riscrivi la risposta di nuovo".

Il sistema diventa auto-correttivo a livello di processo.

Modelli di prompt che supportano l'auto-miglioramento

Il prompting conta ancora.

Deve solo supportare il ciclo.

Ecco alcuni modelli di prompt utili.

Prompt 1: prompt d'azione consapevole della valutazione

1Stai eseguendo un compito all'interno di un flusso di lavoro limitato.
2Il tuo obiettivo non è solo produrre una risposta, ma produrre una risposta che supererà la valutazione.
3Se mancano informazioni, chiedile o recuperale.
4Se il risultato è incerto, non finalizzare con sicurezza.
5Se un tentativo precedente è fallito, evita di ripetere la stessa strategia a meno che il contesto non sia cambiato.

Prompt 2: prompt di diagnosi del fallimento

1Il tentativo precedente è fallito.
2Classifica la probabile causa del fallimento in una di queste categorie:
3- contesto mancante
4- uso improprio dello strumento
5- presupposto errato
6- output incompleto
7- fallimento di formattazione o schema
8- conflitto di policy
9Poi proponi il più piccolo cambiamento successivo che migliori le probabilità di successo.

Prompt 3: prompt di revisione

1Rivedi il tentativo successivo usando il feedback del valutatore qui sotto.
2Non ripetere lo stesso percorso di ragionamento se è già fallito.
3Preferisci una soluzione più ristretta e fondata.
4Se necessario, recupera più contesto prima di rispondere.

Prompt 4: prompt di riepilogo della memoria

1Riassumi l'ultimo tentativo in un breve blocco di memoria per l'esecuzione successiva.
2Includi solo:
3- cosa è fallito
4- cosa ha funzionato
5- cosa dovrebbe essere evitato
6- cosa dovrebbe essere provato dopo
7Mantienilo sotto le 120 parole.

Questi non sono prompt magici.

Sono prompt progettati per rafforzare il comportamento del ciclo.

Un'architettura a ciclo semplice in stile Python

Di seguito è riportato un esempio semplificato di come il loop engineering può apparire nel codice

1MAX_ATTEMPTS = 4
2
3memory = []
4
5for attempt in range(MAX_ATTEMPTS):
6    context = build_context(task=task, memory=memory)
7    plan = agent.plan(context)
8    result = agent.act(plan)
9
10    evaluation = evaluator.check(task=task, result=result)
11
12    if evaluation.passed:
13        return {
14            "status": "success",
15            "result": result,
16            "attempt": attempt + 1,
17        }
18
19    failure_summary = agent.summarize_failure(
20        result=result,
21        evaluation=evaluation,
22    )
23
24    memory.append({
25        "attempt": attempt + 1,
26        "failure": failure_summary,
27        "suggested_fix": evaluation.next_step,
28    })
29
30    if evaluation.requires_human:
31        return {
32            "status": "escalated",
33            "reason": evaluation.reason,
34            "attempt": attempt + 1,
35            "memory": memory,
36        }
37
38return {
39    "status": "failed",
40    "reason": "max_attempts_reached",
41    "memory": memory,
42}

Questo è intenzionalmente semplice.

Il punto importante non è il codice in sé.

È la struttura:

• tentativo
• valuta
• memorizza segnale
• adatta
• riprova o scala

Questo è il modello da interiorizzare.

Dove il loop engineering è più importante

Questo approccio è particolarmente prezioso nei flussi di lavoro in cui il successo non è garantito al primo tentativo.

Agenti di codifica

Perfetti per i cicli perché il sistema può:

• eseguire test
• ispezionare i fallimenti
• rivedere il codice
• confrontare gli output
• fermarsi solo quando la verifica passa

Agenti di supporto

Utili perché il sistema può:

• recuperare il contesto delle policy
• abbozzare una risposta
• controllare la fondatezza
• chiedere approvazione se il rischio è alto

Agenti di ricerca

Utili perché il sistema può:

• raccogliere più fonti
• identificare lacune
• cercare di nuovo
• sintetizzare solo quando le prove sono sufficienti

Agenti di estrazione documenti

Utili perché il sistema può:

• analizzare i file
• validare lo schema
• riprovare campi ambigui
• scalare i casi a bassa confidenza

Agenti di flussi di lavoro operativi

Preziosi perché il sistema può:

• chiamare API
• controllare i risultati
• riprendersi da fallimenti parziali
• instradare le eccezioni agli umani

In tutti questi casi, la qualità del ciclo conta più della qualità della generazione singola.

Errori comuni nel loop engineering

Errore 1: trattare i nuovi tentativi come miglioramento

Più tentativi non significano automaticamente un apprendimento migliore.

Se il sistema ripete lo stesso comportamento, non sta migliorando.

Sta solo andando in loop.

Errore 2: memorizzare troppa memoria

Non tutto il contesto passato aiuta.

Troppa memoria può inquinare il tentativo successivo.

Memorizza lezioni compresse e utilizzabili, non cumuli di trascrizioni grezze.

Errore 3: saltare la valutazione

Senza un controllo, l'agente non può sapere se è migliorato.

Questo è il fallimento strutturale più comune.

Errore 4: nessuna condizione di arresto

Un agente senza vincoli non è avanzato.

È costoso.

Errore 5: ignorare il feedback umano

Se gli umani continuano a correggere la stessa cosa e il ciclo non usa mai quel segnale, il sistema non sta realmente migliorando.

Errore 6: usare un unico ciclo gigante per ogni compito

Compiti diversi hanno bisogno di cicli diversi.

Un agente di supporto e un agente di codifica non dovrebbero condividere la stessa logica di ripetizione o le stesse regole di valutazione.

La sequenza pratica di costruzione che raccomando

Se stai costruendo da zero, usa questo ordine.

Passo 1: definisci il successo chiaramente

Che aspetto ha un buon risultato?

Passo 2: definisci le categorie di fallimento

Perché questo agente fallisce di solito?

Passo 3: costruisci prima il valutatore

Come farà il sistema a sapere se ha avuto successo o fallito?

Passo 4: progetta le regole di memoria

Cosa dovrebbe persistere tra un tentativo e l'altro?

Passo 5: definisci la strategia di ripetizione

Cosa cambia tra il tentativo uno e il tentativo due?

Passo 6: aggiungi la logica di escalation

Quando dovrebbe intervenire un umano?

Passo 7: registra tutto ciò che è importante

Non puoi migliorare ciò che non osservi.

Passo 8: ottimizza solo dopo che il ciclo funziona

Non complicare eccessivamente il sistema prima che il ciclo principale sia stabile.

Questa sequenza mantiene i team concentrati sul comportamento invece che sull'hype.

Una semplice lista di controllo prima di chiamare un agente "auto-migliorante"

Usala come controllo di realtà.

• L'agente sa che aspetto ha il successo?
• Valuta ogni tentativo?
• Memorizza lezioni utili dal fallimento?
• Cambia strategia in base al feedback?
• Evita di ripetere ciecamente lo stesso percorso fallito?
• Sa quando fermarsi?
• Sa quando scalare a un umano?
• Puoi misurare se sta effettivamente migliorando?

Se la maggior parte di questi elementi manca, probabilmente il sistema non è auto-migliorante.

È solo iterativo.

Considerazioni finali

Il futuro degli agenti AI non sono solo prompt migliori, più strumenti o catene più lunghe.

Sono cicli migliori.

Questo è ciò che il loop engineering rende possibile.

Trasforma un agente da un generatore monouso in un sistema che può:

• osservare
• valutare
• adattare
• ricordare
• riprovare intelligentemente
• migliorare in condizioni reali

Ecco cosa significa realmente auto-miglioramento nell'AI di produzione.

Non mistero.

Non magia.

Solo una migliore progettazione del sistema.

Se vuoi agenti più forti, non chiederti solo come farli agire.

Chiediti come farli imparare da ciò che è successo dopo.

È lì che si trova la vera leva.