TurboVLA: un robot a 32 Hz con meno di un giga di memoria, togliendo l’LLM dal centro

Nei rally il copilota non racconta la strada: la legge. «Sinistra tre, lunga, non tagliare.» Le note sono state scritte prima, durante le ricognizioni, e in gara servono solo a dire al pilota dove guardare e che cosa fare adesso. Nessuno pretende che il copilota, a centocinquanta all’ora, ragioni sulla geografia della valle: se lo facesse, la curva arriverebbe prima della frase.

È l’intuizione da cui parte TurboVLA: Real-Time Vision-Language-Action Model at 32 Hz on an RTX 4090 with <1 GB VRAM, uscito su arXiv il 29 luglio 2026 (2607.27205, rivisto il 16 agosto). Nella versione attuale lo firmano sette autori della Huazhong University of Science and Technology di Wuhan: Hengyi Xie e Chenfei Yao a pari merito, Xianjin Wu, Yingying Zhu, Dingkang Liang come responsabile del progetto, Xiang Bai e Han Ding. Codice di addestramento e valutazione e pesi sono pubblici, su GitHub e Hugging Face. La tesi è netta: per eseguire un comando come «impila le tre ciotole» un robot non ha bisogno di far passare ogni fotogramma dentro un modello linguistico da miliardi di parametri.

Il collo di bottiglia al centro

I modelli visione-linguaggio-azione (VLA) sono diventati uno dei modi principali di costruire politiche per robot che obbediscono a istruzioni in linguaggio naturale. La maggior parte, osservano gli autori, segue lo stesso percorso, che riassumono come $V \to L \to A$: le immagini delle telecamere vengono proiettate nello spazio di rappresentazione di un grande modello linguistico, concatenate all’istruzione, elaborate da quel modello, e solo alla fine tradotte in comandi per i motori. Il linguaggio non è solo un ingresso: è il ponte obbligato fra percezione e azione.

Il ponte funziona, e porta con sé il sapere di un pre-addestramento su larga scala. Ma si paga a ogni chiamata della politica. I modelli autoregressivi, come RT-2 e OpenVLA, trattano le azioni come token e le generano una alla volta, ereditando la lentezza della scrittura testuale. Quelli più recenti, come $\pi_0$ e $\pi_{0.5}$ di Physical Intelligence, hanno aggiunto un «esperto d’azione» che produce comandi continui in parallelo; resta però il fatto che immagine e istruzione attraversano comunque un backbone da miliardi di parametri prima che un’azione esca. Misurato dagli autori su una RTX 4090 con batch uno, $\pi_{0.5}$ ha 3,4 miliardi di parametri, occupa 12,8 GB di memoria video e impiega 93,6 millisecondi per produrre un blocco di azioni: circa 11 aggiornamenti al secondo.

L’osservazione chiave del paper è che, a livello di esecuzione, l’istruzione ha già detto quale abilità serve. La politica non deve scrivere testo, non deve scomporre il compito in sotto-obiettivi: deve usare le parole per decidere quali parti della scena contano. Per questo, sostengono, basta molto meno.

Vista e parole, faccia a faccia

TurboVLA riscrive il percorso come $V + L \to A$. Le immagini passano per DINOv3, un encoder visivo pre-addestrato senza etichette; l’istruzione per BERT, il vecchio encoder testuale presentato nel 2018. Entrambi vengono proiettati in uno spazio comune di dimensione $d = 256$, e dell’istruzione si tiene la sequenza intera dei token, non un riassunto in un solo vettore: così oggetti, attributi e relazioni spaziali («la ciotola a sinistra del piatto») restano disponibili uno per uno.

Il cuore è un modulo di interazione di sei strati, ispirato al mondo del visual grounding, cioè dei modelli che localizzano in un’immagine ciò che una frase descrive: gli strati partono dai pesi pre-addestrati del modulo di Grounding DINO che fonde caratteristiche visive e testuali. In ogni strato l’attenzione incrociata corre nei due sensi. Le caratteristiche visive interrogano le parole, e diventano visione condizionata dal compito; le parole interrogano l’immagine, e diventano un’istruzione calata nella scena che il robot ha davanti. Per il lato visivo, la formula del paper è

$$\tilde{Z}^{v} = Z^{v} + \mathrm{Attn}\big(Q_{v}, K_{l}, V_{l}\big),$$

e per l’altro lato basta scambiare i ruoli di domande e contesto.

Lo stato del robot, cioè la configurazione in cui il braccio si trova in quel momento, entra solo dopo, nel decoder. È una scelta dichiarata: la corrispondenza fra parole e pixel non ha bisogno di sapere dove si trova il braccio, la traduzione in movimento sì. Il decoder è nello stile di ACT, un’architettura del 2023 per l’imitazione di dimostrazioni: dodici «domande» apprese, una per ogni passo futuro, che in un solo passaggio producono, su LIBERO, un blocco di dodici azioni continue a sette gradi di libertà. Niente token d’azione, niente generazione sequenziale, niente obiettivo linguistico ausiliario: l’addestramento è pura imitazione di dimostrazioni esperte, con una perdita $\ell_1$ fra azioni previste e azioni vere.

I numeri

La prova principale è LIBERO, un banco di prova in simulazione con quattro gruppi di dieci compiti per un braccio singolo: disposizione spaziale, oggetti, obiettivi, sequenze lunghe. Un solo modello addestrato su tutti e quattro, cinquanta tentativi per compito, duemila in totale. TurboVLA, con DINOv3 in versione ViT-B, ha 0,2 miliardi di parametri, usa 0,9 GB di memoria video e produce un blocco di azioni in 31,2 millisecondi. È da qui che viene il titolo: il reciproco della latenza,

