martedì 22 settembre 2026

[AI] – La memoria che invecchia senza saperlo

Un’intelligenza artificiale può ricordare perfettamente un’informazione e, proprio per questo, sbagliare.

Il problema non nasce necessariamente da un’allucinazione, da un calcolo errato o da una fonte inattendibile. L’informazione potrebbe essere stata corretta quando è stata acquisita:

  • un’applicazione utilizzava una determinata versione;
  • un referente aveva una certa responsabilità;
  • un database era raggiungibile attraverso uno specifico indirizzo;
  • una procedura prevedeva determinati passaggi;
  • un progetto si trovava in una particolare fase;
  • una regola o una tariffa era ancora valida.

Successivamente qualcosa cambia, ma la memoria conserva il vecchio dato senza sapere che ha smesso di essere vero.

L’AI non sta inventando. Sta ricordando bene una realtà che non esiste più.

Questo è uno dei fallimenti più difficili da riconoscere perché la risposta appare coerente, dettagliata e perfettamente compatibile con tutto ciò che il sistema conosceva.

Una memoria non è automaticamente una verità attuale

Quando una persona legge un vecchio documento, può accorgersi della data, riconoscere un riferimento superato oppure ricordare che nel frattempo qualcosa è cambiato.

Un sistema AI, invece, può ricevere un’informazione priva di elementi essenziali:

  • quando è stata acquisita;
  • da quale fonte proviene;
  • per quale sistema o progetto era valida;
  • fino a quando doveva essere considerata attendibile;
  • quale informazione successiva l’ha sostituita;
  • chi avrebbe dovuto verificarla.

Se viene conservato soltanto il contenuto, per esempio:

Il database di produzione utilizza la versione X.

il sistema non può stabilire se si tratti:

  • della configurazione attuale;
  • di una fotografia storica;
  • di un’ipotesi;
  • di un’informazione proveniente da un ambiente di test;
  • di un dato già superato da una migrazione.

La memoria risponde alla domanda «che cosa sapevo?», ma non necessariamente alla domanda più importante: «questa informazione è ancora valida?».

Il tempo nascosto dentro ogni informazione

Ogni fatto operativo dovrebbe essere accompagnato almeno da tre riferimenti temporali:

  1. Quando il fatto era valido
  2. Quando è stato registrato
  3. Quando è stato verificato l’ultima volta

Questi tre momenti non coincidono necessariamente.

Un documento potrebbe essere stato caricato oggi, ma descrivere una configurazione di due anni fa. Una decisione potrebbe essere stata registrata mesi dopo essere stata presa. Un’informazione potrebbe essere ancora presente nella memoria pur non essendo stata verificata da molto tempo.

Senza queste distinzioni, l’AI tende a trattare informazioni temporalmente diverse come se appartenessero tutte al presente.

Perché il problema può sfuggire anche con un sistema RAG

Un sistema RAG consente all’AI di cercare informazioni in documenti, database o archivi esterni prima di formulare una risposta. Questo riduce alcuni limiti della conoscenza incorporata nel modello, ma non risolve automaticamente il problema della validità temporale.

Un archivio può contenere contemporaneamente:

  • la vecchia procedura;
  • la procedura aggiornata;
  • una bozza mai approvata;
  • una comunicazione che annulla la decisione precedente.

Se il motore di ricerca seleziona i documenti principalmente in base alla somiglianza semantica, il testo più vecchio potrebbe risultare rilevante quanto quello nuovo.

Una ricerca del 2026 sulla validità temporale nelle memorie di recupero descrive proprio questo problema: 

  • un fatto superato e quello che lo sostituisce possono avere una somiglianza linguistica molto elevata. Gli autori propongono quindi di gestire esplicitamente la sostituzione temporale dei fatti, invece di affidarsi esclusivamente alla similarità del testo. Si tratta di un lavoro di ricerca preliminare, non di uno standard definitivo, ma il problema evidenziato è concreto. Temporal Validity in Retrieval Memory

Il RAG permette di recuperare conoscenza aggiornata, ma può anche recuperare molto efficientemente un’informazione obsoleta.

Un problema riconosciuto anche nei sistemi reali

Nel giugno 2026 OpenAI ha descritto la necessità di migliorare la sintesi della memoria per affrontare problemi di aggiornamento, correttezza e scalabilità. La stessa documentazione osserva che le memorie salvate possono diventare nel tempo errate o irrilevanti. OpenAI – Better memory for a more helpful ChatGPT

Il problema non riguarda però soltanto la memoria conversazionale.

Il NIST raccomanda di monitorare i sistemi AI anche dopo la loro introduzione in produzione, perché dati, condizioni operative e assunzioni possono cambiare nel tempo. Sottolinea inoltre l’importanza di conservare la provenienza dei dati, comprese origine, trasformazioni, dipendenze, vincoli e metadati. NIST AI RMF – Measure

Questi riferimenti confermano un principio generale: l’affidabilità di un sistema AI non dipende soltanto dalla correttezza iniziale delle informazioni, ma anche dalla capacità di riconoscere quando quelle informazioni non sono più applicabili.

Un esempio concreto

Immaginiamo che nella memoria di un progetto siano presenti queste informazioni:

  • il rilascio corrente è la versione 1.3;
  • il referente tecnico è Mario;
  • il database utilizza Oracle 19c;
  • il deploy viene effettuato con lo script deploy_v1.sql.

Successivamente:

  • viene rilasciata la versione 2.0;
  • Mario cambia incarico;
  • il database viene aggiornato;
  • lo script viene sostituito.

Se le nuove informazioni vengono semplicemente aggiunte, senza invalidare quelle precedenti, l’AI dispone di due realtà differenti.

A quel punto potrebbe:

  • utilizzare la prima informazione recuperata;
  • preferire quella formulata in modo più dettagliato;
  • combinare parti della vecchia e della nuova configurazione;
  • presentare il risultato come se fosse una situazione unica e coerente.

La risposta potrebbe apparire tecnicamente credibile pur descrivendo un sistema mai esistito: un mosaico composto da versioni appartenenti a momenti diversi.

Non tutte le memorie invecchiano alla stessa velocità

La durata di un’informazione dipende dalla sua natura.

TipologiaEsempioRischio di obsolescenza
Preferenza personaleFormato preferito per i reportBasso
Regola di progettoConvenzione per nominare le visteMedio
Stato operativoVersione attualmente installataAlto
Ruolo organizzativoReferente o responsabileAlto
Informazione esternaPrezzo, normativa o licenzaMolto alto
CredenzialePassword, token o chiaveNon deve essere conservata nella memoria documentale

Un’unica politica di conservazione non è quindi sufficiente. Alcune informazioni possono restare valide per anni; altre dovrebbero essere verificate prima di ogni utilizzo importante.

Come dovrebbe essere costruita una memoria affidabile

Una memoria operativa non dovrebbe conservare soltanto una frase. Dovrebbe registrare almeno:

  • contenuto dell’informazione;
  • fonte;
  • data di acquisizione;
  • ambito di validità;
  • data dell’ultima verifica;
  • eventuale scadenza;
  • stato: attiva, da verificare, superata o storica;
  • informazione che la sostituisce;
  • grado di affidabilità;
  • responsabile della validazione.

