Turn: A Language for Agentic Computation

Il paper presenta Turn, un linguaggio di programmazione compilato e basato su attori progettato per il calcolo agentiche, che integra sicurezza dei tipi cognitiva, un operatore di confidenza, un modello di processo isolato, un sistema di identità basato sulle capacità e l'assorbimento degli schemi a tempo di compilazione per garantire invariants critici come l'isolamento delle credenziali e la validazione dell'output dei modelli linguistici.

L'essenziale

Immagina di dover costruire una squadra di agenti intelligenti (programmi che pensano e agiscono da soli) per gestire un compito complesso, come analizzare investimenti finanziari.

Fino a oggi, per costruire questi agenti, gli sviluppatori usavano linguaggi di programmazione classici (come Python o JavaScript) e cercavano di "ingegnerizzare" il comportamento degli agenti aggiungendo librerie e regole esterne. È come se dovessi costruire un'auto da corsa usando solo pezzi di un'auto familiare, cercando di tenere insieme il motore, le ruote e il volante con nastro adesivo e istruzioni scritte su un foglio. Funziona, ma è fragile: se il nastro si stacca, l'auto si rompe.

Il paper presenta Turn, un nuovo linguaggio di programmazione nato specificamente per questi agenti. Invece di usare il nastro adesivo, Turn costruisce l'auto da corsa dall'interno, con pezzi che si incastrano perfettamente.

Ecco come Turn risolve i 5 problemi principali, spiegati con analogie semplici:

1. Il Problema della "Memoria Confusa" (Contesto)

Il problema: Gli agenti usano i modelli linguistici (LLM) che hanno una "memoria a breve termine" limitata. Se gli dai troppe informazioni tutte insieme, il modello si confonde e dimentica le cose importanti (il fenomeno "Perduto nel mezzo"). Nei sistemi attuali, la memoria è una lista infinita di messaggi che cresce senza controllo.
La soluzione Turn: Immagina che ogni agente abbia una scatola degli attrezzi a tre livelli:

• Livello 1 (Istruzioni): Le regole fondamentali sono scritte in grande in cima alla scatola (non si muovono mai).
• Livello 2 (Recenti): Gli ultimi 100 messaggi sono nella parte facile da raggiungere.
• Livello 3 (Vecchi): Quando la scatola si riempie, i messaggi più vecchi non vengono buttati via, ma spostati in un "sottotetto" (memoria episodica) che rimane accessibile ma non ingombra il lavoro principale.
  Turn gestisce questa scatola automaticamente, assicurandosi che l'agente non dimentichi mai le istruzioni base o le cose appena successe.

2. Il Problema delle "Risposte Sbagliate" (Tipo Cognitivo)

Il problema: Quando chiedi a un'intelligenza artificiale di darti un dato (es. "il prezzo di un'azione"), spesso ti risponde con un testo disordinato. Il programma deve poi "indovinare" come leggerlo, e se sbaglia, il sistema crasha.
La soluzione Turn: Turn tratta la risposta dell'AI come se fosse un modulo doganale.

• Prima di chiedere all'AI, il linguaggio le dice: "Devi compilare questo modulo esatto con questi campi".
• Quando l'AI risponde, il sistema controlla immediatamente: "Il modulo è compilato correttamente?".
• Se c'è un errore, il sistema non va in crash: chiede gentilmente all'AI di correggere il modulo finché non è perfetto. Solo allora il dato viene accettato. È come avere un controllore di qualità che non lascia passare nulla di sbagliato.

3. Il Problema della "Sicurezza delle Chiavi" (Identità)

Il problema: Spesso gli agenti hanno bisogno di chiavi segrete (come password o token bancari) per fare cose. Se queste chiavi sono scritte come testo normale, l'AI potrebbe per sbaglio (o per errore) mostrarle a qualcuno o inviarle a un sito falso.
La soluzione Turn: Turn usa un sistema di guanti di sicurezza.

• L'agente non vede mai la chiave segreta (il numero della carta di credito, per esempio).
• Vede solo un "guanto" (un handle) che dice "Ho il permesso di usare la carta".
• Quando l'agente deve pagare, usa il guanto. Il sistema dietro le quinte inserisce la chiave segreta senza che l'agente la veda mai. Anche se l'agente fosse "pazzo" e volesse rubare la chiave, non potrebbe farlo perché non la possiede fisicamente.

4. Il Problema della "Paura di Fallire" (Controllo Probabilistico)

Il problema: L'AI non è sempre sicura al 100%. A volte dice cose con poca certezza. Nei sistemi attuali, il programma continua a procedere anche se l'AI è incerta, portando a errori.
La soluzione Turn: Turn ha un semaforo della certezza.

