Esegui Qwen3.8-Flash-Next in locale con Strata: avvio rapido da 64 GB

Qwen3.8-Flash-Next (QFN) ha 125B di parametri totali, 6B attivi per token e una finestra di contesto nativa di 256K. Ha il reasoning abilitato di default e registra i punteggi più alti nei benchmark di coding agentico nella sua classe di modelli locali.

Questo articolo descrive l’esecuzione di una quantizzazione a 3 bit di QFN su un desktop da 64 GB di RAM con una RTX 5090 utilizzando Strata, e documenta perché le quantizzazioni sub-Q4 non producono chiamate di strumento affidabili per i carichi di lavoro agentici.

Sotto sono riportati i comandi di installazione, la RAM che ciascuna quantizzazione blocca e i fallimenti delle chiamate di strumento su un desktop da 64 GB. I dati su velocità e fallimenti mescolano esecuzioni su quella macchina — una RTX 5090, 64 GB di RAM, Ubuntu 26.04 — con rapporti dal tracker di Strata e le note di rilascio della versione 0.2.11.

I comandi e i valori predefiniti del motore sono stati verificati il 06/11/2026 rispetto a Strata 0.2.11, quando il repository mostrava 40.836 stelle e i pacchetti del motore erano alla versione 0.1.57. Dove questo runtime si colloca rispetto a Ollama, llama.cpp e vLLM è oggetto della Guida all’hosting LLM.

Cos’è Strata

Il motore in questo quickstart è Niko1221/Strata, con licenza MIT. Un progetto diverso, il paper OSDI 2026 sulla cache KV gerarchica per SGLang, utilizza lo stesso nome. Strata si basa su llama.cpp e ggml, e il repository include un documento su docs/paper/Strata-Paper.pdf. Esegue Qwen3.8-Flash-Next su una singola GPU di consumo, la RAM di sistema e un SSD. Lo stesso motore serve anche Qwen3.6-35B e DeepSeek V4.1-Flash.

Qwen 3.8 Flash Next ha 24.576 esperti instradati in 48 layer; ciascun token attiva 10 esperti (6B di parametri attivi in totale). Strata divide il modello su tre livelli di memoria invece di richiedere che stia tutto in uno.

Il blocco di parametri n-gram da 51B funge da tabella di consultazione con 20 milioni di voci indicizzata da bigrammi e trigrammi. Poiché si tratta di una consultazione e non di una moltiplicazione di matrici, può risiedere su un SSD con un costo in esecuzione minimo.

La capacità VRAM determina l’asse di scalabilità. Ogni gigabyte aggiuntivo di VRAM contiene circa 700 esperti, e ciascun esperto in cache sulla GPU riduce il calcolo CPU. Una scheda lenta con più VRAM supera le prestazioni di una scheda veloce con meno VRAM.

La capacità RAM è un vincolo rigido perché tutti gli esperti devono essere fissati per il calcolo simultaneo CPU e GPU. Strata non supporta il memory mapping lazy su disco. La dimensione del download e l’uso della RAM sono quasi identici per QFN.

Come è costruita la velocità di decodifica

Tre meccanismi forniscono il tasso di decodifica.

1. Previsione multi-token. Il checkpoint include un layer MTP addestrato per draft multi-step. Strata genera fino a 3 token di draft e li verifica in un passaggio unico su tutti i 48 layer — il ciclo draft-verify della guida alla decodifica speculativa. Il progetto misura un’accettazione media di 2,4–3,2 token per passaggio, e riporta ciò come 1,6–1,8× la velocità di decodifica con la stessa uscita.

2. Consultazione del prompt. Il server recupera fino a 5 token di draft da copie precedenti del contesto quando il modello lo sta ripetendo, come in un’edit al codice o in una citazione. Il progetto riporta edit al codice più veloci del 6–11%, e altri testi invariati.