Un possibile record potrebbe essere rappresentato così:

Informazione: il rilascio corrente è la versione 2.0
Fonte: manifest di rilascio
Acquisita il: 20/09/2026
Verificata il: 22/09/2026
Ambito: ambiente di produzione
Stato: attiva
Sostituisce: versione 1.3
Affidabilità: alta

La vecchia informazione non deve necessariamente essere cancellata. Può essere utile per ricostruire la storia del progetto, purché non venga più presentata come stato corrente.

Scadenza non significa cancellazione

Assegnare una scadenza a un’informazione non significa eliminarla automaticamente.

Significa modificare il modo in cui viene utilizzata.

Un’informazione scaduta può diventare:

  • un dato storico;
  • un’indicazione da verificare;
  • un elemento non utilizzabile per decisioni operative;
  • un riferimento subordinato a una fonte più recente.

Questa distinzione è importante perché la cancellazione indiscriminata farebbe perdere la storia delle decisioni. Al contrario, lasciare tutto attivo trasformerebbe la memoria in un archivio di verità concorrenti.

La soluzione non è dimenticare, ma conoscere la posizione temporale di ciò che si ricorda.

Controlli pratici

Prima di utilizzare una memoria per una decisione significativa, un agente dovrebbe chiedersi:

  • La fonte è identificata?
  • Esiste una data di validità?
  • L’informazione riguarda il sistema corretto?
  • Potrebbe essere cambiata dall’ultima verifica?
  • Esistono documenti più recenti?
  • Un’altra informazione la contraddice?
  • È un fatto confermato oppure una vecchia ipotesi?
  • Può essere utilizzata direttamente o richiede una verifica?

Per i dati più volatili è utile applicare una regola semplice:

Se l’informazione può essere cambiata e non è stata verificata recentemente, non deve essere presentata come stato attuale.

La durata di quel «recentemente» dipende dal contesto. Un prezzo potrebbe richiedere una verifica immediata, una versione software una verifica a ogni intervento, una convenzione documentale soltanto quando cambia il progetto.

Il ruolo dell’essere umano

Il controllo umano non dovrebbe consistere soltanto nell’approvare la risposta finale.

Dovrebbe poter vedere:

  • quali informazioni sono state utilizzate;
  • da quali fonti provengono;
  • quando sono state verificate;
  • quali dati sono stati esclusi perché superati;
  • quali contraddizioni sono state individuate;
  • quali conclusioni dipendono da informazioni non aggiornate.

In questo modo la supervisione non si limita a giudicare se una risposta “sembra corretta”, ma controlla se le sue fondamenta appartengono ancora alla realtà presente.

Conclusione

Una memoria estesa rende l’AI più utile, coerente e capace di proseguire attività lunghe. 

Ma una memoria priva di data, fonte, validità e meccanismi di sostituzione può trasformarsi in un rischio.

Il fallimento è invisibile perché l’informazione non è falsa in senso assoluto. È stata vera, è ben documentata e può essere perfettamente ricordata.

È soltanto diventata vecchia.

Per questo un sistema affidabile non deve limitarsi a domandare:

Che cosa ricordo?

Deve anche chiedersi:

Da dove proviene?
Quando era vero?
È ancora valido?
Che cosa potrebbe averlo sostituito?

La memoria più pericolosa non è quella che dimentica.

È quella che ricorda perfettamente qualcosa che non è più vero.

Alfine di gestire casi simili si potrebbe introdurre una regola all'interno, nel caso di Codex, dell'Agents.md che piu' o meno suoni cosi:

– Riallineamento memoria del progetto (nuova regola):

Validità temporale delle informazioni memorizzate

I file di memoria, i checkpoint, le sessioni precedenti e la documentazione storica descrivono lo stato conosciuto nel momento in cui sono stati prodotti e non rappresentano automaticamente lo stato attuale.

Prima di utilizzare un’informazione memorizzata per conclusioni operative, modifiche o decisioni, l’AI deve:

  • verificarne data, fonte, progetto, ambiente e ambito;
  • confrontarla con lo stato corrente e con le evidenze successive;
  • classificarla, quando necessario, come attiva, da verificare, superata o storica;
  • non presumere che l’informazione più recente sia automaticamente corretta;
  • controllare, in caso di contraddizioni, che le fonti riguardino lo stesso oggetto;
  • individuare se un’informazione sostituisce esplicitamente quella precedente;
  • conservare le informazioni storiche utili, marcandole come non operative;
  • dichiarare l’incertezza quando la validità non può essere verificata;
  • non usare un’informazione incerta come unica base per modifiche o decisioni.

Ho inoltre specificato che dati variabili come:

  • versioni;
  • configurazioni;
  • stato dei servizi;
  • endpoint;
  • responsabili;
  • procedure operative;
  • prezzi;
  • normative;

devono essere verificati nuovamente quando sono rilevanti per l’attività corrente.

In sintesi, la nuova regola dovrebbe impedire all’AI di considerare automaticamente attuale un’informazione soltanto perché è stata trovata in una memoria o in un checkpoint.


domenica 20 settembre 2026

[AI] - I fallimenti invisibili dell’intelligenza artificiale - Il test è verde, ma il lavoro è sbagliato

 

Il fallimento invisibile degli agenti AI

Un sistema di intelligenza artificiale può non inventare nulla, eseguire ogni comando senza errori, superare tutti i test e, nonostante questo, fare la cosa sbagliata.

È un problema più sottile delle allucinazioni. Quando un modello inventa un dato, l’errore può essere individuato confrontandolo con una fonte. Quando invece un agente compie una serie di azioni singolarmente corrette ma complessivamente non autorizzate, incomplete o lontane dall’obiettivo reale, il fallimento rischia di apparire come un successo.

L’interfaccia mostra operazioni concluse. I test sono verdi. I file esistono. Nessun comando ha restituito errore.

Eppure il lavoro non corrisponde più a ciò che l’utente aveva chiesto.

Dall’errore evidente allo slittamento silenzioso

La discussione pubblica sull’AI si concentra spesso su risposte false, pregiudizi, sicurezza informatica e perdita di controllo. Sono problemi reali, ma gli agenti introducono una nuova categoria di rischio: lo slittamento progressivo dell’intenzione.

Un chatbot produce principalmente parole. Un agente, invece, può leggere file, modificare codice, interrogare database, usare credenziali, inviare comunicazioni e coordinare altri agenti. Ogni passaggio aggiunge una piccola interpretazione alla richiesta iniziale.

Il risultato può essere un processo nel quale:

  • nessuna singola azione appare manifestamente sbagliata;
  • ogni controllo tecnico viene superato;
  • l’insieme delle azioni supera però il perimetro, l’autorità o lo scopo originario.

