Reika e Jeff-Code: i piccoli modelli locali rendono meglio con un'impalcatura costruita intorno

Reika è uno strumento da riga di comando per agenti di programmazione, pensato per modelli locali e ospitati. È stato pubblicato su GitHub il 5 ottobre. Nasce intorno ai modelli piccoli: da 8.000.000.000 a 35.000.000.000 di parametri, spesso eseguiti a Q2 o Q4 su una finestra di contesto da 16k a 32.000 token. L'autore, Alex Leung, dice che l'obiettivo non è rendere più intelligente un modello piccolo, ma rendere meno frustrante lavorarci.

Questa impostazione conta per chiunque faccia girare un assistente di programmazione su un portatile o su una singola GPU. Se è l'impalcatura, non il modello, a determinare la maggior parte del costo degli errori, allora l'aggiornamento più economico è un ciclo migliore. Il progetto è pre-1.0, quindi comandi e impostazioni possono ancora cambiare.

La parte più utile del rilascio di Reika è un registro di misurazioni pubblicato. Una riscrittura a metà contesto ha rielaborato 8.453 token di prompt, costando 7,9 minuti di prefill. Un'aggiunta nella stessa sessione è costata 25 token e 3,5 secondi. In un test A/B, un ramo ha scartato le proprie conclusioni prima di una piega. Ha piegato cinque volte, ha riletto file già letti e non ha mai risposto. Il ramo a cui è stato chiesto prima di riportare le conclusioni ha risposto dal digest. Il resoconto di Reika stesso dice che un grep che restituiva "0 corrispondenze" per una chiamata che non riusciva a servire ha portato un modello a riformulare un pattern corretto per cinque giri.

Reika riporta una differenza di comportamento dei modelli per dimensione. Nei test, i modelli da 14.000.000.000 a 35.000.000.000 di parametri hanno gestito i compiti su più file con la maggiore affidabilità. I modelli da 8.000.000.000 a 9.000.000.000 di parametri se la cavavano con compiti semplici e ben delimitati, e i modelli sotto i 7.000.000.000 di parametri raramente andavano lontano.

La formulazione del prompt ha spostato poco. Su un compito vago a Q2, un modello converge o va in spirale più o meno 50/50. L'impalcatura non può cambiare quel tasso, solo quanto costa la metà che fallisce.

Una seconda impalcatura, un trucco diverso

Anche Jeff-Code è stato pubblicato il 5 ottobre. È un fork di Pi, l'agente di programmazione di Mario Zechner e altri contributori, e mette un modello decisionale da 800.000.000 di parametri chiamato Jeff nel ciclo accanto a Qwen 3.8-27B. Intorno a ogni turno di Qwen, Jeff prende due decisioni da circa 0,2 secondi ciascuna. La prima è se può fare da solo il passo successivo (leggere un file, elencare una cartella, cercare nel codice, eseguire test). La seconda è se Qwen ha bisogno del ragionamento completo su quel turno. Scrivere e modificare file resta sempre a Qwen.

I risultati sono limitati ma onesti. Su 1.242 compiti appaiati, il tasso di successo è stato del 62,4% con Jeff-Code contro il 62,8% di Qwen da solo. È una differenza appaiata di meno 0,2 punti, con un intervallo al 95% da meno 2,6 a più 2,1. Il tempo medio per compito è sceso a 0,68x, con una mediana di 0,70x. Il tempo totale su tutti i compiti è stato 0,86x, perché in circa il 5% dei compiti Jeff-Code ha impiegato più di 30 minuti in più rispetto a Qwen da solo.

Alcuni benchmark non hanno mostrato un guadagno chiaro: Terminal-Bench 2.0 a 0,96x e SkillsBench a 0,91x. Disattivare il ragionamento su ogni turno era ancora più veloce ma costava 7,6 punti. Un Jeff meno prudente con soglia 0,7 costava 4,5 punti. È lo scambio che il rilascio rende esplicito: la velocità viene dal saltare il ragionamento, non dal toglierlo.

La stessa settimana ha portato un modello decisionale puntato sullo stesso problema. Liquid AI ha presentato d1 il 5 ottobre, il suo primo modello decisionale, ora con visione. Restituisce probabilità senza generare token a 200 o 300 ms per decisione testuale. Liquid dice che d1 eguaglia o batte GPT-6.1 Sol su quattro delle sei applicazioni testate e costa da 19x a 200x in meno. In una demo compatta il contesto di un agente di programmazione, rimuovendo il 52% dei token e mantenendo ogni output necessario al compito. Sono cifre del fornitore e non sono state verificate in modo indipendente.

Altrove la tesi on-device viene sostenuta con numeri diversi. Interfaze 1.1 Lite è stato pubblicato su Hugging Face il 5 ottobre. Gira su una singola GPU da 80 GB senza servizi esterni e trascrive una registrazione di 95 minuti in circa 90 secondi. La sua tabella di benchmark mette MMMU-Pro a 73,2 contro 71,1 di Interfaze e 40,4 di GPT-5.4-Mini. Resta indietro su GPQA Diamond a 85,9 contro 92,4.

La domanda aperta è quanto di tutto questo sopravviva al contatto con repository reali. Né Reika né Jeff-Code riportano risultati su un benchmark standard di programmazione frontier a impostazioni piene. Entrambi sono progetti agli inizi. Quello che mostrano è che la gestione del contesto, non il numero grezzo di parametri, è dove i piccoli modelli locali perdono tempo.