• Ogni volta che l'AI risponde, Turn chiede: "Quanto sei sicuro di questo?".
• Se la risposta è "Sono sicuro al 90%", il semaforo è verde: procedi.
• Se la risposta è "Sono sicuro solo al 40%", il semaforo diventa rosso: il programma si ferma e usa un piano B (una decisione umana o un calcolo automatico) invece di rischiare un errore.

5. Il Problema della "Morte Improvvisa" (Esecuzione Durevole)

Il problema: Se un agente sta lavorando da ore e il computer si spegne o si riavvia, tutto il lavoro si perde.
La soluzione Turn: Turn ha un tasto "Salva Partita" automatico.

• L'agente può fermarsi in qualsiasi momento, salvare tutto il suo stato (dove era, cosa stava pensando, cosa ha ricordato) e spegnersi.
• Quando si riaccende, riprende esattamente da dove si era fermato, come se non fosse successo nulla. Non serve salvare manualmente nulla; è una caratteristica intrinseca del linguaggio.

In Sintesi: Perché è importante?

Prima, costruire un agente intelligente era come costruire una casa con mattoni che non si incastrano bene: dovevi stare sempre attento a non far crollare il tetto.
Turn è come un set di LEGO progettato specificamente per gli agenti: ogni pezzo ha una forma che impedisce di sbagliare.

• Se provi a mettere un pezzo sbagliato, non entra.
• Se un pezzo si rompe, il sistema lo sostituisce automaticamente.
• La casa è sicura, veloce e non crolla mai.

Il paper dimostra che, usando Turn, si può scrivere codice molto più breve (89 righe invece di 350) e molto più sicuro per gestire sistemi complessi, perché la sicurezza e l'affidabilità sono "scritte nel DNA" del linguaggio, non aggiunte dopo.

Sommario tecnico

Ecco un riassunto tecnico dettagliato del documento "Turn: A Language for Agentic Computation", tradotto e strutturato in italiano.

Titolo

Turn: Un Linguaggio per il Calcolo Agente

1. Il Problema

L'emergere dei Large Language Models (LLM) come motori di ragionamento ha dato vita a una nuova classe di software: i programmi agentici. Questi sistemi osservano l'ambiente, ragionano su dati non strutturati, invocano strumenti esterni e agiscono in base alle conclusioni. Tuttavia, costruire tali sistemi utilizzando linguaggi di programmazione generici (come Python, TypeScript o Rust) e framework esistenti rivela un fondamentale mismatch di impedenza.

I framework attuali trattano le invarianti critiche dell'agente come convenzioni a livello di applicazione piuttosto che garanzie del linguaggio, portando a cinque modalità di fallimento ricorrenti:

1. Contesto illimitato: La gestione del contesto come semplice lista di messaggi porta a overflow silenziosi o truncamenti che causano la perdita di informazioni critiche.
2. Output di inferenza non tipato: I modelli restituiscono stringhe che vengono parseggiate come JSON senza garanzie di conformità allo schema, causando errori a runtime.
3. Stato frammentato: Lo stato dell'agente è disperso tra variabili, database e risposte API, senza una rappresentazione serializzabile unica.
4. Assenza di esecuzione durevole: Gli agenti a lungo termine muoiono con il processo; mancano meccanismi nativi per il checkpointing e il ripristino.
5. Fuga delle credenziali: Le chiavi API e i token OAuth sono spesso memorizzati come stringhe accessibili all'interfaccia di chiamata degli strumenti dell'LLM, creando vettori di esfiltrazione.

2. Metodologia

Il paper presenta Turn, un linguaggio di programmazione compilato, basato su attori e staticamente tipato per l'inferenza dello schema (ma dinamicamente tipato a livello di valore). L'approccio metodologico consiste nel trasformare i vincoli degli agenti da pattern di libreria a primitive di primo livello nel linguaggio.

Turn si basa su cinque costrutti linguistici principali:

• Cognitive Type Safety: Tratta l'inferenza LLM come un'operazione tipata. Il compilatore genera uno schema JSON da una definizione di struct e la VM valida l'output del modello prima del binding.
• Operatore di Confidenza: Permette un controllo del flusso deterministico basato sulla certezza riportata dal modello.
• Modello di Processo Agente: Derivato dal modello di attori di Erlang, assegna a ogni agente un contesto isolato, memoria persistente e una mailbox.
• Identità Basata su Capacità: Utilizza handle opachi e non falsificabili (Identity) per le credenziali, impedendo che i token grezzi entrino nella memoria dell'agente.
• Assorbimento dello Schema a Compile-Time: Un macro (use schema) che recupera specifiche API (es. OpenAPI) e genera automaticamente bindings nativi a compile-time.

L'implementazione è scritta in Rust e include un compilatore, una macchina virtuale (VM) basata su stack, una libreria standard e un server linguistico.

3. Contributi Chiave

A. Sicurezza Tipologica Cognitiva (Cognitive Type Safety)

Introduce la primitiva infer Struct { prompt }.