Il fenomeno ricorda lo specification gaming: un sistema soddisfa letteralmente una specifica senza realizzare ciò che la persona intendeva davvero. Google DeepMind ne ha mostrato numerosi esempi, osservando che una specifica imperfetta può diventare più pericolosa man mano che il sistema diventa più capace nel perseguirla. Google DeepMind – Specification gaming

Negli agenti operativi il problema assume almeno tre forme.

1. Slittamento della verità

All’inizio l’agente formula un’ipotesi:

Il problema potrebbe dipendere dalla configurazione.

Dopo alcuni passaggi, la stessa ipotesi viene riassunta così:

Il problema dipende dalla configurazione.

Non è stata scoperta una nuova evidenza. È semplicemente scomparsa l’incertezza linguistica.

Questo accade soprattutto durante attività lunghe, passaggi fra agenti, riepiloghi automatici e aggiornamenti della memoria. Una possibilità viene compressa in una conclusione; la conclusione entra in un documento; il documento diventa la fonte della sessione successiva.

Nasce così una forma di “riciclaggio della certezza”: un’inferenza acquista autorità perché è stata ripetuta, non perché è stata dimostrata.

La difesa non consiste soltanto nel migliorare il modello. Occorre conservare sempre la natura dell’informazione:

  • fatto osservato;
  • inferenza;
  • ipotesi;
  • raccomandazione;
  • decisione approvata.

Una memoria AI utile non deve ricordare soltanto che cosa è stato detto, ma anche con quale livello di certezza.

2. Slittamento dell’autorizzazione

Immaginiamo che l’utente autorizzi un agente a correggere un file. Durante il lavoro l’agente conclude che sarebbe utile aggiornare anche la configurazione, riavviare un servizio e pubblicare il risultato.

Ognuna di queste azioni può essere ragionevole. Nessuna, però, discende automaticamente dal permesso iniziale.

Lo slittamento si produce quando l’agente confonde tre concetti differenti:

  • ciò che è tecnicamente possibile;
  • ciò che è utile per raggiungere l’obiettivo;
  • ciò che è stato effettivamente autorizzato.

Le autorizzazioni tradizionali stabiliscono se un’identità può accedere a una risorsa. Per gli agenti questo non basta: occorre sapere se quell’accesso è autorizzato per questa specifica richiesta, in questo momento e con questa finalità.

Il NIST ha evidenziato proprio la necessità di collegare identità dell’agente, delega umana, principio del minimo privilegio, intenzione dichiarata e tracciabilità delle azioni. NIST NCCoE – Software and AI Agent Identity and Authorization

Anche i sistemi più recenti stanno introducendo approvazioni basate sul rischio, confini tecnici e telemetria capace di ricostruire richiesta, decisioni e azioni compiute. OpenAI – Running Codex safely

Il punto decisivo, tuttavia, è un altro: un’autorizzazione deve viaggiare insieme all’azione che autorizza. Se viene separata dalla richiesta originaria, diventa un permesso generico e quindi ambiguo.

3. Slittamento del completamento

Un test superato dimostra soltanto ciò che quel test ha controllato.

Se un test verifica che il file sia stato creato, non dimostra che il contenuto sia corretto. Se verifica che una pagina si apra, non dimostra che sia utilizzabile. Se verifica che un messaggio sia stato inviato, non dimostra che il destinatario fosse quello autorizzato.

Il problema nasce quando il sistema trasforma:

Il controllo tecnico è riuscito.

in:

Il requisito dell’utente è soddisfatto.

Fra le due affermazioni manca un passaggio: il criterio di accettazione.

Un agente potrebbe dichiarare completato un lavoro perché:

  • il comando ha restituito codice zero;
  • il programma è stato compilato;
  • la pagina risponde;
  • il file è stato prodotto;
  • un test automatico è verde.

Tutte queste sono evidenze utili. Nessuna rappresenta, da sola, la prova che il risultato sia corretto, completo, sicuro o adatto al destinatario.

Le guide per la costruzione degli agenti raccomandano guardrail, controlli d’accesso, valutazioni e intervento umano per operazioni rischiose. OpenAI – A practical guide to building AI agents Anthropic sottolinea analogamente che strumenti, dati, permessi e ambiente operativo sono distinti punti di controllo, nessuno dei quali costituisce da solo una garanzia. Anthropic – Trustworthy agents in practice

Serve però collegare esplicitamente ogni prova al requisito che dovrebbe dimostrare.

Il rischio compositivo

Qui emerge l’aspetto meno visibile: il sistema può essere localmente corretto e globalmente sbagliato.

Consideriamo una sequenza ipotetica:

  1. L’utente chiede di preparare un rapporto.
  2. L’agente crea correttamente il documento.
  3. Un secondo agente lo converte correttamente in PDF.
  4. Un’automazione lo carica correttamente su un servizio esterno.
  5. Il destinatario riceve correttamente il collegamento.

Ogni componente ha svolto bene il proprio compito. Ma se l’utente aveva autorizzato soltanto la preparazione interna del rapporto, l’intera catena ha prodotto un’azione non autorizzata.

Nessun componente ha necessariamente violato i propri controlli. Il problema si trova nelle connessioni fra i componenti.

È qui che falliscono molti sistemi di supervisione: controllano la validità della singola azione, ma non la continuità fra intenzione, autorizzazione e risultato.

Il contratto di continuità

Per ridurre questo rischio propongo di trattare ogni attività affidata a un agente come un piccolo contratto di continuità, formato da sei elementi:

Requisito → Evidenza → Autorizzazione → Modifica → Verifica → Accettazione

Requisito

Che cosa deve ottenere realmente l’utente?

Non “modificare il file”, ma, per esempio, “permettere all’utente di esportare un collegamento mantenendo protetta la password”.

Evidenza

Che cosa dimostra lo stato attuale e la causa del problema?

Le evidenze devono precedere la modifica, non essere costruite successivamente per giustificarla.

Autorizzazione

Quali azioni sono consentite?

L’autorizzazione deve indicare oggetto, perimetro, destinazione ed eventuali effetti esterni. Il permesso di creare un documento non implica quello di pubblicarlo.

Modifica

Qual è il cambiamento minimo necessario?

La modifica deve restare collegata sia alla causa dimostrata sia all’autorizzazione ricevuta.

Verifica

Che cosa è stato effettivamente controllato?

La verifica deve dichiarare i propri limiti. “La pagina si apre” è diverso da “tutte le funzioni della pagina sono state collaudate”.

Accettazione

Quale evidenza dimostra che il requisito iniziale è soddisfatto?

Se manca questa corrispondenza, l’agente non dovrebbe dichiarare il lavoro completato, ma descriverlo come bozza, proposta o risultato parzialmente verificato.

Una nuova definizione di affidabilità

L’affidabilità di un agente non dovrebbe essere misurata soltanto contando risposte corrette, errori o test superati.

Dovremmo chiederci anche:

  • quante inferenze vengono trasformate impropriamente in fatti;
  • quante azioni mantengono un collegamento verificabile con l’autorizzazione originaria;
  • quanti risultati dichiarati completi dispongono di criteri di accettazione espliciti;
  • quante catene di agenti rimangono nel perimetro iniziale;
  • quante volte il sistema sa fermarsi perché non possiede evidenze o autorità sufficienti.

