Jev, l'AI che decide senza scrivere: l'ho messa alla prova contro GPT

Da quando è arrivato ChatGPT, i modelli di cui tutti parlano sono chatbot: gli fai una domanda e ti rispondono scrivendo. Il 15 settembre è uscito il primo della sua specie che non lo è. Si chiama Jev, l'ha costruito TypeSafe AI e non sa scrivere nemmeno una parola: prende decisioni, e accanto a ciascuna ti dice quanto è sicuro. Chi l'ha creato promette un flusso 193 volte più veloce di un LLM di punta. Una promessa così andava verificata, e l'ho fatto: 105 email di clienti di un gestionale, sei modelli, due lingue, e un confronto solo tra modelli che sbagliano quanto lui. Qui trovi com'è andata, con il metodo, le tabelle e il codice Delphi.

Se hai messo un LLM dentro un gestionale, prima o poi l’hai usato per una decisione piccola: a quale ufficio va questa email, che tipo di documento è arrivato, se il cliente è arrabbiato. Funziona. Però ogni decisione costa un secondo o due e dei token in uscita, e su diecimila email al giorno il tempo e il conto diventano il problema.

Il 15 settembre TypeSafe AI ha presentato Jev, un modello che non sa scrivere una parola e restituisce solo decisioni. Sulla home page dichiarano un flusso 193,6 volte più veloce e 444,6 volte più economico di un LLM di punta. Ne ho parlato nella puntata 7 del podcast “while true do;”, dove avevo promesso di pubblicare qui il metodo, le tabelle e il codice Delphi.

Cos’è Jev

Gli passi un contesto, che TypeSafe chiama state (il testo di una email, un record), e delle domande tipizzate. I tipi sono tre:

• choice: scegli una fra fino a 255 opzioni, ognuna descritta a parole;
• score: colloca il testo su una scala da 2 a 10 livelli;
• noul: una domanda sì o no, e la risposta è la probabilità del sì.

Per ogni domanda ricevi l’opzione scelta, la distribuzione di probabilità su tutte le opzioni e una confidenza, senza testo da interpretare. Jev calcola tutte le domande in un solo passaggio, quindi aggiungerne una cambia poco il tempo di risposta. Il listino è 0,042 dollari per milione di token in ingresso, e l’uscita non si paga.

Dal 18 settembre Jev è anche su OpenRouter, all’endpoint POST /api/v1/systemone. Io ho usato questo: con una chiave sola chiami sia Jev sia gli LLM di confronto, e tutti i tempi comprendono lo stesso passaggio da OpenRouter.

Chiamarlo da Delphi

La chiamata è una POST con un JSON, quindi bastano THTTPClient e System.JSON e non serve un SDK. Questa è la richiesta di JevTriage, il programma dimostrativo: tre domande su una email, una per tipo.

// Le tre domande a Jev: reparto (choice), frustrazione (score), urgenza (noul).
function BuildJevRequest(const AModel, AEmail: string): string;
begin
  var lRoot := TJSONObject.Create;
  try
    lRoot.AddPair('model', AModel);
    lRoot.AddPair('state', AEmail);
    var lQuestions := TJSONObject.Create;
    lRoot.AddPair('questions', lQuestions);   // da qui lo possiede lRoot

    var lDepartments := TJSONObject.Create;
    lDepartments.AddPair('amministrazione', 'Fatture, pagamenti, addebiti, rimborsi');
    lDepartments.AddPair('assistenza tecnica', 'Errori, blocchi e malfunzionamenti del programma');
    lDepartments.AddPair('commerciale', 'Preventivi, nuovi moduli, licenze, formazione');
    lDepartments.AddPair('altro', 'Nessuna delle precedenti');   // l'opzione di ripiego va sempre messa
    lQuestions.AddPair('reparto', TJSONObject.Create
      .AddPair('type', 'choice')
      .AddPair('instructions', 'Quale reparto deve gestire questa email?')
      .AddPair('criteria', lDepartments));

    var lLevels := TJSONArray.Create;
    lLevels.Add('Calmo, espone i fatti');
    lLevels.Add('Infastidito ma cortese');
    lLevels.Add('Molto arrabbiato, toni forti');
    lQuestions.AddPair('frustrazione', TJSONObject.Create
      .AddPair('type', 'score')
      .AddPair('instructions', 'Quanto è frustrato il cliente?')
      .AddPair('criteria', lLevels));

    lQuestions.AddPair('urgente', TJSONObject.Create
      .AddPair('type', 'noul')
      .AddPair('instructions', 'La richiesta è urgente o ha una scadenza ravvicinata?'));

    Result := lRoot.ToJSON;
  finally
    lRoot.Free;
  end;
