Duemila agenti si riscrivono in due settimane: come Prime Agent ha portato TypeScript in Rust

Un esercito di duemila, e nessuno è umano

Prime Agent, l'agente di programmazione uscito ufficialmente solo ad agosto 2026, in due mesi ha accumulato più di 300.000 download e ha elaborato oltre 8 trilioni di token. Il 9 ottobre, il suo sviluppatore Prime Intellect ha annunciato qualcosa di ancora più vistoso: lo strumento è stato riscritto da se stesso. Il passaggio da TypeScript a Rust è stato completato in due settimane, e a fare il lavoro sono stati più di duemila agenti autonomi.

Non è lo slogan "l'IA ti scrive il codice". Durante tutta la portabilità, il team umano ha fatto soprattutto una cosa: predisporre i criteri di accettazione, così che gli agenti potessero misurare da soli se avevano fatto bene. Il resto, orchestrazione, scrittura del codice, revisione e verifica, è stato affidato alle macchine.

Costo e scala: spostare 200 miliardi di token

Secondo il blog ufficiale, questa riscrittura ha coordinato più di 2.000 agenti che lavoravano in parallelo su oltre 10.000 sandbox Prime, consumando più di 200 miliardi di token dall'endpoint GLM-5.3 di Prime Inference. La fase che ha davvero scritto il Rust è stata completata da 1.981 agenti, con circa 192,99 miliardi di token; la successiva fase di tre giorni di salita delle prestazioni ha aggiunto altri 228 agenti e circa 35,7 miliardi di token.

Questi numeri sono di per sé un segnale. Che il modello aperto GLM-5.3 diventi il motore di inferenza principale di uno sciame di agenti di livello produttivo non è la stessa cosa di "un modello ha guadagnato un altro punto in un benchmark". Dimostra che, in contesti di ingegneria lunghi, massivi e che richiedono chiamate a strumenti affidabili, il rapporto costo-efficacia dei modelli a pesi aperti è ormai accettabile per progetti reali.

Orchestrazione: l'agente radice non scrive codice di prodotto

La cosa più da copiare non è "ha usato duemila agenti", ma il loro modo di dividersi il lavoro. L'intera riscrittura era guidata da un unico agente radice, che però non ha scritto una sola riga di codice di prodotto. Faceva solo tre cose: scomporre i compiti in un grafo con ordine topologico, seguire l'avanzamento di ogni compito e unire il lavoro completato.

Ogni compito attraversa quattro ruoli, in sequenza:

• Pianificatore: scrive la specifica, il design della funzionalità e la "risposta di riferimento", presa direttamente dal comportamento esistente della versione TypeScript.
• Implementatore: scrive il codice Rust in un worktree separato, così funzionalità diverse procedono in parallelo.
• Revisore: cambia modello e contesto per cercare in modo avversariale i difetti di questa modifica.
• Verificatore: compila il codice ed esegue i test di coerenza in una sandbox nuova di zecca.

Se la revisione o la verifica non passa, il compito torna all'implementatore con le conclusioni. Solo quando entrambe passano la modifica può essere unita. Prime Intellect ha separato di proposito "generazione" e "valutazione", per una ragione schietta: se lasci che l'agente che ha scritto il codice giudichi il proprio risultato, tenderà naturalmente a favorire se stesso.

Le vere barriere: quattro tipi di controlli di coerenza

Il processo da solo non basta; servono anche criteri oggettivi di giusto e sbagliato. Il team ha costruito quattro tipi di controlli di parità, che coprono aspetti diversi della stessa funzionalità:

• Test differenziali della TUI: eseguire i due binari TypeScript e Rust sotto lo stesso modello con script, confrontando lo schermo del terminale fotogramma per fotogramma, coprendo avvio, menu, chiamate agli strumenti, ripresa della sessione, sotto-agenti e recupero dopo un crash.
• Coerenza dell'harness: confrontare le trascrizioni di sessione prodotte da ciascun lato e le richieste che ognuno invia al fornitore del modello.
• Coerenza del protocollo: verificare ogni tipo di messaggio del protocollo del daemon contro l'implementazione TypeScript.
• Audit funzionale: dove gli script non arrivano, gli agenti controllano componente per componente e marcano ciascuno come "coerente", "parzialmente coerente" o "mancante".