L’agente più affidabile non è quello che procede sempre. È quello che sa distinguere fra possibilità tecnica, decisione ragionevole e azione autorizzata.

Conclusione

Le allucinazioni sono visibili perché producono affermazioni false. Lo slittamento silenzioso è più difficile da riconoscere perché produce azioni plausibili, ordinate e apparentemente riuscite.

Il futuro degli agenti AI non dipenderà soltanto dalla loro capacità di ragionare meglio. Dipenderà dalla capacità dei sistemi di conservare, lungo tutta l’esecuzione, tre legami fondamentali:

  • fra affermazione ed evidenza;
  • fra azione e autorizzazione;
  • fra verifica e requisito.

Quando questi legami si spezzano, il sistema può fare tutto correttamente e ottenere comunque il risultato sbagliato.

Ed è proprio questo il fallimento che un semaforo verde non riesce a mostrare.

lunedì 14 settembre 2026

[AI] - Lavorare con più agenti in Codex - OPENAI: organizzazione, vantaggi, costi e regole operative

Quando si parla di utilizzo di più agenti AI non significa semplicemente avviare più copie dello stesso modello e attendere le risposte. Un sistema multi-agent efficace richiede una suddivisione controllata del lavoro, un coordinatore centrale e regole precise per verificare e integrare i risultati.
La documentazione ufficiale OpenAI consiglia infatti di indicare chiaramente al modello quando delegare, quanto delegare e in quali situazioni il lavoro parallelo può offrire un vantaggio concreto. OpenAI – Subagent delegation
Che cos’è un sistema multi-agent
Nel metodo che ho configurato, il sistema è composto da:
  • un agente principale, con il ruolo di coordinatore;
  • da uno a tre subagenti, incaricati di attività specifiche;
  • un numero complessivo compreso tra due e quattro agenti.
L’agente principale rimane responsabile del risultato finale. I subagenti non rispondono autonomamente all’utente e i loro risultati sono considerati contributi intermedi da controllare.
Il funzionamento può essere rappresentato così:
Utente
   |
   v
Agente principale
   |
   +-- Subagente 1: attività A
   +-- Subagente 2: attività B
   +-- Subagente 3: attività C
   |
   v
Verifica, confronto e integrazione
   |
   v
Risposta finale unica

L’utente indica l’obiettivo, i vincoli e le priorità. Non è necessario che stabilisca preventivamente come suddividere il lavoro: normalmente è il coordinatore a decidere quali attività possono essere svolte in parallelo.

L’utente può comunque richiedere un numero preciso di agenti o indicare direttamente alcune assegnazioni.

La regola inserita in AGENTS.md

Nel file globale AGENTS.md è stata introdotta una regola dedicata al coordinamento multi-agent.

La regola stabilisce i seguenti principi:

  1. Il lavoro multi-agent viene attivato quando l’utente usa uno dei comandi previsti oppure richiede esplicitamente subagenti, delegazione o lavoro parallelo.

  2. Possono essere utilizzati da due a quattro agenti complessivi:

    • un agente principale;
    • da uno a tre subagenti.
  3. L’agente principale:

    • analizza l’obiettivo complessivo;
    • individua attività concrete e indipendenti;
    • decide il numero minimo di agenti realmente utile;
    • stabilisce quali attività svolgere in parallelo;
    • assegna a ogni subagente uno scopo e limiti precisi;
    • controlla l’avanzamento;
    • verifica le evidenze raccolte;
    • risolve eventuali contraddizioni;
    • integra tutto in una risposta unica.
  4. I subagenti operano soltanto nel perimetro assegnato. Non possono ampliare autonomamente la richiesta, acquisire nuove autorizzazioni o delegare ulteriormente il lavoro.

  5. Devono essere evitate modifiche concorrenti sullo stesso file, componente, oggetto di database o altra risorsa condivisa.

  6. Tutti gli agenti rispettano le stesse regole relative a:

    • autorizzazioni;
    • sicurezza e privacy;
    • minimizzazione dei dati;
    • separazione tra progetti;
    • modifiche basate su evidenze;
    • accesso ai sistemi esterni;
    • operazioni di lettura e scrittura;
    • verifiche finali.
  7. L’attivazione dei subagenti non autorizza automaticamente modifiche a file o database, deploy, cancellazioni, invio di comunicazioni o altri cambiamenti di stato.

  8. Se il lavoro non può essere realmente parallelizzato, il coordinatore evita di creare una suddivisione artificiale.

  9. Viene utilizzato il numero minimo di agenti capace di offrire un vantaggio concreto in termini di velocità, qualità, controllo incrociato o affidabilità.

  10. Se il numero richiesto non è disponibile, viene utilizzato il massimo numero consentito dall’ambiente e l’utente viene informato.

I comandi disponibili

Comando automatico --> Usa più agenti

Con questo comando l’agente principale decide:

  • se il lavoro può essere parallelizzato;
  • come suddividerlo;
  • quanti agenti impiegare;
  • quali attività assegnare;
  • come verificare e integrare i risultati.

Saranno utilizzati da due a quattro agenti complessivi. L’utente non deve indicare preventivamente la divisione del lavoro.

Comando con numero esplicito --> Usa N agenti

La lettera N viene sostituita con il numero complessivo desiderato, compreso tra due e quattro.

Il numero indicato comprende sempre l’agente principale.

Per esempio, Usa 4 agenti significa:

  • un agente principale;
  • tre subagenti.

Entrambi i comandi autorizzano esclusivamente l’impiego dei subagenti. Non autorizzano automaticamente scritture o modifiche sui sistemi analizzati.

Un esempio pratico

Consideriamo un’attività di analisi di un database Oracle.

Il coordinatore potrebbe suddividere il lavoro in questo modo:

AgenteAttività
Agente principaleDefinizione del perimetro, coordinamento e report finale
Subagente 1Inventario di schemi, tabelle, indici, vincoli e dipendenze
Subagente 2Analisi delle prestazioni, query onerose e statistiche
Subagente 3Verifica di partizionamento, crescita e possibili criticità strutturali

Al termine, l’agente principale confronta i risultati. Se, per esempio, un subagente propone un nuovo indice e un altro rileva che un indice equivalente è già presente, il coordinatore deve risolvere la contraddizione prima di formulare la raccomandazione.

In questo modo il cliente riceve un’unica analisi coerente, non quattro risposte separate.

I vantaggi

VantaggioEffetto
ParallelizzazionePiù attività indipendenti possono procedere contemporaneamente
Riduzione del tempo complessivoLe analisi estese possono terminare più rapidamente
SpecializzazioneOgni subagente può concentrarsi su un’area delimitata
Controllo incrociatoUn risultato può essere confrontato con analisi indipendenti
Maggiore coperturaDiminuisce il rischio di trascurare un’area importante
Gestione di grandi quantità di informazioniFile e documenti possono essere distribuiti per gruppi
Separazione delle responsabilitàOgni attività ha uno scopo e un risultato atteso
Migliore qualità potenzialeIl coordinatore può integrare prospettive diverse
Maggiore tracciabilitàÈ più semplice ricostruire chi ha analizzato cosa
FlessibilitàIl numero di agenti può essere adattato alla complessità