end;

Le chiavi e le descrizioni sono in italiano di proposito: le email arrivano in italiano, e volevo vedere Jev nella lingua in cui lo userebbe una software house italiana. Se lavori con System.JSON e vuoi ripassare l’API fluente e chi possiede cosa, c’è la guida completa a JSON in Delphi.

La risposta si legge con GetValue<T> e un percorso: answers.reparto.choice, answers.reparto.confidence, answers.urgente.noul. Poi è il codice a decidere l’instradamento, confrontando la confidenza con due soglie:

// Il routing lo decide il codice, non il modello: la confidenza è solo un numero da confrontare.
function RouteByConfidence(const ADepartment: string; AConfidence: Double): string;
begin
  if (ADepartment = 'altro') or (AConfidence < HUMAN_THRESHOLD) then
    Result := 'a un operatore (decide una persona)'
  else if AConfidence >= AUTO_THRESHOLD then
    Result := Format('automatico a "%s"', [ADepartment])
  else
    Result := Format('a "%s" con cautela (serve una conferma)', [ADepartment]);
end;

AUTO_THRESHOLD vale 0,85 e HUMAN_THRESHOLD 0,5. Più sotto vedrai che 0,85 è ottimista.

Quattro email, un’esecuzione vera

JevTriage manda le stesse quattro email a Jev e a google/gemini-2.5-flash-lite, al quale chiede di scrivere un JSON con gli stessi tre campi. Questo è l’output di un’esecuzione di oggi, intero:

Email 1: "Buongiorno, questo mese ci avete addebitato due volte il canone del gestionale sulla carta aziendale. Potete stornare il secondo addebito? Grazie, Marta Rossi"
  Jev (typesafe/jev-1.13-20260917) in 324 ms
    reparto:      amministrazione  (confidenza 1,00)
                  assistenza tecnica=0,00  commerciale=0,00  amministrazione=1,00  altro=0,00  
    frustrazione: 0,09 su 2  (confidenza 0,87)
                  0=0,91  1=0,09  2=0,00  
    urgente:      no  (probabilità del sì 0,21)
    instradamento: automatico a "amministrazione"
  LLM (google/gemini-2.5-flash-lite) in 500 ms
    reparto: amministrazione, frustrazione: 1, urgente: true  (nessuna probabilità, nessuna confidenza)

Email 2: "Da stamattina quando stampo una fattura il programma si chiude con un errore di accesso in memoria. Ho quaranta fatture da mandare entro stasera, non so più cosa fare!!!"
  Jev (typesafe/jev-1.13-20260917) in 342 ms
    reparto:      assistenza tecnica  (confidenza 1,00)
                  assistenza tecnica=1,00  commerciale=0,00  amministrazione=0,00  altro=0,00  
    frustrazione: 1,90 su 2  (confidenza 0,85)
                  0=0,00  1=0,09  2=0,91  
    urgente:      sì  (probabilità del sì 0,98)
    instradamento: automatico a "assistenza tecnica"
  LLM (google/gemini-2.5-flash-lite) in 415 ms
    reparto: assistenza tecnica, frustrazione: 2, urgente: true  (nessuna probabilità, nessuna confidenza)