3. Prefill a blocchi. I prompt arrivano in blocchi di fino a 8.192 token, e gli esperti del layer successivo si muovono via PCIe mentre l’attenzione del layer corrente viene eseguita. Il progetto colloca l’ingestione di documenti lunghi e di codebase sopra 1.000 token/s, e un follow-up inizia entro pochi secondi perché lo stato della conversazione rimane residente.

Il server include un’UI di chat locale, come app desktop o nel terminale, più endpoint compatibili con OpenAI e Anthropic su localhost. Claude Code, Codex CLI, OpenCode, Hermes Agent e OpenClaw si collegano attraverso strata connect. Hardware elencato dal progetto: NVIDIA RTX serie 20/30/40/50 (i pacchetti del motore CUDA 13 richiedono il driver 580 o più recente), AMD Radeon su HIP, Intel Arc su Linux, Apple Silicon, e AMD Strix Halo. Il rilascio 0.2.11 è Strata-0.2.11-linux-x86_64.AppImage per l’app desktop; il percorso del terminale qui sotto è quello che questo quickstart illustra.

Benchmark di QFN rispetto alle alternative locali

La scheda del modello di Alibaba confronta Flash-Next con Qwen3.8-27B, DeepSeek-V4-Flash (il checkpoint 0731) e Claude Opus 4.6 (Max).

Le righe di coding agentico su quella scheda hanno usato temperatura 1.0, top_p 0.95 e una finestra di 256K. DeepSWE riporta il più alto dei due ambienti di test, Claude Code e mini-SWE-agent, e la scheda dice che il punteggio più alto di Flash-Next è su mini-SWE-agent. SWE-bench Pro ha ri-eseguito le baseline su un set di compiti corretto; la cella di Claude Opus 4.6 è il punteggio pubblicato dal vendor, e le altre celle sono Claude Code.

Due righe sulla stessa scheda vanno nella direzione opposta. NL2Repo-Bench è 48.1 per Flash-Next e 54.2 per DeepSeek-V4-Flash. HLE, giudicato da GPT-4o, è 35.9 contro 40.0 di Claude Opus 4.6 (Max).

Per il lavoro agentico i valori predefiniti della scheda sono preserve_thinking attivo, in modo che la traccia di ragionamento resti tra i turni, e reasoning_effort a xhigh. Gli altri livelli sono medium e low. La pagina della famiglia Qwen 4 traccia ciò che Alibaba ha confermato su questa linea, inclusa la Qwen Community License 1.0 su questi pesi. La tabella qui sopra è la parte che può essere misurata oggi.

Costruzioni e dimensioni di quantizzazione

ISTA-DASLab GSQ-RCO

I GGUF ISTA-DASLab GSQ-RCO usano quantizzazione non uniforme. GSQ è quantizzazione scalare a basso numero di bit per tensore, e RCO assegna un tipo per tensore all’interno di un budget dimensionale. Il metodo spende quasi tutta la compressione sugli esperti instradati, che sono il 95% dei pesi ricercabili. Ogni costruzione è due shard. Il secondo è la tabella n-gram a circa 4,5 bit per peso, e può essere mappato da disco.

Quei valori GPQA sono dell’ambiente di test di ISTA, non il 91.7 sulla scheda di Alibaba. Una variante Coder mantiene 256 dei 512 esperti instradati per layer, a 58,4 GB e 1,89 bit effettivi per peso. Un proiettore visivo BF16 da 0,91 GB è l’add-on multimodale. La linea ISTA si ferma a IQ3_S; non ha una costruzione Q4.

Pacchetti Unsloth in Strata 0.2.11

Il 04/11/2026 Unsloth ha ricaricato i suoi GGUF di Qwen3.8-Flash-Next come Dynamic v3.1. Le note di rilascio 0.2.11 dicono che Strata può scaricare, preparare ed eseguirne sette dall’app, da strata launch --family unsloth, o da una cartella che si possiede già. Ogni file viene controllato per dimensione e SHA-256 rispetto alla revisione Unsloth d9620119. L’ultimo file di ogni set è la tabella per token da 28,8 GB. I set che condividono una tabella condividono il file: UD-IQ1_M con UD-IQ2_XS, e UD-IQ3_XXS con UD-IQ4_XS-v31.