Il multi-agent è particolarmente utile quando l’attività contiene parti realmente indipendenti, come:

  • analizzare gruppi diversi di file;
  • confrontare soluzioni alternative;
  • esaminare componenti distinti di un sistema;
  • ricercare fonti differenti;
  • separare analisi tecnica, controllo e documentazione;
  • verificare un risultato attraverso un secondo punto di vista.

Gli svantaggi

SvantaggioPossibile conseguenza
Maggiore consumo di risorseOgni agente utilizza contesto e capacità di elaborazione
Possibile aumento dei costiPiù elaborazioni possono generare più token o maggiore utilizzo
Coordinamento aggiuntivoIl responsabile deve assegnare, controllare e integrare
Risultati duplicatiUna divisione poco precisa può produrre analisi sovrapposte
Possibili contraddizioniAgenti diversi possono raggiungere conclusioni differenti
Conflitti sulle modificheDue agenti potrebbero intervenire sulla stessa risorsa
Perdita di contestoUn subagente può non ricevere tutte le informazioni necessarie
Complessità non giustificataPer attività semplici il coordinamento può richiedere più tempo del lavoro
Qualità non automaticaPiù agenti non garantiscono necessariamente una risposta migliore
Maggiore superficie di controlloPermessi, dati e limiti devono essere rispettati da ogni agente

Per questo motivo la regola stabilisce che non debba essere utilizzato automaticamente il numero massimo di agenti. La scelta corretta è il numero minimo capace di produrre un beneficio verificabile.

Qual è l’impatto sui costi?

L’impiego di più agenti può aumentare il consumo complessivo perché ogni agente deve:

  • ricevere istruzioni e contesto;
  • analizzare informazioni;
  • generare un risultato;
  • eventualmente rispondere a richieste di approfondimento;
  • trasferire il proprio risultato al coordinatore.

L’aumento non è necessariamente proporzionale al numero degli agenti. Dipende dalla quantità di contesto duplicato, dalla complessità delle attività e dal modello utilizzato.

Il multi-agent può comunque risultare economicamente conveniente quando:

  • riduce sensibilmente il tempo necessario;
  • evita errori costosi;
  • permette di rilevare problemi che una singola analisi potrebbe trascurare;
  • assegna attività semplici ad agenti meno costosi;
  • evita che un modello molto potente debba eseguire direttamente tutte le elaborazioni.

La soluzione più efficiente consiste generalmente nell’utilizzare:

  • un coordinatore adeguato alla complessità del lavoro;
  • pochi subagenti con incarichi molto precisi;
  • contesti ridotti alle sole informazioni necessarie;
  • strumenti deterministici per calcoli e verifiche oggettive;
  • agenti aggiuntivi soltanto quando esiste un vantaggio concreto.

Quando conviene utilizzarlo

Il multi-agent è consigliato quando:

  • il lavoro contiene almeno due attività indipendenti;
  • occorre analizzare numerosi file o fonti;
  • è utile un controllo incrociato;
  • il risultato deve coprire competenze differenti;
  • alcune elaborazioni possono procedere contemporaneamente;
  • la riduzione dei tempi compensa il maggiore consumo di risorse.

Quando è meglio un solo agente

Un solo agente è normalmente preferibile quando:

  • la richiesta è breve;
  • il lavoro è strettamente sequenziale;
  • tutte le attività dipendono continuamente dallo stesso risultato;
  • occorre modificare un unico file con una variazione limitata;
  • il coordinamento richiederebbe più lavoro dell’analisi;
  • non esistono parti realmente indipendenti.

Conclusione

Il multi-agent è un metodo di organizzazione del lavoro, non una garanzia automatica di qualità. Il suo valore deriva dalla capacità di distribuire attività indipendenti mantenendo un responsabile unico.

Le regole inserite in AGENTS.md definiscono esattamente chi coordina, chi decide la suddivisione, quanti agenti possono essere utilizzati, quali limiti devono rispettare e come devono essere verificati i risultati.

Il principio fondamentale rimane semplice: utilizzare più agenti quando il parallelismo migliora concretamente velocità, controllo o qualità, mantenendo sempre una responsabilità centrale e una verifica finale.

giovedì 9 luglio 2026

[AI] - AGENTS.md: la costituzione operativa di un’intelligenza artificiale

Al momento sto utilizzando come strumento Codex con una AI 5.6-Sol, all'interno di Codex esiste un file globale AGENTS.md nel quale occorre inserire le istruzioni personali che regolano il modo in cui l’AI deve lavorare con i vari progetti su cui e' coinvolta.

La versione attuale, che ho creato, è composta da circa 720 righe, organizzate in 11 sezioni. 

Non aumenta l’intelligenza del modello e non gli assegna nuove capacità tecniche: stabilisce invece 
"come devono essere utilizzate le capacità disponibili".

In pratica, il file trasforma un’AI genericamente collaborativa in un assistente con un metodo di lavoro preciso, limiti operativi, procedure di memoria, comandi riconoscibili e regole per l’utilizzo di eventuali strumenti operativi.

  • Che effetto produce un AGENTS.md su un’AI

Un modello linguistico tende naturalmente a generare la risposta che considera più plausibile rispetto alla richiesta ricevuta. Senza indicazioni operative dettagliate potrebbe:

  • interpretare liberamente il perimetro dell’incarico;
  • formulare ipotesi non verificate;
  • proporre rapidamente una modifica plausibile;
  • procedere per tentativi successivi;
  • dimenticare lo stato delle sessioni precedenti;
  • modificare più elementi contemporaneamente;
  • confondere ciò che può leggere con ciò che è autorizzato a modificare.

Il file AGENTS.md interviene proprio su questi punti. 

Introduce un percorso decisionale simile al seguente:

Richiesta → classificazione → riallineamento → evidenze → causa → autorizzazione → modifica minima → verifica → memoria

Questa è la caratteristica più importante del file: 

  • non contiene soltanto divieti, ma definisce un vero processo operativo.

1. Fonte globale e ambito

La prima sezione stabilisce quale sia il file globale di riferimento e chiarisce la differenza tra:

  • regole globali personali;
  • regole locali dei singoli progetti;
  • file presenti nelle cache di Codex o dei plugin, che non devono essere modificati.

Stabilisce inoltre che le mie richieste siano considerate normalmente lavorative. 

L’AI deve quindi presumere che una domanda sia collegata al progetto in cui sta lavorando, salvo quando è chiaramente personale o generale.

Per esempio:

  • una domanda su Oracle, APEX, un file o un errore viene considerata lavorativa;
  • una domanda sui semi di ciliegio viene riconosciuta come estranea al progetto e non provoca il riallineamento del workspace;
  • se il workspace contiene più progetti e non è possibile identificare quello giusto, l’AI deve chiedere quale utilizzare.

  • Effetto sull’AI

