C’è una differenza sostanziale tra un’intelligenza artificiale capace di scrivere codice e un sistema di intelligenza artificiale capace di dimostrare matematicamente che quel codice rispetta determinate proprietà di sicurezza, Google DeepMind ha appena presentato un risultato che porta questa distinzione su un terreno particolarmente interessante: la verifica formale dell’implementazione crittografica di Signal, uno dei sistemi di messaggistica più importanti al mondo.

Il progetto si chiama AlphaProof Code e rappresenta un passaggio significativo nell’evoluzione degli agenti autonomi. Non si tratta di aver chiesto a un modello di leggere il codice, individuare vulnerabilità e suggerire correzioni. Gli agenti hanno lavorato alla produzione di dimostrazioni matematiche, utilizzando Lean, un sistema di verifica formale nel quale ogni prova deve superare il controllo di un kernel matematico indipendente. Il risultato è impressionante: circa 6,5 milioni di righe di dimostrazioni formalmente verificate, prodotte da agenti AI sotto la supervisione di cinque ricercatori in quattro settimane.

Per comprendere la portata del risultato bisogna ricordare quanto sia costosa la verifica formale del software. Il microkernel seL4, uno dei casi più importanti nella storia dell’ingegneria del software verificato matematicamente, ha richiesto circa vent’anni-persona di lavoro. Qui un gruppo di cinque ricercatori, utilizzando agenti AI, ha affrontato un problema di complessità considerevole in un mese. Il confronto non significa che i due progetti abbiano identico perimetro o requisiti, ma restituisce una misura del cambiamento nei costi di produzione delle prove formali.

La parte più interessante riguarda ciò che è stato effettivamente verificato. DeepMind non si è fermata al modello teorico del protocollo Signal, né a una versione semplificata del software costruita appositamente per facilitare la dimostrazione. Il lavoro riguarda libsignal, l’implementazione di riferimento del protocollo scritta in Rust, compilata con il normale compilatore in codice macchina AArch64. Le proprietà di sicurezza sono state dimostrate direttamente sull’eseguibile, avvicinando la verifica matematica al software che viene realmente eseguito.

È un passaggio importante. Nella sicurezza informatica esiste da sempre una distanza potenzialmente pericolosa tra la correttezza matematica di un protocollo e il comportamento della sua implementazione. Un algoritmo può essere teoricamente sicuro e diventare vulnerabile a causa di un errore nella gestione delle chiavi, nella memoria o nello stato delle sessioni. Dimostrare proprietà di sicurezza sul codice compilato consente di affrontare proprio questa discontinuità.

L’architettura di AlphaProof Code divide il lavoro tra esseri umani e agenti. I ricercatori definiscono le proprietà che il sistema deve rispettare e, con l’aiuto dell’intelligenza artificiale, costruiscono le specifiche formali in Lean. Una volta approvate, queste specifiche diventano il riferimento per gli agenti incaricati di produrre le dimostrazioni. Un componente di controllo verifica infine che ogni prova sia valida e corrisponda esattamente alle proprietà autorizzate.

Qui si trova un dettaglio che merita attenzione anche al di fuori della ricerca accademica. Gli agenti non sono considerati affidabili semplicemente perché producono risultati convincenti. Possono sbagliare, introdurre ipotesi improprie o persino indebolire involontariamente una dimostrazione per riuscire a completarla. Lean risolve una parte fondamentale del problema: non accetta una prova soltanto perché sembra corretta. La verifica avviene attraverso il proprio kernel, indipendentemente dal modello che l’ha generata.

DeepMind ha inoltre sottoposto il sistema a una prova particolarmente significativa. I ricercatori hanno reintrodotto due vulnerabilità storiche, già individuate e corrette nel codice di libsignal. In entrambi i casi gli agenti sono riusciti a dimostrare formalmente che le versioni modificate violavano le proprietà di sicurezza previste. Non soltanto, quindi, il sistema riesce a provare la correttezza di determinate proprietà, ma può anche produrre una dimostrazione della loro violazione quando viene introdotto un errore conosciuto.

Naturalmente, sarebbe scorretto interpretare il risultato come una certificazione assoluta dell’intera applicazione Signal. La verifica riguarda uno specifico eseguibile e un insieme definito di proprietà. Alcune primitive crittografiche e alcune routine esterne sono rappresentate attraverso contratti assunti come validi. Il lavoro presenta inoltre limitazioni nei modelli di attacco e negli scenari considerati, soprattutto per quanto riguarda alcune garanzie post-quantistiche. La distinzione è essenziale: una dimostrazione matematica garantisce ciò che è stato formalmente specificato, non tutto ciò che un sistema potrebbe essere chiamato a fare nel mondo reale.

Il valore strategico, tuttavia, rimane notevole. Per decenni la verifica formale è stata una disciplina riservata soprattutto ai sistemi critici, perché il costo umano necessario per applicarla a software industriale complesso era difficilmente sostenibile. Se gli agenti autonomi riusciranno a ridurre significativamente questo costo, il modello economico dello sviluppo software potrebbe cambiare. La sicurezza non sarebbe più soltanto una fase di controllo successiva alla produzione del codice, ma potrebbe diventare una condizione verificabile durante ogni modifica del software.