UD-IQ4_XS-v31 è un file diverso dal UD-IQ4_XS che Strata offriva già: altri tipi di tensore, quattro file invece di tre. UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL, e Q8_0 restano sui file del 30/09/2026. Il UD-Q4_K_XL del 04/11 è gli stessi pesi in uno split a quattro file, e Strata accetta quello split se lo si possiede già. UD-IQ1_S non carica — un layer mescola due formati di esperti — quindi UD-IQ1_M è la scelta a 1 bit.

UD-IQ4_XS-v31 usa il formato di esperto Q5_0 in 33 layer. Le stesse note dicono che la matematica Q5_0 di Strata si colloca a 1,2–1,3% dal risultato esatto, contro 2,6–3,0% per la formula di llama.cpp su quei tensori. Su un Mac, l’app riscrive gli esperti in un file GPU prima del primo avvio, quindi il budget su disco è il download più quel file più pochi gigabyte (circa 115 GB per UD-IQ1_M).

Se la tabella da 28,8 GB resta mappata, il resto di UD-IQ4_XS-v31 è circa 64,9 GB prima della cache KV, il che è già oltre una macchina da 64 GB secondo la regola di fissaggio di Strata. Il resto di UD-IQ1_M è circa 39,2 GB. Quel file può stare dove IQ3_S non può, ed è un pacchetto a 1 bit, più lontano dal comportamento delle chiamate di strumento misurato qui sotto a 3 bit.

Quickstart: Installazione, Avvio e Configurazione del Primo Avvio

Un desktop Linux ha bisogno di una scheda RTX serie 20/30/40/50 o di un’altra GPU elencata dal progetto, RAM sufficiente per il pacchetto scelto più margine per la cache KV, e spazio SSD per il download. I pacchetti del motore CUDA 13 richiedono il driver 580 o più recente.

Installazione da terminale:

curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
strata launch

strata launch chiede il modello, la quantizzazione, il contesto, la cartella di archiviazione e le impostazioni di accesso, scarica il motore per la scheda, avvia il server e mostra un monitor con velocità, memoria e dati delle richieste. L’endpoint predefinito è http://127.0.0.1:8080.

Per vedere cosa sta prima di un download da 76 GB, o per avviare senza i prompt:

strata launch --family qwen --model q2_0 --plan      # dry run: cosa manca, cosa sta
strata launch --family qwen --model q2_0 --yes --no-tui   # avvia in background
strata launch --status
strata connect    # stampa la configurazione per Claude Code / OpenCode / Hermes / OpenClaw / ...
strata launch --stop

