Passa al contenuto principale

Addestra il tuo modello decisionale: Jeff, Jeeves e lo stack System One fai-da-te (set 2026)

Avanzato
What you'll learn
  • Spiegare la vera ricetta di addestramento dietro un modello decisionale open — cross-entropy sulle lettere delle opzioni, un'epoca, e una temperatura calibrata dopo — e perché la calibrazione è una fase separata dall'accuratezza
  • Leggere onestamente le tabelle di benchmark pubblicate: le tre righe in cui un modello da 0,8B batte l'API commerciale, e le due righe in cui perde di 20–26 punti
  • Scegliere fra quattro opzioni — API hosted, pesi open zero-shot, un fine-tune proprio, o un semplice classificatore a embedding — usando l'unico numero di baseline che uccide la maggior parte di questi progetti
  • Addestrare e servire da soli un modello compatibile con Jev in un pomeriggio su una sola GPU, inclusa la regola di selezione del checkpoint che tiene onesto il risultato
  • Sapere quando rimettere il ragionamento dentro un modello decisionale vale 11x la latenza, e come una soglia di confidenza compri quasi tutta l'accuratezza a un terzo dell'attesa

I modelli decisionali System One hanno spiegato la categoria: invii lo stato del programma più domande tipizzate, e ricevi indietro probabilità calibrate invece di testo. Quella pagina si fermava a dov'erano le ricreazioni open a metà settembre — Kev, Nimble, uno shim sui logprob.

Nell'ultima settimana di settembre la storia ha cambiato forma. La domanda ha smesso di essere "possiamo clonare l'API" ed è diventata "conviene addestrarne uno tuo?" Il 28 settembre un progetto chiamato Jeff ha rilasciato fine-tune da 0,8B e 2B che si fermano a quattro punti dal punteggio complessivo di Jev e girano in ~22–28 ms su una GPU di classe laptop, addestrati in circa due ore su una sola scheda da workstation. Quel giorno è stata la notizia AI più in alto su Hacker News. Dodici ore dopo PostHog ha pubblicato Jeeves, che fa l'opposto — innesta il ragionamento sopra un modello decisionale — e dichiara di battere Jev sul suo stesso livello difficile.

Entrambi sono codice MIT con pesi Apache-2.0. Entrambi sono abbastanza onesti nei loro README da pubblicare le righe in cui perdono. Questa pagina parla di cosa significano quelle righe per te.

Le 72 ore, in ordine​

Data (2026)Cosa è uscitoPerché conta
15 setJev (TypeSafe AI), solo APIHa definito la categoria e la forma della richiesta /v1/systemone
21 setKev, Nimble, openjev-sglangHanno dimostrato che l'interfaccia era riproducibile su pesi open
—AutoJev (denis-pplx)La ricetta: SFT full-weight di Qwen3.8-27B, 73.000 esempi, una H200, 84,60% contro un 69,83% del modello base
28 setJeff (firelex)L'ha rimpicciolita — studenti da 0,8B/2B, ~2 h su una GPU da workstation, serving MLX, valutazioni su videogiochi
29 setJeeves (PostHog)Ha ribaltato la premessa — un modello decisionale che pensa, LoRA + RL su Qwen3.5-9B

Il filo conduttore: in due settimane una categoria è passata da un'API chiusa con addestramento non dichiarato a una ricetta che puoi far girare in una notte. AutoJev è la cerniera — ha pubblicato la funzione di loss, e tutto ciò che è venuto dopo è una variazione su quell'unica idea.

La ricetta, sul serio​

Togli il marketing e un modello decisionale è una modifica sorprendentemente piccola a un normale LLM.

1. La loss è cross-entropy sulle lettere delle opzioni​

Al modello non si insegna a "prendere decisioni". Gli si insegna a mettere massa di probabilità su un singolo token-lettera — A, B, C — in una posizione precisa. Disponi le opzioni come un pannello con le lettere, addestri con una semplice cross-entropy sulla lettera corretta, e in inferenza leggi i logit dei token-lettera e li rinormalizzi solo sulle opzioni che hai offerto.