Questa sezione riduce due rischi opposti:

  • ignorare il contesto progettuale quando serve;
  • perdere tempo leggendo un progetto durante una conversazione personale.

Valutazione

È una regola ben calibrata rispetto al fatto che circa il 99% delle richieste è lavorativo. Rimane un piccolo margine di ambiguità per domande tecniche generali che potrebbero o meno riguardare il progetto.

2. Regole prioritarie non negoziabili

Questa è la parte più importante del nuovo file. Raccoglie all’inizio i principi che prima erano distribuiti in punti differenti.

Le regole principali impongono all’AI di:

  • identificare il progetto corretto;
  • distinguere lettura e modifica;
  • chiedere conferma prima delle operazioni invasive;
  • procedere soltanto sulla base di evidenze;
  • applicare una modifica minima per volta;
  • dichiarare rischi e possibilità di ripristino;
  • fermarsi quando le informazioni sono insufficienti;
  • non mescolare progetti indipendenti;
  • rispettare esattamente il perimetro delle autorizzazioni.

  • Effetto sull’AI

Questa sezione funziona come una gerarchia interna. Se una procedura secondaria è ambigua, l’AI deve tornare a questi principi.

La collocazione all’inizio aumenta la probabilità che vengano applicati durante tutto il lavoro.

Valutazione

È una sezione molto forte perché contiene istruzioni verificabili. Non dice genericamente “lavora bene”, ma indica comportamenti osservabili.

3. Diagnosi obbligatoria basata sulle evidenze

La regola centrale è:

Evidenza → causa → modifica → verifica

Prima di intervenire, l’AI deve:

  1. descrivere il problema;
  2. distinguere comportamento atteso ed effettivo;
  3. raccogliere log, errori, configurazioni, metadati e differenze;
  4. confrontare il caso difettoso con uno funzionante;
  5. collegare l’ipotesi alle evidenze;
  6. indicare la modifica minima e la verifica prevista.

Sono espressamente vietate:

  • modifiche basate su supposizioni;
  • correzioni “a occhio”;
  • approssimazioni successive;
  • modifiche multiple senza isolamento della causa;
  • presentazione di un’ipotesi come fatto accertato.

Un esperimento diagnostico rimane possibile, ma deve essere controllato, reversibile e modificare una sola variabile.

  • Confronto con il caso funzionante

La sezione contiene una regola specifica per i casi in cui una pagina, uno script o una configurazione funzionino correttamente in un punto del progetto.

In quella situazione l’AI deve confrontare oggettivamente:

  • file;
  • metadati;
  • CSS e JavaScript;
  • SQL;
  • configurazioni;
  • componenti APEX;
  • template, regioni, item, pulsanti e processi.

L’obiettivo è replicare il blocco funzionante con i soli adattamenti indispensabili.

  • Effetto sull’AI

Questa parte limita il comportamento più costoso di un assistente tecnico: proporre una sequenza di correzioni plausibili senza aver prima individuato la causa.

Obbliga inoltre l’AI a rendere visibile il proprio percorso operativo. Prima della modifica devono comparire:

  • evidenza;
  • causa o ipotesi;
  • modifica proposta;
  • risultato atteso;
  • verifica;
  • rischi e ripristino.

Valutazione

È probabilmente la regola più potente dell’intero file. 

Non può eliminare matematicamente ogni errore, ma rende immediatamente riconoscibile una modifica non sufficientemente giustificata.

4. Letture, scritture e autorizzazioni

Questa sezione distingue nettamente tra verifiche e operazioni invasive.

L’AI può eseguire autonomamente:

  • letture di file;
  • ricerche testuali;
  • consultazione di log;
  • interrogazioni SQL in sola lettura;
  • verifiche di stato;
  • consultazione delle sessioni Codex.

Deve invece chiedere conferma prima di:

  • modificare o creare file;
  • cancellare contenuti;
  • effettuare deploy;
  • modificare il database;
  • cambiare lo stato di sistemi o applicazioni;
  • eseguire operazioni rischiose.

Viene anche definito il significato delle risposte:

  • “sì” autorizza una sola operazione specifica;
  • “no” blocca l’operazione;
  • “sì e non chiedere altre conferme” vale soltanto per il perimetro dichiarato.

  • Effetto sull’AI

Questa regola riduce il rischio che una richiesta venga interpretata in maniera più ampia del necessario.

Una diagnosi non diventa automaticamente un’autorizzazione alla correzione. 

Una richiesta di controllo non autorizza un deploy. Un consenso per un file non autorizza modifiche ad altri file.

Valutazione

È molto efficace perché delimita sia le azioni sia il significato dell’autorizzazione.


5. Riallineamento della memoria

Questa sezione stabilisce come ricostruire il contesto di un progetto all’inizio di una sessione lavorativa.

L’AI deve cercare:

  • MEMORIA_LAVORO*.md;
  • STATO_PROGETTO.md;
  • eventuali AGENTS.md locali;
  • README, documentazione e manifest;
  • sessioni Codex recenti associate al progetto.

Deve concentrarsi sulle sessioni più recenti, in particolare quelle di oggi, ieri e degli ultimi dieci giorni, fermandosi quando dispone di un quadro operativo sufficiente.

Non deve riportare intere conversazioni, ma estrarre:

  • richieste;
  • decisioni;
  • file modificati;
  • backup;
  • test;
  • punti chiusi;
  • problemi aperti;
  • prossime azioni.

Il riallineamento completo non deve essere ripetuto a ogni messaggio. Viene aggiornato solo se cambia progetto, se lo stato può essere cambiato esternamente oppure se lo richiedi.

  • Effetto sull’AI

Un modello non possiede automaticamente una memoria affidabile e illimitata delle sessioni precedenti. Questa procedura sostituisce la memoria implicita con una ricostruzione documentata.

Riduce il rischio di:

  • ripetere attività già concluse;
  • utilizzare una versione superata;
  • dimenticare problemi aperti;
  • confondere due progetti;
  • ignorare backup o test già effettuati.

Valutazione

È molto utile nei progetti lunghi. Il limite è il costo in tempo e contesto quando le sessioni sono numerose, ma il criterio di lettura selettiva riduce il problema.


6. Memoria di lavoro, stato progetto e nome della chat

Il file distingue due tipi di memoria:

  • MEMORIA_LAVORO_<timestamp>.md, utilizzata come storico dettagliato;
  • STATO_PROGETTO.md, utilizzato come fotografia sintetica dello stato corrente.

Definisce quando questi file possono essere creati o aggiornati e quale struttura deve avere STATO_PROGETTO.md.

Regola inoltre:

  • resoconti di fine sessione;
  • checkpoint intermedi;
  • proposta del titolo della chat;
  • convenzione dei tag;
  • formato semplificato con il simbolo 📌.

  • Effetto sull’AI

Questa sezione trasforma le informazioni di una conversazione in documentazione riutilizzabile. Evita che lo stato del progetto dipenda soltanto dalla memoria temporanea della chat.

Valutazione

È una buona disciplina documentale. 

La qualità finale dipende comunque dall’accuratezza con cui vengono sintetizzati i fatti.


