Jeff-Code affianca un modello da 0.8B a un coder da 27B e lo rende il 47% più veloce

Il 5 ottobre la pagina GitHub del progetto è comparsa con una rivendicazione circoscritta. Jeff-Code fa girare un modello decisionale da 0.8B, chiamato Jeff, dentro il loop dell'agente di Pi, l'agente di coding di Mario Zechner e dei contributori. Jeff prende due decisioni rapide attorno a ogni turno di Qwen, circa 0.2 secondi ciascuna. Se eseguire da solo il passo successivo, e se Qwen deve ragionare a fondo su questo turno.

Su 1.242 attività appaiate, il tasso di successo è risultato del 62.4% per Jeff-Code contro il 62.8% per il solo Qwen 3.8-27B. La differenza appaiata è di meno 0.2 punti, con un intervallo al 95% da meno 2.6 a più 2.1. Il tempo medio per attività è sceso a 0.68x, intervallo da 0.64 a 0.72, e la mediana è stata 0.70x. Da qui viene la cifra del 47%: il 32% di tempo in meno, in media.

Questa è la forma dell'AI on-device che nel 2.026 arriva davvero sul mercato. Il modello piccolo non scrive il codice, e nessuno sostiene il contrario. Decide cosa saltare.

Lo stesso schema ricorre in d1 di Liquid AI, un modello decisionale che restituisce probabilità invece di generare token, e in Reika, una CLI per agenti di coding costruita attorno a modelli da 8.000.000.000 a 35.000.000.000 di parametri a Q2 e Q4 su una finestra da 32.000 a 32.000 token. Per gli utenti la domanda pratica smette di essere se un modello piccolo sia abbastanza intelligente e diventa se sia abbastanza economico da lasciarlo acceso. Né Jeff-Code né Liquid hanno detto come si comportano questi sistemi su hardware più lento di una GPU da workstation.

Cosa può e non può correggere il harness

La documentazione di Reika argomenta con misure, non con aggettivi. Il progetto riferisce che una riscrittura a metà contesto ha rielaborato 8.453 token di prompt, costati 7.9 minuti di prefill, mentre un'aggiunta nella stessa sessione è costata 25 token e 3.5 secondi. Ha anche rilevato che la formulazione del prompt era la leva più debole a disposizione. Su un compito vago a Q2, un modello converge o va in spirale circa 50/50, e il harness non può spostare quel rapporto. Può solo cambiare quanto costa la metà che fallisce.

I risultati dei test sono poco lusinghieri per scelta. La pagina dice che i modelli da 14.000.000.000 a 35.000.000.000 di parametri gestivano con più affidabilità i compiti su più file, i modelli da 8.000.000.000 a 9.000.000.000 di parametri se la cavavano con quelli semplici e ben delimitati, e qualsiasi cosa sotto i 7.000.000.000 di parametri raramente andava lontano. La demo principale fa girare Qwen3.6 35B a Unsloth UD-IQ2_M tramite llama.cpp, accelerata tre volte, e il primo test del modello fallisce prima che lo corregga a partire dall'errore. Reika è pre-1.0, quindi comandi e comportamento possono ancora cambiare tra una release e l'altra.

I numeri di Jeff-Code mostrano la stessa onestà su dove i guadagni si fermano. Il tempo complessivo a orologio per tutte le attività insieme cala meno del tempo per singola attività, a 0.86x con un intervallo da 0.80 a 0.93, perché in circa il 5% delle attività Jeff-Code gira più di 30 minuti in più rispetto al solo Qwen. Anche la ripartizione per benchmark è irregolare: 0.63x su SWE-bench Verified e 0.64x su Terminal-Bench Pro, ma nessuna accelerazione chiara su Terminal-Bench 2.0 a 0.96x né su SkillsBench a 0.91x.

