Il sito che ti spiega l'AI.
News, strumenti e guide in italiano.
Studi e rapporti

Replit, 32 agenti Claude Opus 5.5 rendono NumPy fino a 18,9 volte più veloce

Lo studio Replit Frontier su Optimization-Bench mostra quando gli sciami di agenti AI battono il singolo agente e quando no, con NumPy a 18,9 volte.

Daniele Della Corte
Novembre 22, 2026
Lettura: 6 min
Team di persone al lavoro attorno a un tavolo, metafora del coordinamento tra agenti AI
fonte: unsplash photo-1504384308090-c894fdcc538d

Il 19 novembre 2026 il gruppo Replit Frontier ha pubblicato uno studio che mette alla prova un’idea molto in voga nel mondo degli agenti AI: se un agente lavora bene da solo, due, otto o trentadue agenti insieme lavorano meglio? Il dato più citato riguarda NumPy, la libreria di calcolo numerico di riferimento per Python. Un singolo agente Claude Opus 5.5, in due ore, ha reso i carichi di lavoro scelti circa 3,7 volte più veloci. Uno sciame di 32 agenti Opus, con lo stesso tempo a disposizione, è arrivato a 18,9 volte.

Sembra una vittoria netta della strategia “più agenti”, ma lo studio racconta una storia più sfumata, e proprio per questo utile a chi usa o sta valutando sistemi multi-agente.

Che cosa ha misurato Replit con Optimization-Bench

Per rispondere alla domanda, i ricercatori hanno costruito Optimization-Bench, una raccolta di compiti di ottimizzazione delle prestazioni su versioni bloccate di librerie open source. A ogni agente vengono consegnati il codice sorgente della libreria, un programma di prova con un carico di lavoro realistico, un contratto rigido sull’output e un verificatore isolato. L’obiettivo è ridurre il tempo di esecuzione senza rompere nulla.

La versione preliminare copre 14 librerie. Nel post Replit ne analizza quattro: NumPy con 13 carichi di lavoro (quantili, ordinamenti, gestione delle date, numeri casuali), SQLite con 12 (ricerca full-text, indici, JSON, join), SQLGlot con 4 e Git con 7, questi ultimi confinati in una libreria di confronto composta da soli 15 file.

La scelta è voluta. Secondo gli autori, i compiti di costruzione di software come ProgramBench vengono già superati quasi del tutto da un singolo agente, mentre l’ottimizzazione offre uno spazio di ricerca aperto e un punteggio continuo, dove dividere il lavoro può davvero fare la differenza.

Regole del gioco e valutazione

Ogni agente ha avuto a disposizione 8 vCPU, 16 GiB di RAM, due ore di tempo e i normali strumenti di profilazione. Erano vietati la memorizzazione tra una chiamata e l’altra, i trattamenti speciali per input noti, il calcolo anticipato dei risultati, la delega a librerie esterne e la modifica di impostazioni globali del runtime come allocatori e garbage collector. L’accesso alla rete era disattivato e le esecuzioni sono state controllate a posteriori.

Ogni compito è stato eseguito in quattro configurazioni: un agente solo, oppure sciami da 8, 16 e 32. I modelli provati sono sei: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Astra, GPT-6 Astra, GPT-6.1 Sol e GPT-6 Luna. Conta solo il ramo finale consegnato allo scadere delle due ore.

La valutazione avviene su una macchina separata, inaccessibile agli agenti. Il sistema rifiuta le modifiche fuori dai file consentiti, ricompila originale e candidato dal sorgente e pretende che i test del repository passino e che l’output coincida su input pubblici, input nascosti e test generati che solo la pipeline conosce. I tempi sono misurati solo sugli input nascosti, su una macchina Google Cloud c4-standard-32, alternando in ordine casuale esecuzioni originali e ottimizzate.

Come lavora uno sciame di agenti

Ogni partecipante, coordinatore o lavoratore, è un agente Replit completo con la propria sandbox. Non condividono un filesystem ma un repository, e il lavoro confluisce tramite branch e push. Per parlarsi hanno tre canali: una bacheca condivisa con thread, risposte, messaggi indirizzati e stati, i messaggi diretti e le trascrizioni.

Il punto più interessante è che il coordinatore riceve i requisiti del compito ma nessuna indicazione su come organizzare la squadra. Ogni sciame sceglie da sé la propria struttura, e questo si rivela il vero fattore discriminante.

I risultati: dove gli sciami funzionano e dove no

Su NumPy gli sciami Anthropic hanno registrato il salto maggiore, da 3,66 a 18,92 volte di mediana. Nel grafico dello studio, che la pagina non lega esplicitamente alla configurazione da 32 agenti, compaiono anche Sonnet 5.5 con 8,63 volte, GPT-6.2 Astra con 6,53, GPT-6.1 Sol con 4,94, GPT-6 Astra con 4,05 e GPT-6 Luna con 1,59.

Su SQLite l’etichetta di Opus 5.5 indica 1,52 volte, contro valori tra 1,02 e 1,23 degli altri. Su SQLGlot Opus arriva a 1,38 volte e Sonnet 5.5 a 1,14, mentre i modelli GPT restano intorno a 1. Su Git, invece, i numeri sono vicini tra loro: GPT-6.2 Astra 1,289, Opus 5.5 1,287, GPT-6 Astra 1,273.