Quelli flag --family qwen --model q2_0 sono il dry run usato per la costruzione ISTA Q2_0 su Ubuntu 26.04. I pacchetti Unsloth usano --family unsloth e il nome dalla tabella qui sopra. strata connect stampa un blocco di provider per strumento. Entrambe le forme API usano un URL base compatibile con OpenAI (http://127.0.0.1:8080/v1) e il nome del modello che l’avvio stampa. Qualsiasi client che accetti un endpoint OpenAI-compatibile personalizzato, incluso Cursor, usa quella coppia.

Due impostazioni da verificare al primo avvio

1. Campionamento. Nella 0.2.11 una configurazione di pacchetto senza un blocco sampling segue la scheda del modello. Le richieste di reasoning ottengono temperatura 1.0, top_p 0.95 e top_k 20. Le richieste non di reasoning ottengono 0.7, 0.8 e 20, con presence_penalty 1.5. La precedenza è la richiesta, poi le impostazioni Chat dell’interfaccia web, poi il blocco di configurazione, poi la scheda. Temperatura 0 si applica solo quando la richiesta o il blocco la impostano, e quelle esecuzioni greedy sono quelle che sono finite in loop di ripetizione su questo checkpoint. Se una vecchia configurazione di pacchetto contiene ancora "sampling": {"temperature": 0}, sostituiscila con il preset di reasoning della scheda.

2. tool_call_recovery. La chiave vive nella configurazione di esecuzione del modello (strata-*.json). È attiva di default dalla 0.2.8, e disattiva nella 0.2.7 e precedenti. Le note del motore di Strata, citando 1.462 turni agentici, riportano il 98,3% delle chiamate lette come previsto con l’interruttore e il 92,9% senza. Accetta quattro forme di una chiamata il cui nome era nella richiesta: un tag <parameter=NAME>, JSON dentro tool_call, un blocco <function=NAME> senza wrapper tool_call, e una seconda chiamata dentro un tool_call. Un nome non dichiarato o JSON rotto resta testo. Nella 0.2.7 e precedenti, imposta "tool_call_recovery": true. Lascia il default della 0.2.11 attivo per il lavoro agentico.

Tieni il server su localhost

Il server si lega a localhost di default, e le impostazioni di accesso sono parte di strata launch. Gli endpoint espongono il modello e la conversazione su quella macchina, e non sono stati costruiti per una rete aperta. Quando un’altra macchina ne ha bisogno, metti un reverse proxy autenticato davanti alla porta.

ss -ltnp | grep :8080    # conferma che l'ascoltatore è 127.0.0.1, non 0.0.0.0
curl -s http://127.0.0.1:8080/v1/models   # il server risponde su localhost

Schede con 13 GB di VRAM o meno

STRATA_ROUTE_PRIOR=1.5 dice al router di preferire gli esperti già sulla scheda. Le note di Strata per una RTX 3060 12 GB che esegue IQ3_XXS riportano +15% nella decodifica di storie e +37% nella decodifica di codice rispetto al prior disattivato, e meno compiti agentici superati: 4,5 su 10 in media su 4 esecuzioni, contro 5,6 su 7 esecuzioni con il prior disattivato. La versione 0.2.7 ha attivato 1.5 da sola per schede NVIDIA discrete di 13 GiB o meno. La versione 0.2.8 l’ha disattivata di nuovo il 29/10/2026, dopo ripetizioni e sessioni agentiche lunghe più deboli (issue #4402). Con la variabile non impostata, 0.2.11 instrada come 0.2.6. Il progetto punta il prior verso chat e risposte brevi su una scheda da 12 GB, e via dalle esecuzioni agentiche lunghe.

Testbed: Un desktop da 64 GB che esegue un agente

La macchina misurata:

Con ISTA IQ3_XXS lo shard residente è 47 GB. Poiché gli esperti sono fissati, restano circa 9 GB per tutto il resto. La VM Hermes — lo stack agentico nella configurazione di produzione Hermes — più Cursor lascia circa 5 GB, che non è abbastanza page cache o cache KV per una sessione agentica lunga.

ISTA IQ3_S non sta su questa macchina come desktop giornaliero. Lo shard residente da 54,8 GB più la tabella n-gram mappata da 28,8 GB usano i 64 GB. Con Cursor in esecuzione, restano liberi 3 GB, e la VM Hermes non ha dove andare.

IQ3_S decodificava a 100–130 token/s, la stessa classe di velocità di una costruzione da 27B su llama.cpp con MTP 3 nel confronto MTP Qwen 3.6. Il pacchetto che sta nel budget di RAM (IQ3_XXS) è quello che manca nel formato della chiamata di strumento. Il pacchetto consigliato da ISTA (IQ3_S) lascia spazio per il resto del desktop.

Su IQ3_XXS il modello emetteva argomenti di chiamata di strumento non validi, inventava nomi di strumento non nello schema, e ri-emetteva lo stesso comando tre o cinque volte dopo un breve blocco di reasoning. L’ambiente di test tratta ogni errore come un retry, quindi la sessione si riempie dello stesso errore. Su questo hardware IQ3_XXS non è un modello agentico.

Cosa riporta la community

Rapporti di velocità per Qwen3.8-Flash-Next su Strata, da thread di issue e dalle note 0.2.11:

Tre modalità di fallimento sono documentate per Qwen3.8-Flash-Next a basso numero di bit in carichi di lavoro agentici.

1. Emissione di chiamate di strumento corrotta che segue la dimensione dello schema. L’Issue #1431 riporta che con 39 schemi di funzione (circa 12K token) e un prompt di sistema da 6K, IQ3_XXS su Strata 0.1.40 ha prodotto un turno utilizzabile in circa il 30–50% di oltre 20 riproduzioni controllate. Il modello o emetteva una forma di chiamata di strumento che il parser non poteva mappare — il testo finiva in content con finish_reason: stop — o chiudeva il blocco di reasoning ed emetteva fine-sequenza senza chiamata e senza risposta. Gli stessi pesi su llama.cpp hanno analizzato le chiamate di strumento in tutti i 8+ run consecutivi. llama.cpp vincola l’emissione con una grammatica PEG e recupera contenuti corrotti dentro tool_calls. Un wrapper che riparatava il testo dopo non ha spinto il tasso di turni utili sopra quella fascia 30–50%, perché la riparazione avviene dopo che i token sono già scelti.

2. Errori di configurazione e un percorso di esperto non deterministico. L’Issue #2685 riporta una RTX 5070, IQ3_S, e 60 GB di RAM, con chiamate di strumento fallite attraverso Strata: argomenti non validi, strumenti allucinati e loop di retry, incluso dopo l’attivazione di un blocco di campionamento e tool_call_recovery. La stessa quantizzazione attraverso llama serve ha avuto successo in 5 su 5 run dello stesso ambiente di test. Il riportatore ha trovato che seed identici divergevano nel percorso di esperto MMQ durante il prefill, e che disattivare quel percorso rendeva i run bit-identici. Strata 0.1.44 ha rilasciato correzioni di determinismo. Rapporti successivi non mostrano ancora Strata che eguaglia llama.cpp sulla stessa quantizzazione.

3. Chiamate di strumento lasciate dentro il blocco di reasoning. L’Issue #804 riporta che una chiamata di strumento completa dentro un blocco think non chiuso torna come reasoning_content, con content vuoto e nessun tool_calls, e il loop agentico si ferma. Un utente ha contato circa 1 su 100 risposte su circa 1.300 risposte agentiche reali, usando Hermes con IQ3_XXS, IQ2_XS, e le costruzioni Coder.

Perché il sub-Q4 rompe le chiamate di strumento agentiche

Una chiamata di strumento deve corrispondere a un formato di rete. A 3 bit questo modello da 125B manca quel formato in alcuni turni, e gli errori crescono con il contesto dello schema degli strumenti. Uno schema più grande chiede di più alla memoria di lavoro che formatta la chiamata, e il rumore di quantizzazione cade su quella formattazione. I turni di chat lo nascondono. I turni agentici, che sono in gran parte chiamate di strumento, no.

La stessa compressione fa più male quando pochi parametri sono attivi. Il confronto LLM locali per OpenCode ha misurato un 27B denso a IQ3_XXS con un tasso di errore di circa il 5% su un compito agentico strutturato. I checkpoint MoE a bassa attività a larghezze di bit simili sono falliti più pesantemente: il 35B-A3B ha avuto il 64,2% di errori su IQ3_S e il 98,8% su IQ4_XS, e il 122B-A10B ha avuto l'80% di errori su IQ3_S e il 90% su IQ3_XXS. Qwen3.8-Flash-Next attiva 6B di parametri per token, quindi un pacchetto a 3 bit si comporta come un modello piccolo su una quantizzazione pesante. Quelle esecuzioni OpenCode mostrano IQ3 e IQ4 che mancano il compito strutturato per il 35B-A3B e il 122B-A10B; non includono una esecuzione Q5 di Flash-Next. UD-IQ4_XS-v31 di Strata è scaricabile dalla 0.2.11, non ha un confronto di compito agentico nelle fonti verificate qui, e non sta nella macchina da 64 GB.

Gli stessi pesi GSQ-RCO falliscono quando sono caricati in llama.cpp e in Ollama. llama.cpp vincola ancora l’emissione con una grammatica e può recuperare uno span corrotto dentro tool_calls, quindi il client vede una chiamata invece di una stringa rotta. La modalità JSON di Strata, nelle note del motore, è prompting dello schema più un controllo dopo la generazione, non decodifica vincolata da grammatica: un oggetto male torna con HTTP 502 e structured_output_failed. tool_call_recovery e i rilasci successivi riparano le quattro forme elencate sopra. Non cambiano la distribuzione da cui il modello campiona, il che è perché il wrapper dell’issue #1431 non poteva superare il tasso di emissione.

Strata spende RAM per mantenere la CPU e la GPU sincronizzate. Su 64 GB, il pacchetto ISTA più grande che lascia ancora spazio per un desktop e una VM agentica è IQ3_XXS, e quel pacchetto è sotto la soglia di emissione misurata qui. IQ3_S decodifica già nella stessa fascia di un modello da 27B con MTP 3, quindi il limite su quel pacchetto è la RAM. Un’esecuzione llama.cpp con una mappa lazy impegnerebbe meno RAM e rinuncerebbe al tasso di decodifica che rende Strata il più veloce dei due su questo modello.

Giudizio

Qwen 2.8 Flash Next supera Qwen3.8-27B nei benchmark agentici: DeepSWE 58.7 vs 42.2, JobBench 55.7 vs 33.4, e Toolathlon 73.5 vs 67.1. Il lavoro multi-step è notevolmente più competente. Il calcolo per token è più vicino a un modello piccolo che a un modello da 125B.

Le quantizzazioni sotto Q4 non forniscono emissione affidabile delle chiamate di strumento per il lavoro agentico, fallendo a tassi che producono loop di retry sia su Strata che su llama.cpp. Le prestazioni Q4 non sono ancora dimostrate attraverso confronto controllato su benchmark agentici. Le quantizzazioni di classe Q5 sono il fondo dimostrato per il lavoro agentico affidabile; l’Unsloth UD-Q5_K_XL esiste ma manca di benchmark pubblicati.

Un Mac Studio con M5 Max e 128 GB di memoria unificata può contenere la costruzione MLX da 105 GB o un pacchetto Q4 con margine sufficiente per lo stack agentico. L’architettura di QFN è stata progettata per questo modello di offloading.

Continuerò a usare nella mia configurazione attuale un modello NVFP4 da 27B — 17 GB sulla RTX 5090 — con MTP 3, sta ottenendo 100+ token/s con chiamate di strumento affidabili e nessuna competizione RAM. Tornerò a QFN quando una quantizzazione di classe Q4 sarà benchmarkata su compiti agentici, quando il recupero delle emissioni di Strata maturerà, o quando l’hardware sarà aggiornato.

Riferimenti

• Niko1221/Strata — il motore di inferenza in questo articolo. Il paper OSDI 2026 sulla cache KV gerarchica per SGLang è un progetto diverso con lo stesso nome.
• Note di rilascio Strata 0.2.11 — pacchetti Unsloth Dynamic v3.1, matematica Q5_0, e le velocità con prompt brevi citate sopra.
• Note del motore (docs/DETAILS.md) — precedenza del campionamento, tool_call_recovery, e le misurazioni del prior del percorso.
• Qwen/Qwen3.8-Flash-Next — architettura, preset di campionamento e la tabella dei benchmark.
• ISTA-DASLab Qwen3.8-Flash-Next GSQ-RCO GGUFs — le costruzioni Q2 e IQ3 nel testbed.
• Issue #1431, issue #2685, issue #804, e issue #4402 — i rapporti di fallimento nelle sezioni community e schede piccole.

Link utili

• Scelta del miglior LLM per Ollama su una GPU con 16 GB VRAM — alternative a modello denso quando la scheda è il limite.
• Scheda rapida Ollama — l’altro server locale in cui gli stessi GGUF possono essere importati.