Poi c'è la parte che conta per chiunque sia tentato di copiare il trucco. Girare con il ragionamento spento a ogni turno è ancora più veloce, e costa 7.6 punti, intervallo da meno 10.6 a meno 4.5, con un calo di 13.5 punti su Terminal-Bench 2.0. Un Jeff meno prudente, con la soglia alzata da 0.6 a 0.7, perde 4.5 punti. Nella valutazione così com'è stata eseguita, circa tre quarti dei turni di Qwen giravano con il ragionamento spento. Il modello piccolo non aggiunge intelligenza. Decide quando l'intelligenza serve.

I modelli decisionali passano dal testo alle immagini

Liquid AI ha portato la stessa idea in un'altra direzione il 5 ottobre, annunciando d1, che definisce il suo primo modello decisionale e il primo a gestire immagini oltre al testo. Una chiamata a d1 legge l'input in un solo passaggio in avanti e restituisce probabilità per risposta senza generare token; una decisione su testo richiede da 200 a 300 millisecondi. L'azienda dice che d1 eguaglia o batte GPT-6.1 Sol su quattro delle sei applicazioni di test e costa da 19x a 200x in meno sia di quel modello sia di Claude Opus 5.5, e risponde più velocemente su ogni attività.

La parte più interessante è che il modello non è mai stato addestrato per questo. Grazie alla sua ottima generalizzabilità, capisce il compito da una breve descrizione.

Quella frase viene dal post di Liquid stesso, su una demo di ispezione visiva costruita sul dataset pubblico VisA di schede a circuito, candele, anacardi e gomme da masticare, dove d1 smista pezzi buoni e difettosi con un'accuratezza dall'85% al 97%. L'inquadratura dell'azienda è il punto interessante: un modello piccolo e specializzato che generalizza a un compito mai visto, da una frase di descrizione, invece che da un prompt e una finestra di contesto.

Una delle demo di Liquid cade direttamente sul problema degli agenti di coding. Si chiama Context Compaction e fa leggere a d1 ogni output di tool in una sessione di agente per tenerlo, ridurlo o scartarlo, eliminando il 52% dei token e conservando ogni output che il compito richiede. Liquid dice di aver adattato quattro delle sei applicazioni testuali da progetti open source. La tabella dei benchmark è dell'azienda stessa, e il rivale di d1, Jev, compare solo come nome: Liquid dice che una release sperimentale di una settimana prima ha reso d1 il primo modello a rivaleggiare con Jev sulle decisioni testuali, ma non fornisce cifre su Jev.

Il post di Sean Goedecke del 5 ottobre spiega perché un modello come Jev o d1 sia facile da sostituire una volta che funziona. Poiché lo si interroga per un compito specifico, si possono registrare i suoi input e output e addestrarvi sopra un classificatore proprio. Il modello costruito a mano sarà più economico e più veloce, perché non porta alcuna conoscenza di compiti non correlati. Il punto di Goedecke non è che i piccoli modelli decisionali siano deboli. È che sono un trampolino, ed economico, per validare una funzionalità prima che qualcuno assuma competenze di ML.

Lo stack dei modelli piccoli si completa attorno a loro

Altre release nelle stesse 24 ore mostrano quanto si sia mosso il tooling attorno ai piccoli modelli locali. Interfaze 1.1 Lite, pubblicato su Hugging Face il 5 ottobre, è un modello a mistura di architetture che gira su una sola GPU da 80 GB senza servizi esterni. Un nucleo visione-linguaggio instrada il lavoro a specialisti per documenti, parlato, rilevamento di oggetti e controlli di sicurezza, e mantiene un contesto da 131.000 token. La sua tabella lo pone a 73.2 su MMMU-Pro contro 71.1 di Interfaze e 40.4 di GPT-5.4-Mini, e a 83.8 su olmOCR-Bench contro 85.7 di Interfaze, quindi il modello piccolo perde contro il proprio predecessore più grande su un benchmark di documenti e vince sul ragionamento multimodale.