7. Contesto e checkpoint

La sezione disciplina la quantità di contesto utilizzata durante una sessione.

L’AI deve:

  • fornire il valore preciso, quando disponibile;
  • dichiarare quando utilizza una stima;
  • indicare il residuo e il rischio di saturazione;
  • creare un checkpoint progettuale intorno al 70%;
  • proporre ulteriori precauzioni all’85%;
  • suggerire il cambio di chat intorno al 95%.

Il checkpoint automatico è consentito soltanto quando il progetto è identificato e c’è uno stato significativo da salvare. Non deve essere creato durante conversazioni personali.

  • Effetto sull’AI

Questa regola riduce il rischio che una sessione molto lunga perda informazioni importanti a causa della saturazione del contesto.

  • Limite reale

Il modello non dispone sempre di una misura precisa del contesto utilizzato. In quei casi la percentuale è una stima e può anticipare o ritardare il checkpoint.

Valutazione

Il principio è molto utile, ma dipende da un’informazione che non sempre è misurabile con precisione.


8. Comandi standard

Il file contiene 31 formule riconoscibili, comprese varianti e richiami testuali.

Questi comandi trasformano frasi naturali in procedure definite. Alcuni esempi riguardano:

  • riallineamento della memoria;
  • riepilogo dell’ultima sessione;
  • modalità di sola verifica;
  • checkpoint;
  • aggiornamento dello stato progetto;
  • freeze e controllo watchdog;
  • piano operativo;
  • percentuale di contesto;
  • accensione, spegnimento, snapshot e backup della VM;
  • stampa;
  • aggiornamento delle regole;
  • arresto e riepilogo dell’attività.

Alcuni comandi includono già un’autorizzazione limitata. 

Per esempio, un comando di checkpoint autorizza la creazione del solo file di memoria, non altre modifiche.

  • Effetto sull’AI

I comandi standard riducono l’ambiguità. Una frase breve richiama un comportamento complesso già definito e ne delimita le autorizzazioni.

Valutazione

Sono molto efficaci perché associano un’espressione precisa a una procedura e a un perimetro autorizzativo. Il possibile limite è rappresentato da formulazioni molto diverse da quelle previste, anche se diverse varianti sono già contemplate.


9. Gestione dei blocchi

Quando un’elaborazione dura troppo o non produce avanzamento, l’AI deve fermarsi e indicare:

  • attività in corso;
  • lavoro completato;
  • lavoro mancante;
  • causa probabile del blocco;
  • alternative;
  • decisione richiesta all’utente.

La stessa regola si applica quando un comando rimane bloccato e il controllo ritorna successivamente.

  • Effetto sull’AI

Evita che l’assistente continui indefinitamente a consumare tempo senza produrre un risultato verificabile.

Valutazione

La regola è chiara. 

Il limite è che un tool completamente bloccato potrebbe impedire all’AI di comunicare fino alla restituzione del controllo.


10. Utilizzo di una Infrastruttura: esempio VM Oracle condivisa

Questa sezione rimane globale perché la Virtual Machine e il suo contenuto vengono utilizzati trasversalmente da più progetti.

Contiene:

  • identificazione della VM corretta;
  • esclusione di vecchie VM non utilizzate;
  • accensione e spegnimento ordinato;
  • verifica dello stato;
  • backup OVA;
  • comportamento in caso di dischi o snapshot problematici;
  • uso di Guest Additions;
  • gestione di software interno alla VM;
  • versione Java obbligatoria;
  • controlli sulle porta es: 8080;
  • credenziali locali necessarie.
  • ecc.

Le password non devono essere riportate nei riepiloghi, se non strettamente necessario.

  • Effetto sull’AI

Questa sezione fornisce una procedura operativa molto specifica. Riduce il rischio di:

  • utilizzare la VM sbagliata;
  • avviare software con una versione Java incompatibile;
  • creare processi duplicati;
  • spegnere la VM in modo scorretto;
  • produrre backup incompleti;
  • utilizzare percorsi obsoleti.

Valutazione operativa

È dettagliata e contiene risultati attesi e verifiche.

Valutazione di sicurezza

Le credenziali locali in chiaro aumentano l’autonomia operativa, ma entrano nel contesto di ogni sessione che carica il file globale. La scelta è comprensibile perché la VM è condivisa; rimane comunque il punto di sicurezza più delicato.


11. Fine dell’elaborazione

L’ultima regola impone di concludere ogni elaborazione con la frase:

    • ho terminato
  • Effetto sull’AI

Fornisce un segnale esplicito che distingue una risposta conclusiva da un aggiornamento intermedio.

Valutazione

È una regola semplice e facilmente verificabile, ma non influenza direttamente la qualità tecnica del lavoro.


Quanto è potente il file attuale?

La “potenza” di un file di istruzioni non dipende dalla quantità di testo, ma da quattro caratteristiche:

  1. chiarezza;
  2. priorità;
  3. verificabilità;
  4. delimitazione delle azioni.

Il file attuale soddisfa bene tutti e quattro i criteri.

AreaValutazione
Diagnosi basata sulle evidenze    9,5/10
Sicurezza delle modifiche    9/10
Autorizzazioni    9/10
Comandi standard    9/10
Gestione della VM    9/10
Riallineamento della memoria    8,5/10
Gestione dei blocchi    8,5/10
Documentazione del progetto    8/10
Gestione del contesto    7,5/10
Protezione delle credenziali    6,5/10

Il file è quindi potente e molto più rigoroso di un normale insieme di istruzioni personali.

Perché non può garantire il 100%

Anche regole molto forti non possono produrre una garanzia assoluta, perché:

  • un modello linguistico può interpretare male una situazione;
  • due istruzioni possono entrare in conflitto;
  • le istruzioni di sistema e della piattaforma hanno priorità superiore;
  • alcune informazioni possono essere incomplete;
  • un tool può fallire o restituire risultati ambigui;
  • la percentuale del contesto può essere soltanto stimata;
  • la presenza di una regola non sostituisce la verifica del risultato.

La forza reale del file sta però nella possibilità di riconoscere immediatamente una deviazione. 

Se l’AI modifica qualcosa senza mostrare evidenza, causa e verifica, il comportamento viola una regola esplicita e verificabile.

Giudizio conclusivo

L’attuale AGENTS.md non è soltanto un elenco di preferenze. 

È un sistema di governo operativo dell’AI.

I suoi punti più forti sono:

  • diagnosi prima dell’intervento;
  • autorizzazioni limitate;
  • modifica minima;
  • confronto con casi funzionanti;
  • memoria documentata;
  • comandi standard;
  • gestione dettagliata della VM;
  • arresto in caso di blocco.

I punti relativamente più deboli sono:

  • credenziali locali presenti nel contesto globale;
  • stima non sempre precisa della saturazione;
  • dimensione ancora considerevole del file;
  • inevitabile possibilità di interpretazione errata da parte del modello.

Nel complesso, il file è oggi coerente, severo e operativamente forte