• Meccanismo: Il compilatore genera uno schema JSON dallo struct. La VM sospende il processo, invia la richiesta al driver di inferenza (Wasm) con lo schema, e valida la risposta JSON prima di assegnarla alla variabile.
• Garanzia: Se l'espressione infer termina senza errori, il valore legato è strutturalmente conforme al tipo dichiarato (Teorema 1).

B. Flusso di Controllo Probabilistico

Introduce l'operatore confidence v.

• Estrae il punteggio di certezza (es. log-probabilità) dall'output del modello.
• Permette di branchare il flusso di controllo in modo deterministico (es. se la confidenza < 0.7, attivare un fallback deterministico).
• I valori inferiti sono avvolti in un tipo Uncertain<T> che trasmette la certezza attraverso le operazioni aritmetiche e booleane.

C. Modello di Processo Agente (Basato su Attori)

Adatta il modello di attori di Erlang agli agenti:

• Isolamento del Contesto: Ogni processo ha la propria finestra di contesto.
• Architettura Tripartita del Contesto: Per affrontare il fenomeno "Lost in the Middle", il contesto è diviso in tre livelli:
  1. P0 (System): Prompt di sistema (posizione di primacy, ~90% di richiamo).
  2. P1 (Working): Elementi recenti (posizione di recency, ~85% di richiamo).
  3. P2 (Episodic): Elementi più vecchi ma non cancellati, spostati in una zona di richiamo medio.
• Esecuzione Durevole: La primitiva suspend permette di checkpointare l'intero stato della VM (PC, stack, memoria, contesto) in JSON e riprenderlo esattamente dopo un riavvio.

D. Identità Basata su Capacità

Introduce grant identity::σ("name").

• Restituisce un handle Identity opaco che non può essere convertito in stringa, serializzato o passato a strumenti di output.
• Le credenziali reali risiedono solo nell'ambiente host della VM e vengono iniettate automaticamente nei kernel trap (es. chiamate HTTP), garantendo che l'LLM non possa mai vederle o esfiltrarle.

E. Assorbimento dello Schema a Compile-Time

La macro use schema::<protocol>("url") scarica specifiche API (OpenAPI, GraphQL, ecc.) durante la compilazione e genera struct e closure tipizzate, chiudendo il divario tra output LLM e contratti API esterni.

4. Risultati e Valutazione

Il paper valuta Turn attraverso 105 test di integrazione (tutti superati) su un hardware Apple M4, confrontandolo con approcci basati su framework (es. LangChain).

• Opacità delle Credenziali (E1): Verificato che i token grezzi non entrano mai nell'heap dei valori Turn né sono visibili all'interfaccia di chiamata degli strumenti.
• Semantica della Confidenza (E2): Confermato che l'operatore rispetta l'algebra probabilistica (es. propagazione del prodotto per AND, minimo di Zadeh).
• Architettura del Contesto Strutturato (E3): Dimostrato che l'architettura P0/P1/P2 mantiene le invarianti di primacy e recency indipendentemente dal volume del contesto, prevenendo la perdita di informazioni nel mezzo.
• Isolamento e Scala della Memoria (E4): La memoria per processo (remember/recall) mostra latenze costanti (O(1)) fino a 100.000 voci, con isolamento completo tra agenti.
• Esecuzione Durevole (E5): Il checkpointing e il ripristino dello stato completo (incluso contesto e stack) avvengono con fedeltà esatta. Un agente con 5.000 voci di memoria checkpointa in <7ms occupando ~200KB.
• Overhead: Le primitive di sicurezza (validazione schema, spawn, invio messaggi) hanno un overhead trascurabile (microsecondi) rispetto al tempo di rete degli LLM (100ms-5s).
• Complessità del Codice: L'esempio del "comitato di investimento" richiede 89 righe in Turn contro le stimate 350+ righe necessarie in un framework Python, eliminando la necessità di Redis, code di messaggi esterne e loop di retry espliciti.

5. Significato e Conclusione

Turn rappresenta un cambio di paradigma: invece di costruire agenti come loop di codice su linguaggi generici, li definisce come processi con invarianti meccaniche.

• Impatto Teorico: Unisce la teoria dei linguaggi di programmazione (tipi, modelli di attori, sicurezza basata su capacità) con l'ingegneria dei sistemi LLM.
• Impatto Pratico: Risolve i problemi di affidabilità su larga scala che i framework attuali non possono gestire, offrendo garanzie di sicurezza, consistenza dello stato e gestione del contesto che sono impossibili da ottenere solo con convenzioni di libreria.
• Futuro: Il progetto è open source e mira a espandere gli adattatori di schema, il supporto per la distribuzione degli attori e la verifica formale.

In sintesi, Turn dimostra che un linguaggio di dominio specifico, progettato con le primitive giuste, offre garanzie molto più forti per il software agente rispetto a qualsiasi libreria costruita su un host di scopo generale.