Metagente, pubblicato su GitHub il 5 ottobre, scommette sul contrario: un singolo binario Rust e un breve file di agente dichiarativo invece di un framework Python. Parla MCP e A2A in modo nativo, e la sua proposta è che ogni agente dichiari quali cartelle, variabili d'ambiente e altri agenti può usare. Quel modello di permessi è la parte da tenere d'occhio per chiunque faccia girare agenti sulla propria macchina, dove la modalità di guasto non è una risposta sbagliata ma un'operazione sbagliata su un file.

Neanche il fronte accademico è chiuso. Uno studio della UC Riverside, pubblicato il 23 settembre, ha rilevato che nei grandi modelli linguistici la fiducia e la correttezza nascono da caratteristiche interne diverse. Il gruppo ha studiato Llama-3.1-8B di Meta e Gemma-2-9B di Google con autoencoder sparsi e ha trovato che sopprimere le caratteristiche legate puramente all'incertezza riduceva nettamente l'accuratezza, mentre sopprimere la maggior parte delle caratteristiche legate alle risposte errate non la riduceva.

Het Patel, dottorando in informatica alla UCR e primo autore, ha inquadrato la scoperta rispetto all'assunto di default del settore: «L'assunto principale nel settore è che quando il modello è sicuro, è probabile che sia corretto, e quando il modello è incerto, è più probabile che sia scorretto.» La parte utile è che i ricercatori hanno cambiato il comportamento abbassando caratteristiche interne invece di riaddestrare, la stessa economia che Jeff-Code e d1 stanno inseguendo.

Cosa i numeri non chiariscono

L'argomento a favore dei modelli piccoli on-device poggia su tre tesi che le release del 5 ottobre sostengono in modo diseguale. Sul costo, il divario da 19x a 200x di Liquid e il tempo di 0.68x per attività di Jeff-Code sono entrambi autodichiarati, misurati contro baseline scelte dalle aziende. Sulla capacità, Reika è esplicita nel dire che il suo harness rende un modello piccolo meno frustrante, non più intelligente, e il tasso di successo di Jeff-Code è piatto, non migliore. Sulla fiducia, il lavoro della UCR dice che la fiducia dichiarata da un modello è una guida scarsa, cosa che conta di più quando è il modello a decidere cosa saltare che quando è una persona a leggere la sua risposta.

Beam di Reflection, annunciato il 5 ottobre, mostra il contrappeso. Il suo modello sparso da 501.000.000.000 di parametri, con 23.000.000.000 di parametri attivi, raggiunge 80.1 su Terminal Bench v2.1, dove Kimi K3 segna 88.3 e DeepSeek V4.1 Flash 90.6. Reflection dice che Beam eguaglia GLM-5.2 sul ragionamento avanzato usando da 3 a 4 volte meno calcolo di inferenza. I pesi, il rapporto tecnico e la model card sono attesi più avanti questo mese, e il modello è ancora in red-teaming.

Quindi la frontiera non sta ferma, e la storia dei modelli piccoli non è una corsa che stanno vincendo. È una scommessa diversa: che la maggior parte del lavoro degli agenti sia instradare, leggere e decidere, e che un modello da 800.000.000 di parametri che compie quei passi mentre uno più grande pensa valga più di uno più grande che fa tutto. La valutazione dietro Jeff-Code sostiene quella scommessa sulla velocità e la lascia non dimostrata sulla qualità. Nulla in essa mostra l'abbinamento battere il solo Qwen. Mostra che tiene il passo spendendo meno.

Quello che nessuno ha pubblicato è il numero che gli acquirenti vorrebbero di più: il costo di far girare la coppia su hardware che un team normale possiede. Jeff-Code girava sullo stesso server Qwen in blocchi appaiati. Liquid cita il costo per decisione contro due modelli ospitati. Le cifre di Reika sono tempi di prefill su un setup locale con llama.cpp, che almeno mette in vista l'overhead del harness. Finché quei numeri non saranno comparabili, il riassunto onesto del 5 ottobre è che i modelli piccoli sono diventati abbastanza economici da stare dentro il loop, e le discussioni sul fatto che ci debbano restare sono appena cominciate.