La conseguenza riguarda direttamente le imprese. Nei sistemi finanziari, nelle infrastrutture energetiche, nei dispositivi medicali e nelle piattaforme che gestiscono dati sensibili, un errore software può avere conseguenze economiche e operative enormi. Oggi molte organizzazioni investono considerevoli risorse in test, audit e penetration testing, strumenti indispensabili ma che non equivalgono a una dimostrazione matematica delle proprietà di sicurezza. L’introduzione di agenti capaci di produrre prove verificabili potrebbe modificare il rapporto tra costo dello sviluppo e costo della garanzia.

Resta però una questione che DeepMind stessa riconosce nel proprio lavoro: quando diventa relativamente economico dimostrare qualcosa, la difficoltà si sposta sulla definizione di ciò che deve essere dimostrato. Scrivere una specifica corretta richiede competenza, giudizio e comprensione del contesto. Una dimostrazione perfetta di una proprietà formulata male può produrre una falsa sensazione di sicurezza. In questo senso, l’intelligenza artificiale non elimina la responsabilità degli ingegneri; ne modifica profondamente la collocazione.

Nello stesso contesto di ricerca merita attenzione anche un lavoro di Tao Zhang e Yuhang He, di Microsoft Research Asia, intitolato LongCapHarness: Capability-Guided Auto-Harnessing for Long-Context Reasoning. La ricerca affronta un problema diverso, ma complementare: migliorare la capacità dei modelli di ragionare su contesti molto lunghi senza ricorrere al consueto ciclo di generazione di dati sintetici e successivo post-training.

Gli autori propongono un approccio chiamato LongCapHarness, nel quale il modello viene inserito in un ambiente capace di migliorare ricorsivamente le proprie procedure operative. Il sistema interviene sulle primitive di capacità, sullo stato interno del processo e sulla logica di controllo, utilizzando i risultati ottenuti durante le attività di sviluppo per correggere progressivamente il proprio funzionamento. Non viene quindi addestrato nuovamente il modello: si lavora sull’infrastruttura che ne organizza e sfrutta le capacità già disponibili.

Gli esperimenti sono stati condotti su Llama 3 8B e successivamente trasferiti a Qwen 2.5 3B. Secondo gli autori, il metodo supera diversi approcci basati sulla sintesi di dati nei benchmark HELMET e RULER, con un costo di sviluppo stimato inferiore alla metà di quello necessario per alcune delle strategie di training confrontate. È un risultato interessante perché suggerisce che una parte delle capacità ancora poco sfruttate dai modelli potrebbe emergere attraverso una migliore architettura di esecuzione, anziché richiedere necessariamente modelli più grandi o ulteriori cicli di addestramento.

I due lavori raccontano una trasformazione che interessa direttamente l’architettura dei sistemi AI. Nel primo caso, gli agenti producono dimostrazioni matematiche che un verificatore indipendente può controllare. Nel secondo, un ambiente ricorsivo migliora il modo in cui un modello affronta problemi complessi senza modificarne i pesi. Sono approcci differenti, ma entrambi spostano l’attenzione dal modello preso isolatamente al sistema che lo mette nelle condizioni di lavorare.

Per chi guida un’organizzazione tecnologica, questa evoluzione ha implicazioni concrete. Il vantaggio competitivo potrebbe dipendere sempre meno dalla disponibilità esclusiva di un determinato modello e sempre più dalla capacità di costruire ambienti nei quali gli agenti possano pianificare, operare, verificare i risultati e correggere i propri errori. Il modello diventa una componente di un processo più ampio, non necessariamente il suo elemento più importante.

C’è anche una conseguenza economica meno evidente. Se la verifica formale diventa progressivamente accessibile, cambia il costo marginale della qualità del software. Se il ragionamento su grandi quantità di informazioni migliora attraverso harness specializzati, diminuisce la necessità di risolvere ogni limite aumentando la dimensione dei modelli. In entrambi i casi, il valore si sposta verso l’ingegnerizzazione dell’intelligenza artificiale.

La ricerca di DeepMind su Signal è probabilmente uno degli esempi più convincenti di questa direzione. Non perché dimostri che l’intelligenza artificiale possa sostituire gli esperti di sicurezza, ma perché mostra che un gruppo di specialisti può utilizzare agenti autonomi per affrontare un problema che, fino a poco tempo fa, avrebbe richiesto risorse umane difficilmente disponibili. La differenza tra un assistente che suggerisce codice e un sistema che contribuisce a dimostrarne matematicamente la sicurezza è ormai molto meno teorica di quanto fossimo abituati a pensare.

Fonti originali per approfondire:

Google DeepMind, 10 novembre 2026: Introducing AlphaProof Code: a breakthrough in verifying complex software at depth.

Pubblicazione tecnica e dimostrazioni Lean: AlphaProof Code: Verifying Signal’s Security at the Machine-Code Level.

Microsoft Research Asia: LongCapHarness: Capability-Guided Auto-Harnessing for Long-Context Reasoning.

Codice sorgente: Google DeepMind, code-verification su GitHub.

Comments are closed.