Alcuni pesi di modelli di frontiera si scaricano gratuitamente, ma questo dice solo chi può ottenere un modello, non chi può permettersi di eseguirlo. I motori di inferenza disponibili oggi presuppongono ancora hardware da datacenter, e chi ha una GPU da gioco si ritrova a scegliere tra modelli piccoli o attese insostenibili.
FreeToken parte esattamente da questa distanza. È un motore di inferenza pensato per i modelli Mixture-of-Experts, sviluppato da ricercatori di UC Berkeley insieme a colleghi di MIT e UT Austin, e pubblicato il 17 agosto 2026 con licenza Apache-2.0. Tra le firme del paper ci sono Ion Stoica e Matei Zaharia, cioè due nomi dietro Spark, Ray e buona parte dell’infrastruttura di calcolo distribuito degli ultimi quindici anni.
L’idea di fondo è trattare un computer personale non come una GPU piccola, ma come un unico insieme di risorse che comprende scheda video, processore, memoria di sistema e collegamento PCIe. Invece di decidere in anticipo cosa mettere dove, FreeToken misura le bande reali della macchina e ridistribuisce il lavoro a ogni passo.
I numeri dichiarati sono notevoli. Un modello da 35 miliardi di parametri gira a 39,3 token al secondo su un portatile con RTX 4060 da 8 GB, mentre GLM-5.2 da 753 miliardi di parametri arriva a 14,9 token al secondo su una singola RTX PRO 6000. Nei confronti con llama.cpp, Ollama e KTransformers, il vantaggio dichiarato sul decode va da 1,5 a 2,3 volte.
Perché i modelli MoE cambiano i conti della memoria
In un modello Mixture-of-Experts ogni strato contiene decine o centinaia di sottoreti specializzate, chiamate esperti, e una piccola rete di instradamento sceglie quali attivare per ciascun token in ingresso. Il resto degli esperti resta fermo. I numeri di DeepSeek-V4-Flash rendono l’idea. Il modello ha 43 strati e in ognuno attiva 6 esperti su 256, quindi per ogni singolo token lavorano circa 13 miliardi di parametri su un totale di 284 miliardi. Dal punto di vista aritmetico, l’esecuzione locale diventa plausibile.
Il problema è che la sparsità riduce il calcolo, non l’ingombro. Anche quantizzati a FP4, tutti gli esperti insieme occupano circa 140 GB, una cifra che nessuna scheda consumer avvicina. Gli esperti inattivi devono quindi vivere nella RAM di sistema ed entrare nel percorso di esecuzione solo su richiesta.
Qui nasce il collo di bottiglia: ogni volta che il modello ha bisogno di un esperto che non si trova nella memoria della scheda video, le strade sono due. O quel blocco di pesi viene spedito dalla RAM alla scheda attraverso il bus PCIe, cioè il canale che collega la scheda video al resto del computer, oppure il calcolo viene svolto direttamente dal processore.
Entrambe le strade sono lente per lo stesso motivo, ovvero la quantità di dati che riescono a spostare in un secondo. Questo valore si chiama banda, e sia il bus PCIe sia la memoria di sistema ne hanno molta meno di quella con cui una scheda video legge la memoria che ha a bordo. Il divario è netto. Una normale configurazione di RAM DDR5 a doppio canale sposta circa 80-90 gigabyte al secondo, mentre una RTX 4090 o una 5090 leggono dalla propria memoria tra 1 e 1,8 terabyte al secondo, cioè quindici o venti volte tanto. Servire un modello MoE in locale significa quindi gestire questo squilibrio. Il modo in cui lo si gestisce fa la differenza tra un sistema utilizzabile e uno che fa aspettare minuti prima di scrivere la prima parola.
Le tre cose che gli altri motori sbagliano
Il paper FreeToken di UC Berkeley è esplicito nell’elencare dove falliscono i motori esistenti, e vale la pena elencarli, perché spiegano tutto il resto del progetto.
- La lettura iniziale del prompt annulla il risparmio. Prima di rispondere, il modello deve leggere tutto quello che gli hai scritto, la fase che in gergo si chiama prefill. Migliaia di token attraversano ogni strato insieme e, presi nel loro insieme, finiscono per richiamare quasi ogni esperto disponibile. Il vantaggio della sparsità sparisce e l’intero archivio attraversa il bus, con un costo di circa due secondi su una RTX 5090, cinque su un desktop con PCIe 4.0 e dieci o più sui collegamenti ridotti tipici dei portatili.
- Il posizionamento fisso non segue il traffico. llama.cpp decide al caricamento quali pezzi tenere sulla scheda video, mentre KTransformers blocca in memoria un gruppo scelto in anticipo perché ritenuto il più richiesto. Siccome gli esperti chiamati cambiano a ogni token, gran parte del lavoro finisce comunque sul processore, mentre scheda video e bus restano fermi ad aspettare.
- Il processore non regge il resto. Scaricare tutto sulla CPU sembra una soluzione elegante finché non si guardano le bande di memoria, che sono un ordine di grandezza sotto quelle della scheda video.
La conseguenza pratica di questi tre difetti si vede nel tempo di attesa prima del primo token. Nei test riportati nel paper, il caso peggiore di FreeToken resta sotto i 44 secondi, mentre llama.cpp tocca 232 secondi, Ollama 179 e KTransformers arriva a 946. Vale la pena ricordare quanto conta il numero di 39,3 token al secondo citato per il portatile. Nei valori riportati dagli autori, la velocità di decode mediana misurata per Codex è di circa 33 token al secondo. Un portatile da mille euro, con un modello da 35 miliardi di parametri, si colloca quindi sopra quella soglia.
Su questi benchmark serve la cautela di sempre, dato che i numeri arrivano dagli autori del sistema e sono misurati su macchine scelte da loro.
Il meccanismo centrale, dividere le richieste tra bus e processore
La trovata più elegante di FreeToken è quella che gli autori chiamano politica q star, e il ragionamento dietro è semplice. Sia i trasferimenti verso la scheda video sia i calcoli svolti dal processore attingono alla stessa RAM di sistema, quindi non sono due strade indipendenti, sono due modi di usare la stessa risorsa. L’immagine che aiuta è quella di una conduttura unica che alimenta due rubinetti. Aprendone uno solo non sfrutti tutta la portata disponibile, mentre aprendoli entrambi nella giusta proporzione sposti più acqua nello stesso tempo.
Se il bus PCIe lavora al massimo, resta comunque della banda di memoria che i trasferimenti non stanno usando. FreeToken usa quel residuo. A ogni passo divide gli esperti mancanti in due gruppi, ne trasferisce una parte sulla scheda video e calcola il resto sul processore, poi somma i due risultati parziali. Il punto da sottolineare è che questa somma è esatta. Non c’è approssimazione, non c’è sostituzione di esperti, non viene toccato il router e non viene diminuita la precisione. L’output è identico a quello che produrrebbe lo stesso modello servito interamente su scheda video.
Attorno a questo ci sono altri due meccanismi che contano parecchio nell’uso quotidiano.
- Cache che sa dove tagliare. Mentre la scheda video calcola uno strato, il successivo viene già trasferito, così i due lavori si sovrappongono invece di alternarsi. In più il motore salva dei punti di ripristino nei momenti giusti della conversazione, ovvero all’inizio di un blocco di ragionamento o di una chiamata a uno strumento esterno. Sono esattamente i punti in cui un agente taglia e riscrive il testo, quindi una modifica costa solo il ricalcolo della parte nuova invece che dell’intera conversazione.
- Memoria elastica. La cache degli esperti sulla scheda video può essere ridimensionata a motore acceso, senza riavvii e senza ricaricare i pesi. Un comando come
ft ctl cache --moe 8k --kv 32ksposta lo spazio tra esperti e cache del contesto mentre il server continua a rispondere.
FreeToken: installazione su Linux e applicazione desktop su Windows
La riga di comando richiede Linux x86_64, una GPU NVIDIA con driver r580 o successivo su CUDA 13, e Python 3.10 o superiore. Non ci sono schede AMD, non c’è Apple Silicon, e i kernel CUDA vengono compilati alla prima esecuzione, quindi serve il toolkit con nvcc raggiungibile dal PATH.
# Installazione da PyPI, con uv (consigliato)
uv venv && source .venv/bin/activate
uv pip install "freetoken[accel]"
# Oppure dai sorgenti
git clone https://github.com/FlashML-org/FreeToken.git && cd FreeToken
uv venv && source .venv/bin/activate
uv pip install -e ".[accel]"
# Verifica
ft --version
Chi usa Windows non è tagliato fuori, ma passa da un’altra strada, cioè l’applicazione desktop scaricabile da flashml.ai, che installa il motore e aggiunge un’interfaccia grafica per scaricare modelli, chattare e regolare i parametri.
Avviare un server richiede un solo parametro, perché tutto il resto viene dedotto dal checkpoint e dalla scheda video installata.
# Il modello può essere una cartella locale o un id di Hugging Face
ft serve --model ~/models/Qwen3.6-35B-A3B
# Una volta pronto, il log mostra:
# API server is ready to serve on 127.0.0.1:1919
# Chat da terminale, collegandosi al server già avviato
ft shell
# Stato, throughput, occupazione della memoria video
ft ctl stats
Un passaggio da fare una volta sola è la calibrazione delle bande, che scrive un profilo riutilizzato dal motore per scegliere la strategia di suddivisione. Senza quel profilo il sistema resta su una modalità più conservativa.
# Misura banda di memoria e banda PCIe con i kernel reali
ft bench bw
# Solo i formati in uso
ft bench bw --dtype nvfp4,bf16
I modelli supportati coprono buona parte di quello che è uscito nell’ultimo anno, tra cui DeepSeek-V4-Flash, GLM-5.2 e GLM-4.7 nelle versioni NVFP4, la famiglia Qwen3.6 e Qwen3.5, gpt-oss nelle taglie da 20 e 120 miliardi, Gemma-4, MiniMax-M2.5. I checkpoint vengono letti direttamente in formato safetensors, con la possibilità di preconvertirli in un formato interno a caricamento rapido.
Collegare Claude Code, Codex e gli altri agenti al proprio computer
La funzione che rende FreeToken interessante oltre la curiosità tecnica è la compatibilità con le due API di cui ormai tutti gli strumenti fanno uso. Il server espone gli endpoint in stile OpenAI, ovvero /v1/chat/completions, /v1/responses e /v1/models, e quelli in stile Anthropic, cioè /v1/messages e /v1/messages/count_tokens.
Qualunque libreria client scritta per una delle due funziona cambiando il solo indirizzo di base. Un test rapido si fa con un comando curl, senza installare nulla.
curl http://127.0.0.1:1919/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "Qwen3.6-35B-A3B",
"messages": [{"role": "user", "content": "Spiega cosa fa questa funzione"}],
"max_tokens": 256,
"stream": true
}'
Per gli agenti di coding esiste una scorciatoia, il comando ft launch scrive la configurazione del provider per l’agente scelto, ne installa la riga di comando se manca e lo avvia puntandolo al tuo server.
Gli agenti riconosciuti sono sei e coprono i nomi più diffusi del momento.
- Claude Code. L’agente da terminale di Anthropic, oggi il più usato tra chi lavora a riga di comando, si collega con
ft launch claude. - Codex CLI. La controparte di OpenAI, che con
ft launch codexinterroga il tuo server invece dei server dell’azienda. - OpenCode. Alternativa open source molto seguita, nata proprio per non dipendere da un singolo fornitore di modelli.
- OpenClaw e Hermes. Due progetti aperti, pensati fin dall’inizio per funzionare anche con modelli locali.
- dsh. È il DeepSeek Harness, l’ambiente ufficiale con cui DeepSeek fa girare i propri modelli in modalità agente.
La combinazione più immediata è quella tra Claude Code e un modello da 35 miliardi di parametri quantizzato, perché resta nei limiti di memoria di una scheda da gioco e mantiene una velocità di scrittura comoda da seguire a schermo.
# Agenti supportati: claude, codex, dsh, hermes, openclaw, opencode
ft launch claude
# Mostra le modifiche previste senza toccare nulla
ft launch codex --dry-runLe chiavi API dei servizi cloud, da ANTHROPIC_API_KEY a OPENAI_API_KEY, vengono cancellate dall’ambiente del processo figlio, così l’agente non può ripiegare in silenzio su un endpoint a pagamento se il server locale si inceppa.
FreeToken: numeri dichiarati e requisiti
Il primo limite è quello hardware. La riga di comando gira solo su Linux con schede NVIDIA recenti, mentre l’applicazione desktop copre solo Windows. Chi lavora su Mac, su schede AMD o su Intel Arc resta fuori, e per quel pubblico llama.cpp rimane l’unica strada praticabile.
Il secondo limite riguarda lo spazio su disco e la memoria di sistema. Far girare un modello da 284 o 753 miliardi di parametri significa tenere quei pesi sul disco e caricarne una buona parte nella RAM del computer.
Il paper parla di circa 140 GB per l’insieme degli esperti di DeepSeek-V4-Flash in formato FP4. La scheda video da 8 GB è quindi solo una parte del racconto, e il resto lo fanno un SSD capiente e una dotazione di memoria generosa.
Anche la quantità di impostazioni disponibili è notevole, con decine di parametri che governano il modo di calcolare l’attenzione, la dimensione delle pagine della cache e la suddivisione degli strati. Nulla di tutto questo è un difetto, ma non è materiale per chi cerca un’installazione da tre clic.
Una scommessa che ripaga chi ha già una buona GPU da gioco
FreeToken non è il primo tentativo di far girare modelli grandi su hardware piccolo (ricordiamo anche Colibrì), ma è il primo che affronta il problema come una questione di bande misurate.
Il valore dipende da cosa possiedi già. Chi ha una scheda da gioco recente e paga un abbonamento mensile per un agente di coding ha ora un motivo per fare due conti, perché una configurazione locale che regge 35 miliardi di parametri cambia i calcoli della spesa. Chi tratta dati che non possono uscire dall’azienda ha un motivo ancora più forte, dato che non esce nulla dalla macchina.
Il consiglio pratico è partire in basso e salire. Installa il pacchetto, esegui la calibrazione delle bande, prova un modello da 30 o 35 miliardi quantizzato e collegaci il tuo agente con ft launch. Solo dopo, se la macchina regge, ha senso puntare ai modelli ancora più prestanti.
Nonostante qualche limite, il codice è Apache-2.0, la firma è quella del laboratorio che ha prodotto Spark e Ray, e la direzione indicata è quella giusta, cioè trasformare i pesi aperti in software che gira davvero sulle macchine che la gente possiede già.