$$f = \frac{1}{31{,}2\ \text{ms}} \approx 32\ \text{Hz},$$

cioè più di trenta blocchi di azioni al secondo. La media di successo è 97,7%, la più alta nella tabella degli autori, sopra anche il modello di Physical Intelligence, che ha circa diciassette volte i parametri ed è tre volte più lento. Il confronto con i modelli «leggeri» è il più istruttivo, perché ridurre la taglia non basta: Evo-1 ha pochi parametri ma è il più lento e il meno preciso del gruppo; VLA-Adapter si avvicina alla media di TurboVLA, ma con più parametri e più latenza. E TurboVLA non ha il pre-addestramento aggiuntivo su dati robotici che hanno quasi tutti i modelli più grandi.

Non vince ovunque. Sul gruppo delle sequenze lunghe fa 94,2%, meglio di $\pi_{0.5}$ (92,4%) ma sotto cinque concorrenti, da OpenVLA-OFT (94,5%) a VLA-JEPA (95,8%); sugli obiettivi (97,4%) resta dietro a $\pi_{0.5}$ (98,0%) e a OpenVLA-OFT (97,9%). Il vantaggio medio viene dai gruppi spaziale e oggetti, dove i migliori concorrenti stanno già fra il 98,8 e il 99,6%.

Il secondo banco è RoboTwin 2.0: cinquanta compiti a due braccia, cento tentativi ciascuno, con un encoder più grande (ViT-L, 0,4 miliardi di parametri in tutto) e blocchi di cinquanta azioni. Qui TurboVLA fa 60,2% in 43,4 millisecondi; $\pi_{0.5}$ si ferma al 57,0% e ne impiega 95,6, StarVLA-α arriva al 50,3% in 74,9. Infine il mondo reale: un braccio AgileX Piper a sei gradi di libertà, due telecamere, quattro compiti (afferrare un rullo, spostare una carta da gioco, premere una spillatrice, impilare tre ciotole), 65 dimostrazioni teleguidate per compito, a partire dal modello già addestrato su LIBERO, e quaranta prove ciascuno. I successi vanno dall’80 al 92,5%, sempre sopra $\pi_{0.5}$ allenato sugli stessi dati.

Le ablazioni rispondono alla domanda ovvia, cioè se il linguaggio serva ancora. Serve: senza istruzione la media crolla a 70,8%, e nel gruppo degli obiettivi, dove la stessa scena ammette più compiti, all’11,6%. Sostituire la frase con un vettore appreso che identifica il compito recupera gran parte del terreno ma resta 2,3 punti sotto. Il testo però non deve essere enorme: con T5-small al posto di BERT si ottiene 97,1%, con l’encoder testuale di SigLIP 95,5%. E l’interazione deve andare nei due sensi: concatenare semplicemente le caratteristiche dà 95,2%, l’attenzione in una sola direzione 96,1 e 96,5%.

Che cosa il paper non mette alla prova

La generalizzazione. Il vantaggio che si attribuisce a un LLM al centro è la comprensione aperta: istruzioni mai viste, oggetti nuovi, frasi scritte in modo diverso. Nessuno degli esperimenti la misura. LIBERO valuta gli stessi compiti su cui il modello è addestrato ed è ormai vicino alla saturazione, con distanze di pochi decimi fra i primi; RoboTwin è limitato, per scelta dichiarata degli autori e per ragioni di calcolo, allo scenario pulito, senza le scene randomizzate. Che BERT basti per «impila le tre ciotole», il paper lo mostra; che basti per un’istruzione mai sentita, no.

Il «tempo reale» è su una GPU da scrivania. La figura d’apertura parla di dispositivi edge, ma tutte le misure sono su una RTX 4090. Nessun numero su schede embedded, del tipo che si monta davvero su un robot. E 32 Hz è la frequenza con cui escono i blocchi di dodici azioni, non necessariamente quella a cui si comanda il motore.

Le latenze altrui le hanno misurate gli autori. Con architetture, codice e checkpoint ufficiali, a batch uno, sulla stessa scheda: è il modo corretto di confrontare, ma misura le implementazioni così come sono, e le tecniche di accelerazione che il paper stesso passa in rassegna (quantizzazione, potatura, esecuzione asincrona) restano fuori dal confronto.

Il mondo reale è piccolo. Quattro compiti, un solo braccio, un solo avversario, e i valori di $\pi_{0.5}$ compaiono solo come barre in un grafico, senza cifre.

Il limite dichiarato dagli autori è quello di fondo: TurboVLA è pensato per istruzioni concrete di esecuzione e può non offrire la comprensione e il ragionamento necessari a pianificare un compito complesso. La direzione che indicano è gerarchica: un grande modello che pianifica sopra un esecutore veloce come questo.

Perché conta adesso

Da tre anni la ricetta dei VLA è stata «più grande»: più parametri, più dati, un modello linguistico sempre più capace al centro, e poi tecniche per farlo andare meno piano. TurboVLA non dimostra che quella ricetta sia sbagliata; mostra che, sui banchi di prova su cui la comunità si misura, non è indispensabile. Il paper ne trae un invito esplicito: chiedersi se il controllo di basso livello debba restare centrato su un grande modello linguistico, e giudicare i sistemi non solo sulla percentuale di successo. La domanda scomoda che ne segue la aggiungiamo noi: se un modello da 0,2 miliardi pareggia quelli da tre o otto, forse quei benchmark misurano l’esecuzione più che la comprensione. Per chi costruisce robot la conseguenza pratica è più semplice: una politica che sta in meno di un giga e risponde in trenta millisecondi può girare in locale, senza un server remoto e senza rete; su una RTX 4090 è misurato, su un computer di bordo resta da vedere. Come il copilota del rally, legge le note e lascia a qualcun altro la geografia.