Quell'unico dettaglio implementativo spiega il limite principale. Jeff ti ferma a 26 opzioni, e il README è schietto sul fatto che le posizioni oltre quella soglia non vengono "di fatto mai selezionate" — perché è finito l'alfabeto, non per ragioni architetturali. (Jev stesso dichiara fino a 255 opzioni, il che ti dice che codifica le opzioni in modo diverso.)

Jeeves prende l'altra strada: una pointer head che confronta uno stato nascosto proiettato con l'embedding di ciascuna opzione tramite un prodotto scalare scalato. Niente lettere, nessun tetto alfabetico. Segna la struttura con token rari presi in prestito dal tokenizer di Qwen che il testo reale non usa praticamente mai — <|fim_prefix|> per lo stato, <|fim_middle|> per le domande, <|box_start|>/<|box_end|> attorno alle opzioni, <|fim_suffix|> nel punto della decisione. Riusare token morti come delimitatori è il trucco economico che evita di far crescere il vocabolario o di collidere con il contenuto.

2. La calibrazione è una fase separata, a un solo parametro​

È la parte che si salta, ed è la parte che rende l'output affidabile.

Accuratezza e calibrazione sono proprietà diverse. Un modello può mettere la risposta giusta al primo posto quasi sempre e dire comunque "91%" quando ha ragione il 75% delle volte — il pilota indipendente su BANKING77 con Jev ha trovato esattamente quella forma di eccesso di confidenza. Per questo tutti e tre i progetti calibrano un singolo scalare di temperatura su un development set tenuto da parte dopo l'addestramento, e lo distribuiscono insieme al checkpoint. Dividi i logit per quello, softmax, fatto.

AutoJev pubblica cosa ti compra tutto questo, ed è il prima/dopo più pulito dell'intero stack:

MetricaQwen3.8-27B baseAutoJev-27B
Accuratezza69,83%84,60%
ECE (expected calibration error — più basso è meglio)0,064830,04282
Brier score (più basso è meglio)0,408340,22027

Nota che tutti e tre si sono mossi, ma di quantità diverse. L'accuratezza è salita di ~15 punti mentre l'ECE è sceso del ~34% — l'addestramento ha reso il modello sia più corretto sia più onesto, e l'onestà è misurabile separatamente. Se addestri il tuo e riporti solo l'accuratezza, non hai finito.

3. Tutto il resto è piccolo​

Un'epoca. Batch 256. Full-weight (Jeff, AutoJev) o LoRA r=16 (Jeeves). Selezione del checkpoint su un development set, mai sul pannello di benchmark — Jeff lo dichiara esplicitamente, ed è l'unica riga che separa un risultato credibile su un modello piccolo da uno contaminato. Jeff tiene inoltre almeno metà di ogni famiglia di addestramento nello stesso layout di pannello che vedrà in inferenza, il che conta più di quanto dovrebbe; vedi la sezione sulla formulazione più sotto.

Addestra un modello decisionale da 0,8B (la ricetta di Jeff)

# 1. Build the training mix from public datasets
uv run autojev-mix ...

# 2. One epoch, full-weight, lr 5e-6
scripts/train.sh RUN data/mix/public.jsonl data/mix 5e-6 40 Qwen/Qwen3.5-0.8B <revision> --epochs 1

# 3. Evaluate the SELECTED checkpoint against a held-out panel
uv run autojev-evaluate --data data/panel.jsonl --local \
--checkpoint checkpoints/RUN/selected --output runs/eval/RUN.json

Costo dichiarato del passo 2: ~2 ore per il modello da 0,8B, ~3,5 ore per quello da 2B, su una sola RTX PRO 6000. È il numero che ha reso questa una storia da prima pagina.

Leggi la tabella dei benchmark di traverso​

Ecco il pannello pubblicato da Jeff — 4.599 domande su cinque dataset pubblici più il livello difficile di JevBench — con l'API commerciale nell'ultima colonna. Leggilo per riga, non per la riga complessiva.

BenchmarkJeff-0.8BJeff-2BJeff-Gemma4-E2BJev (API)
Complessivo79,1%83,1%81,6%83,0%
Financial PhraseBank96,4%96,3%96,1%77,0%
RAGTruth86,1%88,9%87,4%77,3%
WinoGrande68,6%79,0%77,4%90,7%
JudgeBench62,6%64,6%60,6%78,6%
BBH64,0%68,0%66,4%94,3%
JevBench Hard47,6%53,3%48,6%73,3%