Git è anche il caso più debole per gli sciami Anthropic, che faticano a battere le esecuzioni singole. La ragione è semplice: tutti e sette i carichi di lavoro toccano gli stessi 15 file, quindi c’è poco da dividere.

Un esempio concreto: searchsorted

Tra le ottimizzazioni ottenute c’è una modifica alla funzione searchsorted di NumPy, descritta nella pull request 33269. Il codice cerca 256 chiavi alla volta, in modo che il blocco resti nella cache del processore, e salta il confronto sicuro rispetto ai NaN quando nessuno dei due array ne contiene. Su input float64 con molte chiavi, il risultato è stato da 8,7 a 13,1 volte più veloce, con output identici.

Perché più agenti non significa sempre meglio

La parte più istruttiva dello studio riguarda i modelli che non scalano. GPT-6.2 Astra ha le migliori prestazioni da solo su ogni compito, ma i suoi sciami raggiungono il massimo con 8 agenti. A 32 scendono sotto il punteggio dell’esecuzione singola su NumPy, SQLGlot e Git. Sulla bacheca di SQLite, la casella di posta del suo coordinatore è cresciuta di circa quattro volte quando la squadra è raddoppiata.

Altri modelli soffrono di un problema di comunicazione. I lavoratori di GPT-6 Astra e GPT-6.1 Sol hanno inviato in media circa 22 e 20 messaggi diretti al coordinatore, contro 1,4 dei lavoratori Opus. I loro coordinatori sono diventati centralini, e raddoppiare la squadra ha spostato poco i punteggi. I coordinatori di GPT-6 Luna hanno avuto difetti propri: uno ha interrogato la bacheca più di 200 volte, un altro ha svolto gran parte del lavoro da sé, alcuni hanno detto ai lavoratori di restare fermi.

Chi ha funzionato meglio? Gli sciami in cui ogni lavoratore possedeva carichi o file distinti e lo dichiarava in pubblico. Opus ha tenuto l’82% dei messaggi sulla bacheca, con un thread per carico di lavoro e rivendicazioni esplicite dei file.

Il punteggio da soli, concludono gli autori, prevede male quello di squadra: conta di più la topologia che ogni sciame adotta spontaneamente.

Cosa cambia per chi usa agenti AI

Per un professionista che orchestra agenti, la lezione pratica è triplice. Prima di aggiungere agenti, verifica quanto lavoro davvero indipendente offre il progetto: se tutto passa per gli stessi pochi file, i conflitti di merge e la competizione sul codice annullano il vantaggio. Poi osserva come il modello si organizza, perché la stessa architettura produce risultati opposti con modelli diversi. Infine non scegliere il modello per il solo punteggio individuale.

Lo studio si inserisce in una serie di segnali sul tema che il sito segue da settimane. Ne abbiamo parlato, da un’altra angolazione, a proposito dei cicli di indagine di Codex usati da OpenAI per capire i rallentamenti di ChatGPT, dei prezzi e della scheda di sistema di GPT-6.2 Astra e dei limiti degli agenti quando devono servire più utenti insieme, nel test Worse Together di Anthropic. Per orientarti tra i modelli della famiglia, c’è anche la nostra pagina dedicata a Claude.

I limiti dello studio

Alcune cautele sono doverose. Il post non riporta costi in dollari, consumo di token né tempi assoluti, solo rapporti di velocità, quindi non si può dire quanto convenga economicamente uno sciame da 32 agenti. Gli autori descrivono i controlli contro il reward hacking ma non segnalano episodi nelle proprie esecuzioni. Inoltre i dati vengono da un benchmark preliminare costruito dagli stessi autori.

Conclusioni

Lo studio Replit non dice che più agenti siano sempre meglio, e nemmeno che non servano: dice che il guadagno dipende da quanto il problema si lascia dividere e da come il modello sa organizzare il lavoro. Gli autori prevedono di aggiungere nuove librerie come bzip2, xz, Black, SQLFluff, jq, serde_json, DuckDB, FFmpeg e Tantivy.

Se vuoi approfondire, leggi il post originale di Replit Frontier, prova a ripetere un piccolo esperimento sul tuo codice e raccontaci nei commenti come si comportano i tuoi agenti quando li metti in squadra.

Newsletter gratuita · ogni venerdì

Tutta l'AI della settimana, in 5 minuti, nella tua email

  • Le guide e le notizie della settimana, divise per rubrica
  • Solo ciò che conta, verificato e spiegato in italiano
  • Niente spam, ti cancelli con un clic

Daniele Della Corte
Rivisto e verificato da

Daniele Della Corte

Fondatore di IntelligenzaArtificiale.net · Consulente SEO e AI dal 2008

Prima della pubblicazione controlla fonti, numeri e nomi, e risponde personalmente di quello che leggi. Lavora con l'intelligenza artificiale da oltre 7 anni: ha fondato BeProud.ai e ha progettato la redazione di questo sito.

Consulenza AIVuoi applicare l'AI al tuo lavoro? Ti aiuto a scegliere cosa automatizzare e a realizzarlo.

Scopri la consulenza