Con queste regole oggettive, gli agenti possono giudicare da soli l'avanzamento e fermare le regressioni prima dell'unione, riducendo la necessità di revisione umana. Il team è anche schietto: i bug sfuggiti erano quelli che nessun test copriva, e sono emersi solo con l'uso quotidiano interno.

Risultati: avvio a freddo 14 volte più rapido, 80 % di memoria in meno

Nei dati di confronto ufficiali, la latenza dall'avvio a freddo alla possibilità di digitare scende da 737,8 millisecondi della versione TypeScript a 55,8 millisecondi, un'accelerazione di 14,18 volte; l'avvio a caldo guadagna 13,34 volte; la memoria dell'intero albero dei processi scende da 607,4 MB a 106 MB, con un risparmio di circa l'80 %; anche la dimensione di installazione si riduce da 172,1 MB a 59,6 MB. Il primo output visibile arriva a 23,6 millisecondi. La fase di salita ha registrato in tutto 144 esperimenti e ha unito 69 modifiche valide. Un avvertimento: questo confronto affiancato usa la suite di esecuzione del team stesso, e il team segnala anche l'assenza di un benchmark comune, quindi i numeri vanno letti con prudenza.

Il cambiamento strutturale potrebbe durare più della velocità. Il codice è stato diviso in nove crate, con dipendenze unidirezionali imposte da Cargo; il file sorgente più grande è passato da circa 15.000 righe a circa 2.500, e nessun file supera più le 5.000 righe. Ogni sessione gira nel proprio processo di lavoro, quindi un crash non influenza gli altri. Il supporto a Windows è arrivato come effetto collaterale di un'astrazione della piattaforma più pulita, e il catalogo dei modelli viene ora recuperato a runtime, così un nuovo modello non dipende più da un rilascio.

Perché Rust

I punti dolenti di TypeScript elencati dal team sono concreti: i tipi sono opzionali e spariscono a runtime; gli errori si propagano come eccezioni non controllate; il lavoro che consuma CPU, come il rendering e il parsing di sessioni grandi, contende lo stesso event loop all'input da tastiera; e ogni processo deve mantenere un runtime JavaScript e la garbage collection. Per un daemon che resta residente ed esegue un processo di lavoro per sessione, il codice nativo senza GC è la principale fonte di miglioramento per memoria e tempo di avvio.

E quando il codice è scritto soprattutto dagli agenti, il valore delle "garanzie in fase di compilazione" si amplifica. Enum esaustivi, ownership e lifetime, più i lint severi di Clippy, eliminano un'intera classe di bug prima ancora che il codice giri. In altre parole, il compilatore si fa carico di una parte del giudizio che altrimenti spetterebbe a un revisore umano.

Cosa significa per persone diverse

Se guidi un team di ingegneria, ciò che puoi riutilizzare non è il numero "duemila agenti", ma il metodo: prima trasformare i criteri di accettazione in controlli oggettivi ed eseguibili automaticamente, poi distribuire generazione e valutazione tra modelli e contesti diversi, e infine lasciare che gli agenti avanzino da soli dentro le barriere. Primer Intellect sta già trasformando questo schema a quattro ruoli in un flusso di lavoro riutilizzabile, con la motivazione che una "fabbrica di sciami ben definita" è più affidabile di una messa in piedi all'occorrenza per ogni progetto.

Se sei solo un utente comune, questo spiega una cosa: la velocità di aggiornamento di strumenti come Prime Agent assomiglierà sempre meno a quella del software tradizionale. Quando un prodotto può riscrivere se stesso, il significato del numero di versione cambia. È anche un promemoria: davanti a conclusioni come "il refactoring ha accelerato di 14 volte", vai prima alla nota a piè di pagina per vedere chi ha misurato e con cosa. Gli agenti sanno scrivere codice utile, ma sanno altrettanto bene scrivere lodi di sé piene di sicurezza.