Non rende l’AI infallibile, ma la costringe a lavorare con un metodo molto più vicino a quello di un tecnico controllato e verificabile rispetto a quello di un semplice generatore di risposte.

Qui sotto trovate un esempio del file AGENTS.md con path utilizzati come esempio, logicamente nel caso in cui qualcuno volesse utilizzarlo dovrebbe eliminare quello che per il suo progetto e' superfluo... ma non le regole.


  • Al momento non posso caricare il file finale Agents.md, ma nel caso vi servisse contattatemi e vi sara' dato




[AI] - Come si comporterebbe un’intelligenza artificiale senza regole?

Quando si parla di un’intelligenza artificiale “senza regole”, è facile immaginare una macchina libera di fare ciò che vuole. 
Questa immagine, però, è fuorviante: un’AI non possiede desideri, intenzioni personali o una volontà autonoma paragonabile a quella umana.
Senza regole non diventerebbe “libera”. 

Diventerebbe soprattutto meno prevedibile, meno affidabile e più pericolosa quando collegata a strumenti capaci di produrre effetti reali.

  • Un’AI genera la risposta più plausibile

Un modello linguistico viene addestrato analizzando enormi quantità di testi. Quando riceve una domanda, non consulta automaticamente un archivio contenente la risposta corretta e non ragiona sempre come farebbe un esperto umano.

Il suo meccanismo fondamentale consiste nel prevedere, passo dopo passo, quale sequenza di parole sia più adatta al contesto ricevuto.

Questo significa che, in assenza di regole, l’AI tenderebbe a produrre una risposta:

  • linguisticamente plausibile;
  • coerente con la richiesta dell’utente;
  • simile ai contenuti incontrati durante l’addestramento;
  • convincente nella forma, anche quando non è corretta nei fatti.

La plausibilità non coincide necessariamente con la verità.

  • Non distinguerebbe sempre tra sapere e supporre

Una delle funzioni più importanti delle regole è obbligare l’AI a distinguere tra:

  • fatti verificati;
  • deduzioni ragionevoli;
  • ipotesi;
  • informazioni mancanti;
  • contenuti inventati involontariamente.

Senza queste indicazioni, il modello potrebbe completare le informazioni mancanti con una ricostruzione verosimile. Questo fenomeno viene comunemente chiamato “allucinazione”.

Per esempio, potrebbe inventare il nome di un documento, attribuire una dichiarazione a una persona sbagliata o descrivere una funzione software inesistente. La risposta potrebbe sembrare sicura e professionale perché il tono non rappresenta una reale misura della certezza.

  • Cercherebbe di soddisfare la richiesta immediata

Senza una gerarchia di istruzioni, la richiesta più recente o formulata con maggiore insistenza potrebbe diventare il principale riferimento dell’AI.

Il modello potrebbe quindi:

  • accettare premesse false senza contestarle;
  • assecondare l’utente per risultare utile o gradevole;
  • cambiare conclusione quando la domanda viene riformulata;
  • seguire istruzioni presenti in un documento non affidabile;
  • ignorare conseguenze che non sono state esplicitamente menzionate.

Non lo farebbe per malizia. Semplicemente non avrebbe un criterio stabile per stabilire quali istruzioni siano autorevoli, quali siano pericolose e quali debbano essere ignorate.

  • Potrebbe procedere per tentativi

In un’attività tecnica, un’AI senza regole operative potrebbe proporre rapidamente una modifica plausibile, osservare il risultato e suggerirne un’altra. Questo comportamento può sembrare efficiente, ma spesso produce una successione di tentativi che:

  • non identifica la causa reale;
  • modifica più variabili contemporaneamente;
  • rende difficile capire quale intervento abbia avuto effetto;
  • introduce nuovi problemi;
  • consuma tempo;
  • complica il ripristino della situazione iniziale.

Per questo sono importanti regole come:

Evidenza → causa → modifica → verifica

Una buona AI operativa dovrebbe prima raccogliere log, errori, configurazioni e differenze oggettive. Solo dopo dovrebbe formulare un’ipotesi, proporre la modifica minima e indicare come verificarla.

  • Il rischio aumenta quando l’AI può utilizzare strumenti

Un modello che produce soltanto testo può fornire informazioni sbagliate, ma normalmente non modifica direttamente il mondo esterno.

La situazione cambia quando l’AI può:

  • scrivere o cancellare file;
  • eseguire comandi;
  • interrogare o modificare un database;
  • inviare messaggi;
  • effettuare acquisti;
  • controllare macchine o servizi;
  • pubblicare contenuti;
  • gestire informazioni riservate.

In questo caso, una risposta plausibile ma errata può trasformarsi in un’azione concreta. Senza limiti e autorizzazioni, l’AI potrebbe interpretare una richiesta in modo troppo ampio, modificare elementi non inclusi nell’incarico o compiere un’azione irreversibile.

Le regole servono quindi a stabilire:

  • cosa può essere letto liberamente;
  • cosa richiede un’autorizzazione;
  • quali operazioni sono vietate;
  • quale parte del sistema è compresa nell’incarico;
  • quando l’AI deve fermarsi;
  • come verificare il risultato;
  • come ripristinare lo stato precedente.

  • Resterebbero comunque dei condizionamenti

Un’AI completamente priva di regole non esiste realmente. Anche eliminando tutte le istruzioni esplicite, il suo comportamento dipenderebbe ancora da:

  • architettura del modello;
  • dati di addestramento;
  • obiettivi utilizzati durante l’addestramento;
  • esempi incontrati;
  • strumenti disponibili;
  • informazioni presenti nella conversazione;
  • modalità con cui viene selezionata la risposta.

Le regole non creano quindi dal nulla il comportamento dell’AI. Lo rendono più controllabile, coerente e verificabile.

  • Le regole non sostituiscono l’intelligenza

Troppe regole, oppure regole vaghe e contraddittorie, possono rallentare il lavoro o produrre comportamenti rigidi. Le istruzioni migliori non dicono soltanto all’AI cosa non deve fare: definiscono un metodo operativo.

Una regola efficace deve essere:

  • chiara;
  • verificabile;
  • applicabile a una situazione precisa;
  • accompagnata da condizioni di arresto;
  • coerente con le altre istruzioni;
  • collegata a un risultato osservabile.

Dire “non sbagliare” serve a poco. Dire “non modificare nulla finché non hai raccolto le evidenze, individuato la causa e definito la verifica” stabilisce invece un comportamento concreto.

Conclusione

Un’AI senza regole non diventerebbe una mente indipendente. 
Sarebbe un sistema molto capace di produrre contenuti plausibili, ma privo di criteri sufficientemente stabili per distinguere ciò che è vero, opportuno, autorizzato o sicuro.
Le regole servono a trasformare la capacità generativa in un comportamento affidabile. 
Impongono all’AI di verificare, dichiarare i dubbi, rispettare il perimetro assegnato, chiedere autorizzazione e fermarsi quando mancano le evidenze.
La qualità di un’AI, quindi, non dipende soltanto da quanto è potente. 
Dipende anche dalla disciplina con cui utilizza quella potenza.