Email 3: "Salve, siamo uno studio con dodici postazioni e vorremmo un preventivo per il modulo magazzino e per la formazione del personale. Nessuna fretta."
  Jev (typesafe/jev-1.13-20260917) in 309 ms
    reparto:      commerciale  (confidenza 1,00)
                  commerciale=1,00  altro=0,00  amministrazione=0,00  assistenza tecnica=0,00  
    frustrazione: 0,00 su 2  (confidenza 1,00)
                  0=1,00  1=0,00  2=0,00  
    urgente:      no  (probabilità del sì 0,04)
    instradamento: automatico a "commerciale"
  LLM (google/gemini-2.5-flash-lite) in 526 ms
    reparto: commerciale, frustrazione: 0, urgente: false  (nessuna probabilità, nessuna confidenza)

Email 4: "Ciao, volevo solo dirvi che il corso di ieri è stato molto utile. A presto!"
  Jev (typesafe/jev-1.13-20260917) in 353 ms
    reparto:      altro  (confidenza 0,62)
                  assistenza tecnica=0,00  commerciale=0,28  altro=0,72  amministrazione=0,00  
    frustrazione: 0,00 su 2  (confidenza 1,00)
                  0=1,00  1=0,00  2=0,00  
    urgente:      no  (probabilità del sì 0,03)
    instradamento: a un operatore (decide una persona)
  LLM (google/gemini-2.5-flash-lite) in 632 ms
    risposta non interpretabile: {"

Email   Jev ms   LLM ms   Jev token in/out   LLM token in/out   Jev costo      LLM costo
    1      324      500         510 / 93            138 / 23    $0,0000214     $0,0000230
    2      342      415         511 / 93            142 / 24    $0,0000215     $0,0000238
    3      309      526         505 / 92            134 / 23    $0,0000212     $0,0000226
    4      353      632         488 / 91              0 / 0     $0,0000205     $0,0000000
 Tot.     1328     2073                                        $0,0000846     $0,0000694

I costi vengono dal campo usage.cost di OpenRouter (in crediti, 1 credito = 1 USD).
I tempi includono il passaggio da OpenRouter.

La prima email è un doppio addebito scritto con calma. Per Flash Lite il cliente è infastidito e la richiesta è urgente. Jev dice calmo e non urgente, e lo dice con le probabilità accanto.

La quarta email è un ringraziamento. Flash Lite ha risposto {" e si è fermato lì: un JSON aperto e mai chiuso, zero token contati e quindi costo zero, ma anche nessuna risposta da usare. Jev invece mette altro con confidenza 0,62, e il codice passa la mail a una persona, perché ogni altro va a un operatore qualunque sia la confidenza.

Sul costo, con tre domande Jev costa quanto Flash Lite, anzi un filo di più: la richiesta a Jev conta circa 500 token in ingresso, quella all’LLM 140. Il vantaggio di prezzo di Jev sta nell’uscita gratuita, e con tre risposte brevi c’è poca uscita da risparmiare. Quattro email però non dimostrano niente, e Flash Lite è il modello più economico della lista: per questo ho scritto JevBench.

Il benchmark: 105 email, sei modelli

Il benchmark fa lo stesso lavoro in grande, con queste regole:

• 105 email di clienti di una software house di gestionali: doppi addebiti, fatture scartate dallo SDI, cedolini che non si calcolano, preventivi, disdette, spam, phishing. 61 sono difficili di proposito: sarcasmo, frustrazione trattenuta, negazioni (“non è urgente, però entro domani mattina…”), una richiesta scritta nel PS di una newsletter;
• 25 domande per email (reparto, modulo del gestionale, frustrazione, urgenza, richiesta di rimborso, minaccia di andarsene, dati sensibili, e così via), fatte a gruppi di 3, 10 e 25 per chiamata;
• sei modelli via OpenRouter: Jev 1.13, Gemini 2.5 Flash Lite, GPT-5.6 Luna, GPT-5.6 Terra, Gemini 3.1 Pro, DeepSeek V4 Pro. A tutti ho dato le stesse istruzioni, senza lavorare sul prompt;
• l’accuratezza bilanciata come metrica principale, con intervalli di confidenza al 95% da bootstrap. L’accuratezza semplice premia chi risponde sempre “no”: qui un modello che dice sempre la classe più frequente farebbe 84% di accuratezza semplice e 41% di bilanciata;
• prima la qualità, poi i tempi: confronto velocità e costo solo fra Jev e l’LLM più economico che sbaglia quanto lui, o meno. Un modello dieci volte più economico che sbaglia una email su tre non lo puoi usare al posto di Jev.

Non c’è nessun modello Anthropic, e non per antipatia: le risposte attese le ha scritte e riviste Claude Opus 5, e un modello della stessa famiglia partirebbe avvantaggiato sui casi dubbi. Le regole per etichettare le ho fissate io, e ho deciso io il caso più discusso; gli altri casi contesi li ha decisi lo stesso modello su mio mandato, e nessuno ha ricontrollato a mano tutte le etichette.

Il test principale è in inglese, perché TypeSafe dichiara che Jev rende meglio in inglese e non volevo metterlo nella condizione peggiore senza dirlo. Poi l’ho rifatto in italiano.

Chi capisce di più

Ogni cella dice quanto ha capito un modello sulle 105 email in inglese, con quel numero di domande per chiamata. Le colonne non sono tre prove della stessa cosa: “3 decisioni” sono le prime tre domande (reparto, frustrazione, urgenza), “10” le prime dieci, “25” tutte. Ogni colonna aggiunge domande nuove, e alcune sono più difficili, per questo Jev scende da 97,2 a 94,8: con 25 entra anche l’impatto del problema sul cliente, dove si ferma al 68%.

Il numero è l’accuratezza bilanciata, in percentuale. Per ogni domanda si guarda ogni risposta possibile a parte: per “urgente” conta quante email urgenti il modello ha riconosciuto come urgenti e quante non urgenti come non urgenti, e si fa la media delle due. Poi si fa la media su tutte le domande. Così una risposta rara pesa quanto una frequente. Un modello che risponde sempre “no” a “urgente” azzecca 88 email su 105, ma qui prende 50. Rispondere sempre con la risposta più frequente a ogni domanda vale 34,4 con 3 decisioni, 39,4 con 10 e 41,4 con 25: è il punto zero da cui partire per leggere la tabella.

Fra parentesi quadre c’è l’intervallo di confidenza al 95%. L’ho calcolato ripescando a caso 2.000 volte le 105 email (bootstrap): con un altro campione di email simili, il risultato cadrebbe quasi sempre lì dentro. Più l’intervallo è largo, meno il numero è preciso, e con 3 domande è largo perché ogni errore pesa di più. Per dire se un LLM è migliore o peggiore di Jev però non basta guardare se gli intervalli si sovrappongono: ho confrontato i due modelli email per email, sugli stessi ricampionamenti, e contano solo le differenze che restano lontane dallo zero.

Con 3 e con 10 decisioni per chiamata nessun LLM fa meglio di Jev in modo distinguibile. Con 25 lo supera solo Gemini 3.1 Pro, di 2,3 punti [0,9; 3,7]. Flash Lite è peggiore a tutti i livelli, quindi gli errori sulle quattro email di prima non erano un caso.

Nessun modello ha restituito un JSON rotto nelle 2.835 chiamate del benchmark, 1.890 in inglese e 945 in italiano. Il {" della demo, una chiamata su quattro, resta un episodio isolato. Con i modelli di oggi l’errore di schema è raro, quindi per scegliere Jev servono altri motivi.

Quanto è più veloce, quanto costa meno

Jev risponde in circa un terzo di secondo e ci mette lo stesso tempo con 3 domande o con 25: 320, 341 e 337 ms di media. Gli LLM invece devono scrivere ogni risposta, e rallentano: GPT-5.6 Terra passa da 1.397 a 2.338 ms, Gemini 3.1 Pro da 4.625 a 7.151.

Questa tabella, in inglese, confronta Jev con l’LLM più economico che a ogni livello ha un’accuratezza equivalente alla sua:

Il rapporto di costo l’ho calcolato sui listini di OpenRouter di oggi, quindi cambia appena cambia un prezzo. I tempi comprendono il passaggio da OpenRouter, che da qui costa fra i 20 e i 30 ms di andata e ritorno (mediana di 20 ms nel test in inglese, 28 in quello in italiano).

Se invece confronti Jev con un modello di punta, i numeri crescono. Mille email con 25 domande costano 0,08 dollari con Jev, 2,17 con GPT-5.6 Terra e 11,82 con Gemini 3.1 Pro, che ci mette anche 21 volte il tempo di Jev. Ventuno volte resta lontano da 193, però si capisce da dove partono i numeri di TypeSafe: confrontano Jev con i modelli di punta.

In italiano

In italiano ho rifatto il test con Jev e i due modelli di OpenAI:

La qualità di Jev resta quella dell’inglese. L’unica differenza distinguibile è a 3 decisioni, 1,9 punti [0,6; 3,7]. Gli LLM invece in italiano rallentano, perché la stessa email richiede più token: a 25 decisioni GPT-5.6 Luna passa da 1.886 a 2.864 ms, mentre Jev va da 337 a 348.

Le email inglesi sono una traduzione, fatta da un LLM, di originali italiani scritti da un LLM. Una differenza fra le lingue può venire anche dalla traduzione. Lo script build_en.py controlla che ogni email tradotta mantenga le risposte attese dell’originale, ma non può controllare lo stile.

La confidenza: “non può allucinare”?

TypeSafe dice che Jev non può allucinare. Vale per la forma: non ti restituisce un campo che non hai chiesto o un’opzione che non esiste. L’errore di giudizio invece resta. Se gli chiedi qualcosa che il testo non dice, non può rispondere “non lo so”: distribuisce la probabilità sulle opzioni che gli hai dato e ne sceglie una. Per questo l’opzione altro nel codice sopra non è facoltativa.

Per difenderti hai la confidenza. Nella tabella ci sono le risposte choice e score di Jev, a 25 decisioni, raggruppate per confidenza dichiarata:

(Il numero di risposte e la confidenza media sono quelli dell’esecuzione in inglese.)

Sopra 0,95 la confidenza regge. Nel mezzo Jev è ottimista: quando dice 0,90 ha ragione poco più di tre volte su quattro. La confidenza sale insieme alla precisione, quindi serve, ma la soglia devi misurarla sui tuoi dati. Con questi numeri, lo 0,85 di JevTriage manderebbe in automatico parecchie risposte sbagliate: nei miei dati la soglia sensata per agire senza conferma è 0,95.

Cosa non dimostra

Il test vale per un compito: email di clienti di un gestionale italiano, stesse istruzioni per tutti. Non dice come vanno i modelli su altri domini, cosa otterrebbero gli LLM con un prompt curato o qualche esempio, né quanto varia il risultato da un’esecuzione all’altra, perché c’è un’esecuzione sola. Ho sovrarappresentato di proposito le email difficili, quindi le percentuali assolute sono più basse di quelle che vedresti sul traffico vero. E le risposte attese le ha scritte un LLM, non un team di persone con un caffè e molta pazienza.

Prima ancora di provarlo devi decidere due cose. Oggi Jev è solo un’API in cloud, in accesso anticipato, senza pesi pubblicati e senza installazione on-premise: le email dei tuoi clienti escono dalla tua infrastruttura verso una startup uscita allo scoperto una settimana fa, dopo due anni di lavoro riservato. E la configurazione fissa typesafe/jev-1.13, non l’alias jev-latest, perché le soglie di confidenza valgono per una versione precisa.

Scaricarlo e provarlo

Il codice è qui: jev-delphi-demo.zip. Dentro ci sono JevTriage, JevBench, il dataset in italiano e in inglese, i risultati completi con i CSV e bench/METODOLOGIA.md, che spiega ogni scelta molto più per esteso di questo articolo.

Serve Delphi 13 (dovrebbe andare anche su 12 e 11, ma non l’ho provato), i sorgenti di DelphiMVCFramework per MVCFramework.DotEnv, che legge il file .env, e una chiave di OpenRouter con un po’ di credito. Copia .env.example in .env, metti la chiave e compila:

call "C:\Program Files (x86)\Embarcadero\Studio\37.0\bin\rsvars.bat"
msbuild JevTriage.dproj /p:Config=Debug /p:Platform=Win64
JevTriage.exe

JevTriage costa meno di un centesimo. Con sei modelli JevBench fa 1.890 chiamate per lingua e ci mette un’ora abbondante. Il test in inglese è costato circa 3,5 dollari, quello in italiano, con tre modelli e 945 chiamate, circa 0,9. Prima di lanciarlo prova JevBench.exe --selftest, che fa girare tutti i report su risultati inventati senza chiamare nessun modello. Qualunque argomento sconosciuto ferma il programma, così un errore di battitura non ti fa partire un’esecuzione a pagamento.

Per la parte “come la vedo io”, dove lo metterei in un gestionale e dove no, ascolta la puntata 7 di “while true do;”. Il paradosso di Jevons, da cui Jev prende il nome, è nelle puntate 4 e 5. La documentazione ufficiale di Jev è su docs.typesafe.ai.

Domande frequenti

Cos’è Jev di TypeSafe AI? Jev è un modello che TypeSafe AI chiama “System One”: non genera testo, ma riceve un contesto e delle domande tipizzate (choice, score, noul) e restituisce per ciascuna la risposta, la distribuzione di probabilità sulle opzioni e una confidenza. È stato presentato il 15 settembre 2026 e si usa via API, direttamente da TypeSafe o tramite OpenRouter.

Jev è davvero 200 volte più veloce di un LLM? Nel benchmark di Daniele Teti su 105 email di un gestionale, Jev è risultato da 4 a 8 volte più veloce dell’LLM più economico con la stessa accuratezza, e circa 20 volte più veloce di Gemini 3.1 Pro. I numeri da 193 volte del produttore vengono da flussi scelti da TypeSafe e confrontano Jev con modelli di punta.

Jev sbaglia meno di GPT e Gemini? Con 3 e 10 decisioni per chiamata nessuno degli LLM provati supera Jev in accuratezza bilanciata. Con 25 decisioni solo Gemini 3.1 Pro è migliore, di circa 2 punti. Gemini 2.5 Flash Lite è peggiore a tutti i livelli.

La confidenza di Jev è affidabile? In alto sì: sopra 0,95 Jev ha avuto ragione nel 96,5% dei casi. Nella fascia intermedia è troppo ottimista: quando dichiara circa 0,90 ha ragione nel 77,6% dei casi. La soglia per passare un caso a una persona va quindi tarata sui propri dati.

Come si chiama Jev da Delphi? Con una POST JSON all’endpoint /api/v1/systemone di OpenRouter, usando THTTPClient e System.JSON della RTL. Il codice completo, con il benchmark, è scaricabile da danieleteti.it.

Chi ha scritto le risposte attese del benchmark? Le risposte attese le ha scritte e riviste Claude Opus 5. Daniele Teti ha fissato le regole e ha deciso il caso più discusso; gli altri casi contesi li ha decisi lo stesso modello su suo mandato, e nessuno ha ricontrollato a mano tutte le etichette. Per questo nel confronto non c’è nessun modello Anthropic.