Le cinque tier di lavoro per gli agenti

Quando si progetta un agente, è utile suddividere le attività in cinque livelli distinti, che vanno da una domanda rapida fino a un sistema continuo e auto‑monitorato.

1. Domanda semplice

    • Non richiede un agente: un assistente può rispondere direttamente.

2. Compito o idea

    • Un singolo prompt è sufficiente per una risposta zero‑shot.
    • Google AI Studio consente di trasformare rapidamente idee in prototipi funzionali.

3. App, funzionalità più ampia o story

    • Richiede pianificazione settimanale e suddivisione in sotto‑compiti.
    • Qui entrano in gioco i loop e gli agenti completi, come Google Antigravity.
    • Il “steering” avviene a monte: si fissano specifiche, piani e test eseguibili prima dell’avvio del loop.

4. Progetto o epic

    • Un insieme di funzionalità collegate che formano una storia coerente.
    • I loop possono supportare anche la fase di pianificazione.
    • Supera il semplice prompting a turni.

5. Sistema

    • Visione d’insieme di tutti i progetti e compiti.
    • Si redigono file AGENTS.md, si creano skills, si impostano sidecars e si collegano verification gates.
    • Un “instrument cluster” monitora l’intero ecosistema.
    • I loop a questo livello generano il maggior impatto, ma comportano anche rischi più alti.

Figura 1 (non mostrata) illustra queste cinque tier, dal singolo prompt ai loop agentici verificati.

Perché introdurre i loop?

Lo sviluppo software tradizionale sta subendo una trasformazione fondamentale: la ricerca del più alto “leverage” porta dall’attività manuale alla delega, fino all’orchestrazione completa. L’attenzione è diventata il nuovo collo di bottiglia; ridurre le interruzioni permette di avanzare più rapidamente.

Entro il 2026, studi empirici su progetti open‑source hanno stimato che l’adozione di agenti di codifica si era attestata tra il 22 % e il 29 % di oltre 128 000 repository attivi su GitHub. Chi padroneggia i flussi di lavoro agentici ottiene un vantaggio di produttività per l’intero team, ma al contempo aumenta il carico cognitivo a livello sistemico.

Per comprendere questa evoluzione, è utile risalire alle radici accademiche dei loop e definire aspettative di alto livello.

Fondamenti accademici

Il punto di partenza è il paper ReAct di Yao et al., pubblicato nell’ottobre 2022. Il modello intercalava tracce di ragionamento con chiamate a strumenti, superando i benchmark di reinforcement learning del 34 % su ALFWorld e del 10 % su WebShop, dimostrando che “ragionare prima di agire” migliora le prestazioni, proprio come avviene negli esseri umani.

Nel 2023 è emerso AutoGPT, attirando milioni di dollari di venture capital. Le prime versioni di ReAct tendevano a cadere in loop infiniti, rivelando la necessità di guardrail strutturali per garantire automazione “hands‑off”.

Sperimentazioni senza stato (stateless)

Nel mezzo del 2025 gli sviluppatori hanno sperimentato loop bash “stateless”, inviando prompt a agenti da riga di comando e resettando i file di contesto ad ogni iterazione. Il reset impedisce il “cognitive bloat” e riconosce che anche i modelli hanno limiti di memoria analoghi a quelli umani.

Il “durable state” viveva fuori dal modello: nella cronologia Git, nei file di progresso e nella suite di test. Questo approccio ha permesso di costruire compilatori auto‑hostati in pochi mesi di esecuzioni automatiche. Nella primavera 2026, ambienti di sviluppo principali hanno integrato il pattern, introducendo comandi nativi come /goal per eseguire loop non supervisionati.

Matematica dell’autonomia

Un agente inserito in una catena sequenziale di N passi subisce una degradazione esponenziale della probabilità di successo. Se ogni passo ha una probabilità di successo p, la probabilità cumulativa è pⁿ. Esempio:

    • 20 modifiche di file consecutive con p = 0.95 → probabilità di successo ≈ 36 %.
    • Con p = 0.75, al passo 10 la probabilità scende sotto il 6 %.

Queste cifre dimostrano che, senza interventi strutturali, il fallimento è quasi certo.

Un “evaluation loop” efficace non deve far riprovare l’agente all’infinito; deve individuare l’errore e concedere un unico tentativo mirato di correzione. Se l’agente ha un’accuratezza di base del 95 % e il loop rileva e corregge l’errore con il 95 % di probabilità, la probabilità di successo per quel passo sale a:

0.95 + (0.05 × 0.95) = 99.75 %

Il gate di verifica deve essere indipendente dal worker: compilatori, suite di test e linter forniscono questo controllo “gratis”. Per giudizi semantici non coperti da test deterministici, si usano modelli di famiglie diverse per evitare “blind spot” condivisi.

Tabella di probabilità di completamento

Lunghezza della catenaAccuratezza 95 % (senza loop)Loop 95 % × 95 % (correzione)
3 passi86 %99 %
5 passi77 %99 %
10 passi60 %98 %
15 passi46 %96 %
20 passi36 %95 %
30 passi21 %93 %
50 passi8 %88 %

Gestione del contesto

Ogni passo aggiunge circa l’1 % di token al contesto. Dopo circa 50 passi è necessario comprimere. Un agente con 95 % di accuratezza, valutato e corretto con la stessa affidabilità, mantiene buone probabilità di successo fino a 20‑30 passi prima di richiedere compressione.

La strategia consigliata è “divide et impera”: suddividere i problemi in sotto‑compiti di 20 passi al massimo, assegnare a ogni sub‑agente un budget simile e prevedere un agente supervisore che consolidi i risultati. Ogni livello deve avere una valutazione indipendente e un criterio di accettazione finale.

Implementazione pratica in Google Antigravity

Per tradurre questi principi in un progetto reale, segui questi passaggi:

    • Definisci le tier: classifica ogni attività secondo le cinque categorie illustrate.
    • Scrivi AGENTS.md: descrivi gli obiettivi, le skill richieste e i sidecar da collegare.
    • Configura i verification gates: integra test unitari, lint, suite di integrazione e valutazioni comportamentali.
    • Costruisci i loop usando le API di Antigravity:
      • Avvia un /goal che esegue il primo passo.
      • Al termine, verifica l’output con il gate.
      • Se l’errore è identificato, consenti un singolo retry mirato.
    • Monitora il contesto: ogni 20‑30 passi, esegui una compressione o una snapshot del repository.
    • Supervisione multilivello: crea un agente di livello superiore che raccoglie i risultati dei sub‑agenti, esegue una valutazione aggregata e decide se avanzare o richiedere intervento umano.

Esempio di scenario completo

Supponiamo di dover sviluppare una piattaforma di e‑learning con tre feature principali: gestione corsi, tracciamento progressi e integrazione video. Si procede così:

    • Tier 3 (story): per ogni feature si definisce uno spec, un piano di sprint e test di accettazione.
    • Loop per la feature “gestione corsi”:
      • Passo 1: generazione schema DB.
      • Passo 2: creazione API CRUD.
      • Passo 3: test unitari.
      • Passo 4: verifica con linter.
    • Ogni passo è valutato; in caso di fallimento, il loop consente un retry unico.
    • Al completamento della feature, un agente supervisore verifica l’integrazione con le altre due feature.

Con un’accuratezza di base del 95 % e un loop di correzione al 95 %, la probabilità di completare correttamente la feature resta sopra il 95 % anche con 15‑20 passi.

Rischi e mitigazioni

I loop a livello di sistema introducono rischi di:

    • Drift: l’allineamento tra sub‑agenti può divergere nel tempo.
    • Loop infinito: gate di verifica mal configurati possono generare retry senza fine.
    • Over‑compressione: perdita di informazioni rilevanti durante la riduzione del contesto.

Le contromisure includono:

    • Logica di timeout e limite di retry (es. massimo 1 retry per passo).
    • Snapshot regolari del repository e dei file di stato.
    • Valutazioni incrociate con modelli di famiglia diversa per ridurre bias.

Conclusioni

Passare da prompt singoli a loop agentici durevoli richiede una progettazione attenta del “harness” che avvolge il modello. Le cinque tier di lavoro forniscono una mappa di riferimento; i loop di verifica, con una singola correzione mirata, trasformano una probabilità di successo esponenzialmente decadente in una robusta sopra il 95 %.

Google Antigravity mette a disposizione gli strumenti necessari: /goal, API di verifica, sidecar e la possibilità di definire file AGENTS.md. Applicando i principi descritti, gli sviluppatori possono costruire sistemi agentici scalabili, sicuri e pronti a sostenere progetti complessi senza incorrere in errori di cascata o in perdita di contesto.