I punteggi complessivi sono quasi in parità. Le righe non lo sono affatto:

  • Dove il modello minuscolo vince, vince alla grande. Financial PhraseBank: 96,4% contro 77,0% — un modello da 0,8B che batte un'API commerciale di 19 punti. RAGTruth (questa risposta resta fedele al passaggio recuperato?): 86,1% contro 77,3%. Sono entrambi lavori stretti, ad alto volume, di forma "pattern" — sentiment su un vocabolario fisso, groundedness su un passaggio fornito. Se il percorso critico del tuo agente ha quella forma, uno 0,8B locale non è un compromesso, è lo strumento migliore.
  • Dove perde, non ci va vicino. BBH è 30 punti sotto. JevBench Hard è 26 punti sotto. Sono le righe che richiedono ragionamento multi-step, e il README lo dice chiaramente: i modelli decisionali piccoli ti danno "scelte rapide e calibrate fra le opzioni che descrivi" e nessuna catena di ragionamento.
  • Il numero complessivo è la media di questi due fatti e quindi non descrive niente. È la lezione più trasferibile di questa pagina, e non è specifica dei modelli decisionali: qualsiasi punteggio di testa è una media pesata su un mix di benchmark che non è il tuo mix.

La tabella dei videogiochi è quella onesta​

Jeff ha valutato anche il gioco zero-shot — 20 episodi ciascuno di Doom, Frogger e Pac-Man — e il risultato è abbastanza scomodo da rendere meritata la fiducia per averlo pubblicato:

ModelloDoom (uccisioni)Frogger (attraversamenti)Pac-Man (pallini / 98)
Casuale−0,05011,2
Bot a regole scritte a mano6,5510,2594,1
Jeff-0.8B6,5510,357,0
Jeff-2B−0,96,041,2

Il 2B è peggiore del 0,8B in tutti e tre i giochi, pur superandolo su ogni riga di benchmark. La lettura del README è che il modello più grande sia risultato più avverso al rischio. Qualunque sia la causa, il punto è l'accoppiata di quelle due tabelle: la posizione nei benchmark non ha predetto il comportamento dentro un loop. E il bot a regole scritte a mano vince ancora a Pac-Man di 37 punti — il promemoria che "un modello può farlo" e "un modello dovrebbe farlo" sono domande diverse.

Il precipizio di latenza di cui nessuno parla​

Latenza mediana per decisione, domande da ~200 token:

ModelloRTX PRO 6000Apple M4 Max (MLX)CPU (32 thread)
Jeff-0.8B22 ms28 ms463 ms
Jeff-2B24 ms60 ms708 ms
Jeff-Gemma4-E2B29 ms—1,0 s

Due cose da portarsi via:

  1. "Modello minuscolo" non significa "gira ovunque veloce". Lo stesso checkpoint da 0,8B fa 22 ms su GPU e 463 ms su 32 thread di CPU — un divario di 21x. Un modello decisionale è un modello decisionale solo alla latenza della GPU; su CPU è una chiamata API lenta che ti capita di ospitare. Se il piano era "spargere queste chiamate ovunque nel percorso della richiesta", la colonna CPU è il budget di quel piano.
  2. 2,5x i parametri costano 2 ms sulla GPU grande. 22 → 24 ms. A queste dimensioni un singolo forward pass su ~200 token è dominato dall'overhead e dalla banda di memoria, non dall'aritmetica, quindi su una scheda veloce il 2B è quasi gratis rispetto allo 0,8B — mentre sull'M4 Max lo stesso passo ti costa 2,1x (28 → 60 ms). Scegli il modello per target di deployment, non dal conteggio dei parametri.
Guided walkthrough1 of 6
  1. Installa con uv, scarica un checkpoint da Hugging Face, avvia il server. Vuoi il numero zero-shot sui TUOI dati prima di decidere che l'addestramento serve — l'esito più comune riportato dai professionisti è che lo zero-shot non è abbastanza buono, ed è molto più economico scoprirlo in venti minuti che dopo una run di addestramento.

