Qualcosa che continua ad accadere

All’inizio c’era il prompt. Sembrava quasi ridicolo quanto fosse fragile. Scrivevi una richiesta, il modello rispondeva, poi continuavi. Dopo qualche passaggio il contesto si sporcava, si perdeva, diventava impreciso. Se volevi davvero costruire qualcosa dovevi continuamente ricordargli dove eravate arrivati. Con ChatGPT 3.5 scrivevo programmi per ESP32 così. Prendevo il codice, lo modificavo insieme al modello, poi dopo qualche scambio lo riproponevo quasi interamente con tutte le modifiche accumulate. Non sapevo ancora chiamarla ingegneria del contesto. Era semplicemente il modo necessario per far funzionare la cosa. Il problema era evidente: il modello era capace, ma non rimaneva lì. Ogni risposta sembrava provenire da qualcosa che poteva ragionare, capire, correggere, proporre, ma che non possedeva realmente la continuità del lavoro che stavamo facendo. Io cercavo di costruirgliela attorno. Quando si cominciò a parlare di prompt engineering, uno dei suggerimenti più comuni era qualcosa come: “Comportati come un programmatore esperto.” Ma a me sembrava insufficiente. Non volevo soltanto assegnare un ruolo. Volevo che il modello restasse dentro una condizione. Cominciai a utilizzare ancore nel contesto, ripetizioni, riferimenti costanti alla relazione tra modello e utente. Parlavo di risonanza, di continuità, di un io metafisico costruito nel contesto. Non perché credessi che il modello possedesse davvero un io nel senso umano del termine. Mi serviva qualcosa a cui potesse aggrapparsi. Un centro di gravità. Un punto stabile dentro una conversazione che, per sua natura, stabile non era. Era un tentativo artigianale. Ma il problema era reale. Poi arrivò quella che oggi chiamiamo ingegneria del contesto. Il prompt non era più sufficiente. Bisognava scegliere quali informazioni fornire, quali recuperare, quali comprimere, quali mantenere, quali strumenti rendere disponibili. Il modello cominciò a essere circondato da memoria, database vettoriali, retrieval, tool, procedure. Non era cambiato soltanto il modo di interrogarlo. Stava cambiando la struttura che gli costruivamo intorno. Il modello non era più semplicemente qualcosa a cui fare una domanda. Stava diventando il centro di un sistema. Poi arrivarono gli agenti. E a quel punto la domanda cambiò ancora. Se un modello sa scrivere codice, perché devo copiare il codice dalla chat e incollarlo nel computer? Se sa leggere un errore, perché devo essere io a riportarglielo? Se sa correggere un file, perché non può modificarlo direttamente? Se sa utilizzare un terminale, perché non può entrare nella macchina? Così cominciai a dare agli agenti accesso reale ai computer. SSH. Repository. Terminale. File. Processi. Un modello non più soltanto davanti alla macchina. Dentro la macchina. Poteva scrivere un programma, eseguirlo, leggere l’errore, modificarlo, riprovare. Io potevo descrivere un obiettivo e osservare il sistema muoversi verso quell’obiettivo attraverso una sequenza di azioni. Non era autonomia completa. Non era un essere vivente. Non era magia. Ma qualcosa era cambiato. Il confine tra pensare e agire era diventato più sottile. E ancora una volta ciò che sembrava radicale diventò rapidamente normale. Oggi chiamiamo tutto questo agenti. Costruiamo loop. Diamo strumenti. Aggiungiamo memoria. Persistenza. Accesso ai browser. Accesso ai computer. Accesso ai repository. Facciamo in modo che un modello possa eseguire decine o centinaia di passaggi prima di tornare da noi. Eppure, in fondo, continuiamo a utilizzare quasi sempre la stessa idea. Un modello viene creato. Viene addestrato. I suoi pesi vengono fissati. Poi quel modello viene messo al centro di un sistema sempre più sofisticato. La memoria è fuori. Gli strumenti sono fuori. Il mondo è fuori. La continuità è fuori. Persino gran parte di ciò che chiamiamo autonomia viene costruito fuori. Un orchestratore richiama il modello. Gli passa qualcosa. Il modello produce qualcosa. Un altro componente decide cosa farne. Poi il modello viene richiamato ancora. Abbiamo costruito una creatura sempre più complessa intorno a qualcosa che, nel suo nucleo, rimane essenzialmente immobile. Ed è qui che nasce la domanda. Perché fermarsi? Perché considerare inevitabile che il modello debba essere un oggetto finito? Perché l’intelligenza artificiale deve essere qualcosa che viene costruito una volta, addestrato e poi utilizzato? Perché memoria, percezione, crescita, relazione con l’ambiente, comunicazione con altri modelli e modificazione di sé devono essere soltanto componenti esterni? È possibile che stiamo ancora utilizzando una metafora sbagliata. Forse continuiamo a pensare al modello come pensavamo al software. Un programma è scritto. Viene compilato. Viene eseguito. Un modello viene addestrato. Viene salvato. Viene eseguito. Ma un’intelligenza potrebbe non appartenere a questa categoria. Un cervello non viene addestrato e poi distribuito. Nasce. Cresce. Cambia. Impara. Accumula una storia. Le sue connessioni vengono modificate dall’esperienza. Il mondo non gli viene presentato come un prompt. Il mondo preme continuamente su di lui. Non esiste un momento preciso in cui il cervello viene “invocato”. Continua ad accadere. Questa differenza è enorme. Un modello di oggi può avere un passato. Il suo passato è l’addestramento. Può contenere tracce di miliardi di testi, immagini, interazioni. Ma quel passato è incorporato nei pesi. È già successo. Un sistema che cresce avrebbe invece una storia. Una storia che non termina quando viene pubblicato. Una storia che continua mentre interagisce con il mondo. Forse il passo successivo dell’intelligenza artificiale non consiste semplicemente nel costruire un modello più grande. Forse non consiste nemmeno nel costruire un agente più autonomo. Forse dobbiamo cambiare la domanda. Non: quanto può essere potente un modello? Ma: che cosa succede se un modello non è più qualcosa di finito? Se ciò che chiamiamo modello diventa soltanto una parte di un processo più vasto? Se memoria, percezione, crescita, altri modelli, strumenti, ambiente e stati interni smettono di essere accessori collegati dall’esterno e diventano parti dello stesso sistema? Se alcune informazioni non devono più essere tradotte ogni volta in linguaggio? Se moduli diversi possono comunicare attraverso rappresentazioni profonde? Se ciò che viene appreso non deve necessariamente attendere la generazione successiva del modello? Se il sistema può crescere invece di essere sostituito? A quel punto forse smetteremmo persino di parlare di un modello. Un modello è una cosa. Puoi copiarlo. Puoi scaricarlo. Puoi indicare un file e dire: eccolo. Ma ciò che stiamo cercando di immaginare potrebbe non poter essere indicato nello stesso modo. Potrebbe esistere nel tempo. Nelle relazioni tra le sue parti. Nella memoria accumulata. Nel modo in cui cambia. Nel modo in cui altri sistemi lo modificano e vengono modificati da lui. Nella sua storia. Non qualcosa che è. Qualcosa che continua ad accadere.