Servi in locale un modello compatibile con Jev e mandagli una richiesta vera

# Apple silicon (MLX backend)
uv sync --no-default-groups --extra mac
uv run --no-default-groups hf download mstrasser/Jeff-Qwen3.5-0.8B --local-dir checkpoints/jeff-0.8b
JEFF_BACKEND=mlx JEFF_CHECKPOINT=checkpoints/jeff-0.8b PORT=8765 \
uv run --no-default-groups --extra mac jeff-serve

# Two independent questions, one request, one parallel pass
curl -s localhost:8765/v1/systemone -H 'content-type: application/json' -d '{
"model": "jeff-latest",
"state": "Refund request: the customer says the parcel arrived crushed and wants their money back.",
"questions": {
  "route": {"type": "choice", "instructions": "Which team should handle this?",
            "criteria": {"1": "Refunds and payments", "2": "Damaged or lost parcels", "3": "Account and login problems"}},
  "angry": {"type": "noul", "instructions": "Is the customer angry?"}
}
}'

La domanda scomoda: ti serve davvero un modello?​

La critica più tagliente nel thread di Hacker News non era che Jeff vada male. Era strutturale: se devi comunque fare il fine-tune sui tuoi dati etichettati, non hai comprato un classificatore zero-shot — hai comprato un modo un po' goffo di addestrare un classificatore, e il campo ne ha già di più economici.

I numeri in quel thread rendono ragionevole prenderla sul serio. Un commentatore ha riferito di aver testato lo 0,8B zero-shot sulla classificazione di annunci di lavoro trovandolo inutilizzabile, con il 2B che continuava a mancare categorie. Un altro ha riferito che semplici embedding più una testa di regressione logistica hanno raggiunto il 93,0% su BANKING77 con un modello circa 15x più piccolo dei modelli decisionali messi a confronto — contro la forma 87,4% di confidenza / 75,3% di accuratezza che il pilota indipendente su Jev aveva trovato sullo stesso dataset.

Quindi la tabella decisionale onesta:

SituazioneUsa
Poche etichette fisse, molti esempi, la latenza contaEmbedding + regressione logistica. Il più piccolo, il più veloce, si addestra in secondi. Batti questo prima di considerare qualunque altra cosa.
Le etichette cambiano spesso, o le domande sono scritte in prosa a ogni richiestaModello decisionale zero-shot — lo schema è l'interfaccia, che è il vero prodotto
Un solo dominio ad alto volume, hai le etichette, hai una GPU per un pomeriggioFine-tune. La run di Jeff sugli scacchi è passata da 15,5% a 55,8%; un fine-tune per la navigazione vocale su ~11.000 esempi è passato da 31,7% a 95,8% in meno di 30 minuti
Giudizi davvero difficili, multi-stepRagionamento — Jeeves, o un modello di frontiera dietro una cascata
Ti serve funzionante questo pomeriggio e il volume è bassoAPI hosted. Neanche la tua GPU è gratis

La regola generale sotto a tutto: un modello decisionale si guadagna il posto quando la parte di valore è lo schema — domande tipizzate arbitrarie, in prosa, risolte in un solo passaggio. Quando il tuo insieme di etichette è fisso e noto, stai pagando costi da modello per un lavoro da classificatore.

Jeeves: rimettere dentro il ragionamento​

La tesi fondativa di Jev era che questa classe di modelli non genera testo. Jeeves di PostHog mette alla prova quella premessa direttamente, lasciando pensare un modello decisionale prima di decidere, su Qwen3.5-9B con LoRA r=16 e una pointer head.

L'addestramento procede in tre fasi: SFT (19.126 domande da 12 dataset pubblici più dati sintetici di policy, metà con catene di ragionamento, 2 epoche / 596 step su 8 GPU), poi reinforcement learning CISPO (9.992 domande, 8 rollout ciascuna a temperatura 1, pensiero limitato a 2.560 token — uno schedule da 624 step fermato deliberatamente allo step 402 perché la calibrazione peggiorava oltre quel punto), poi la stessa calibrazione scalare della temperatura.

Risultati dichiarati:

BenchmarkJeevesJevKev-9B
Test complessivo0,8890,8570,822
JevBench complessivo (231 item)0,9350,8660,715
JevBench difficile (111 item)0,8650,7300,451

E l'ablazione che conta più di tutte quelle righe: 0,804 senza ragionamento, 0,840 con. Pensare vale circa 3,6 punti su questo modello.

Ora mettici un prezzo. Su una H100, Jeeves risponde in ~0,3 s con il ragionamento spento e 3,3 s mediani con quello acceso — 17,1 s al p90. Sono circa 11x la latenza mediana e una coda peggiore di un ordine di grandezza, per 3,6 punti. La mitigazione proposta dal README è l'ingegneria interessante: limitare il pensiero a 2.560 token e aggiungere una soglia di confidenza a 0,9 che si ferma in anticipo quando il modello è già sicuro, il che porta la mediana a 2,0 s. Il ragionamento diventa qualcosa che spendi solo sugli item che ne hanno bisogno.

Due avvertenze che Jeeves pubblica su se stesso: è peggiore di Jev sui compiti a forte contenuto di conoscenza (MMLU 0,793 contro 0,900) — il ragionamento non aggiunge fatti — e le sue catene di ragionamento non sono mai state premiate per coerenza linguistica, quindi non sono leggibili in modo affidabile. Se volevi la catena come traccia di audit, verifica che sia leggibile prima di prometterlo a qualcuno.

Trappole che ti costeranno una giornata​

  • La coerenza della formulazione conta più della sua qualità. Jeff riporta che gli attraversamenti di Frogger sono passati da 15 a 23 semplicemente formulando ogni opzione nello stesso modo delle sue sorelle. Le opzioni vengono confrontate fra loro in un solo passaggio — una formulazione asimmetrica è un pollice sulla bilancia. Tieni le chiavi corte e metti la descrizione nel testo.
  • I formati di prompt non si trasferiscono fra modelli decisionali. Lo stile "numero di rilevamento" di Jev non si è trasferito a Jeff; è servita invece una formulazione centrata sulle conseguenze. Tratta un cambio di modello decisionale come un lavoro di ri-tuning, esattamente come portare i prompt da un modello all'altro.
  • Il tetto delle 26 opzioni è silenzioso. Niente va in errore. Le opzioni dalla 27ª in poi semplicemente non vincono mai. Spezza gli insiemi di etichette grandi in una decisione a due stadi.
  • Solo inglese, solo testo per Jeff. AutoJev accetta immagini in base64; Jeff no.
  • La qualità zero-shot dipende dal carico di lavoro ed è spesso deludente. Più professionisti hanno riportato che i modelli piccoli erano inutilizzabili sui loro veri compiti di classificazione. Misura sui tuoi dati dal primo giorno.
  • Filtrare le fughe di dati di addestramento è compito tuo. Jeff genera dati sintetici in locale con filtraggio delle fughe proprio perché un modello decisionale addestrato vicino al suo pannello di valutazione produce un numero che non significa nulla.
  • Entrambi i repo hanno pochi giorni. Flag, nomi dei checkpoint e default si stanno muovendo. Niente qui sostituisce il README attuale.
Vocabolario dei modelli decisionali fai-da-te
Premi Invio o Spazio per girare la carta. Usa le frecce sinistra e destra per spostarti tra le carte.Termine mostrato.
1 / 8

Check yourself

0/5
  1. Jeff-0.8B totalizza 96,4% su Financial PhraseBank contro il 77,0% di Jev, ma 64,0% su BBH contro il 94,3% di Jev. Qual è la conclusione corretta?
  2. Perché Jeff ti limita a 26 opzioni per domanda?
  3. Il tuo modello decisionale fine-tuned raggiunge l'88% di accuratezza sul tuo dev set. Cosa resta da fare prima di lasciargli saltare la revisione umana?
  4. Jeeves riporta 0,804 di accuratezza con il ragionamento spento e 0,840 con quello acceso, a 0,3 s contro 3,3 s mediani (17,1 s al p90). Qual è la conclusione ingegneristica?
  5. Prima di addestrare un tuo modello decisionale su un insieme fisso di etichette, quale baseline dovresti misurare per prima?

Fonti e approfondimenti​

Prossimi passi​