Jev – un nou clasificator AI

LLM-urile avansează într-un ritm incredibil, iar Jev este un pic diferit. Fiecare generație nouă devine mai capabilă, raționează mai bine și poate rezolva probleme care păreau imposibile doar cu câțiva ani în urmă.

Dar două blocaje rămân: sunt lente și sunt scumpe.

1. Ce este Jev?

Un robot nu poate aștepta câteva secunde înainte de fiecare decizie. Un sistem care analizează un flux live de date nu își poate permite să trimită fiecare eveniment printr-un model de raționament scump.

De obicei există un tradeoff: folosești un model mic și pierzi inteligență. Folosești un model de frontieră și câștigi capacitate, dar și latență și cost.

Diogo Almeida și echipa lui de la TypeSafe AI ar putea schimba asta.

Diogo a fost cercetător la OpenAI, unde a lucrat la metodele de urmărire a instrucțiunilor care au făcut ChatGPT posibil. A plecat de la OpenAI în 2024 și a dispărut în mod stealth timp de aproximativ doi ani.

Compania lui, TypeSafe AI, a introdus un model nou numit Jev, acum disponibil direct prin ei sau prin terți furnizori (de exemplu prin OpenRouter). Spre deosebire de un LLM, Jev nu generează text liber. Returnează decizii structurate — alegeri, scoruri și probabilități – pe care codul le poate acționa direct. LLM-urile pot face asta și ele, dar diferența de viteză și cost e uriașă.

TypeSafe raportează o execuție de 193,6 ori mai rapidă și un cost de 444,6 ori mai mic decât la LLM-uri în testele lor de workflow, deși câștigurile în alte aplicații pot fi mai mici.

Jev costă 0,042 $ / milion de tokeni de intrare. Cu alte cuvinte, 42 $ per miliard de tokeni. Output-ul e gratuit, iar TypeSafe raportează timpi de răspuns de 70 până la 500 de milisecunde (cel puțin cu servere în apropiere).

Deci e rapid și ieftin.

TypeSafe spune că performanța lui Jev pe sarcini de decizie structurată e comparabilă, în linii mari, cu GPT-5.6 Terra la setarea implicită de raționament. Asta sugerează că Jev e foarte capabil în ciuda latenței și costului redus.

2. Jev -un nou tip de model AI

Jev e primul din ceea ce TypeSafe numește System One Models. E proiectat pentru decizii, nu pentru generare de text arbitrar.

Îi dai context și definești ce vrei să afli. Poate alege între opțiuni, atribui scoruri sau estima probabilități. Deciziile sunt produse în paralel și returnate ca valori tipizate pe care software-ul tău le poate folosi direct.

Cealaltă piesă importantă e incertitudinea. TypeSafe antrenează Jev cu ceva numit Reinforcement Learning for Calibrated Decisions (RLCD), cu scopul de a face probabilitățile sale semnificative: dintre predicțiile cărora li s-a atribuit o probabilitate de 80%, aproximativ 80% ar trebui să se dovedească corecte.

Din experiența mea, să ceri unui LLM să scoată un scor sau o probabilitate îmi dă rar valori bine calibrate. De obicei numerele se adună în jurul câtorva valori pe care le folosește mai des. Cercetările au arătat și ele că modelele raportează adesea estimări supraîncrezătoare și că simplul prompting poate să nu fie suficient pentru o calibrare bună.

3. Cazuri de utilizare pentru Jev

Aplicațiile interesante nu sunt lucruri pe care un LLM nu le poate face. Sunt aplicații în care așteptarea de câteva secunde sau plata pentru milioane de apeluri de model face folosirea unui LLM impracticabilă.

TypeSafe deja demonstrează ideea de bază cu Jev jucând Doom la zece interogări pe secundă. Modelul primește starea de joc structurată și continuă să ia decizii în timp ce lumea se schimbă.

3.1. Utilizare computer și browser

Agenții de browser-use și computer-use observă de obicei un ecran, raționează, dau click și apoi repetă. Dată o vedere structurată a paginii sau a aplicației, Jev ar putea alege acțiuni și verifica rezultatele lor mult mai rapid și mai ieftin.

Asta ar putea fi util pentru testare QA, navigarea pe site-uri pentru a găsi informații specifice, compararea listărilor de produse și monitorizarea paginilor pentru schimbări semnificative.

3.2. Interfețe în timp real

În loc să codezi un UI fix cu un LLM, software-ul ar putea alege continuu ce panouri, controale sau informații ar trebui să fie vizibile pentru utilizator. Renderer-ul rămâne determinist, în timp ce interfața se adaptează la ce se întâmplă.

json-render de la Vercel lasă AI-ul să genereze și să actualizeze interfețe în timp real din componente predefinite. Jev ar putea face acele actualizări mai rapid și mai ieftin, decidând ce componente să arate și cum să le aranjeze.

3.3. Robotică

Robotica poate fi una dintre cele mai evidente aplicații. Imaginile de la cameră și celelalte citiri de senzori ar putea fi convertite în stare structurată, permițând lui Jev să decidă repetat ce ar trebui să facă robotul în continuare. Jev ar putea selecta acțiuni precum deplasare înainte, viraj la stânga sau închiderea unui gripper, la fel cum selectează acțiuni din starea de joc structurată în demo-ul Doom.

La acest punct, răspunsurile de 70–500 ms contează enorm. Un robot care ia decizii de câteva ori pe secundă e foarte diferit de unul care așteaptă mai multe secunde după un LLM după fiecare acțiune.

3.4. Fluxuri de evenimente

Loguri, tranzacții, citiri de senzori industriali și evenimente de rețea pot sosi mult mai repede decât ai vrea vreodată să le trimiți individual printr-un model de frontieră.

Un model de decizie rapid ar putea sta direct în interiorul fluxului, transformând continuu evenimentele în scoruri și probabilități semantice. În loc să analizezi un eșantion după, ai putea inspecta fiecare eveniment și marca cazurile neobișnuite sau dificile pentru review.

3.5. Simulări și personaje de joc

Imaginează-ți o simulare de trafic, o economie virtuală, un lanț de aprovizionare sau o lume de joc cu mii de actori independenți.

Să dai fiecărui actor un LLM astăzi ar fi mult prea lent și scump. Dar dacă fiecare actor poate face ieftin decizii sensibile la context de câteva ori pe secundă, simulările pot deveni mult mai dinamice.

4. Laya – un Jev open source

Pentru că evident scandalurile nu lipsesc nici din domeniul AI, Jev pare a fi inspirat din studiile unui alt cercetător care acum a decis punerea pe piața a unui model AI numit Laya care promite că este mult mai performant ca Jev.

Laya este un clasificator format din 3 checkpointuri:

• o variantă în limba engleză;
• o variantă care acoperă peste 100 de limbi;
• o variantă optimizată pentru decizii din cadrul workflowurilor.

Laya se instalează simplu:

pip install laya

Am făcut un test cu un task de clasificare a conținutului unui email – una din problemele practice care încă ne răpește timpul. Laya trebuie să citească conținutul mailului de test dintr-un fișier și să stabileacă dacă acesta este de tip ofertă, spam, newsletter sau generic (neindeficiabil).

Pentru acest test vom folosi varianta multilanguange, iar conținutul analizat va fi în limba română.

+Subject: Ofertă limitată - 50% reducere!
+
+Bună,
+
+Ne bucurăm să vă anunțăm o ofertă exclusivă! Pentru următoarele 48 de ore
+primești 50% reducere la toate produsele din categoria de iarnă. Utilizează
+codul IARNA50 la finalizarea comenzii.
+
+Oferta se aplică doar pentru clienții noi. Cumperi acum, economisești mult!
+
+--
+Echipa de Marketing
+Promo.ro

Am folosit următorul cod python:

#!/usr/bin/env python
"""
Laya multilingual email classifier.

Reads the email content from `email.txt` and classifies it into one of:
    oferta   (offer / commercial promotion)
    spam     (unsolicited junk / bulk marketing)
    newsletter (periodic digest / informational publication)
    generic  (everything else: personal, transactional, support, ...)

Based on the laya repo docs (https://github.com/NandhaKishorM/laya):
  - Router: auto-detects script/language and picks the right checkpoint
    (English vs multilingual) before the forward pass.
  - `choice` primitive -> top label + per-option probabilities + confidence.
  - `noul` primitive  -> calibrated probability (used here as a spam cross-check).

Usage:
    python laya_email_classify.py [path/to/email.txt]
"""

import sys
from pathlib import Path

import laya
from laya import Router, email_state, clean_email_body


# The four categories the user asked for, with short criteria the model can match.
CATEGORIES = {
    "oferta": "a commercial offer, price promotion, discount, deal or product pitch",
    "spam": "unsolicited bulk marketing, junk, scam or phishing email",
    "newsletter": "a periodic digest, announcement or informational publication from a known sender",
    "generic": "any other email: personal message, support request, transactional receipt, notification",
}

# One `choice` question (the classification) + one `noul` spam cross-check.
QUESTIONS = {
    "category": {
        "type": "choice",
        "instructions": "Classify the email in `body` into exactly one category.",
        "criteria": CATEGORIES,
    },
    "is_spam": {
        "type": "noul",
        "instructions": "Is this email unsolicited spam or bulk marketing?",
    },
}


def classify_email(text: str) -> dict:
    """Run the laya Router over the email text and return a readable result."""
    # Preload both checkpoints so language switches cost nothing.
    # (For a one-shot script you can drop preload=True to save startup time.)
    router = Router(preload=True)

    # Build a clean state dict (strips signatures, quoted history, disclaimers).
    state = email_state(subject="", body=text, clean=True)

    result = router.predict(state, QUESTIONS)

    cat = result["answers"]["category"]
    spam = result["answers"]["is_spam"]

    return {
        "category": cat["choice"],
        "confidence": cat["confidence"],
        "probabilities": cat["probabilities"],
        "is_spam": spam["noul"],
        "routing": result.get("routing", {}),
    }


def main() -> None:
    path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("email.txt")
    if not path.exists():
        sys.exit(f"Email file not found: {path}")

    text = path.read_text(encoding="utf-8", errors="replace")
    if not text.strip():
        sys.exit("email.txt is empty.")

    res = classify_email(text)

    print("=" * 52)
    print("Laya email classification")
    print("=" * 52)
    print(f"Category    : {res['category']}")
    print(f"Confidence  : {res['confidence']:.2f}")
    print("Probabilities:")
    for label, p in sorted(res["probabilities"].items(), key=lambda kv: -kv[1]):
        bar = "#" * int(round(p * 30))
        print(f"  {label:<12} {p:6.3f}  {bar}")
    print(f"Is-spam P   : {res['is_spam']:.2f}")
    if res["routing"]:
        print(f"Routed to   : {res['routing'].get('model')} "
              f"({res['routing'].get('reason', '')})")
    print("=" * 52)


if __name__ == "__main__":
    main()

Mărimea modelului este de aproximativ 2.37 GB ceea ce îl face să se încadreze foarte bine în resursele VRAM ale plăcilor video generaliste, deci poate fi folosit cu succes și pe echipamente personale fără prea mari pretenții.

Am rulat codul pe 5 tipuri de conținut de email de teste – clasificate cu succes, cu un timp mediu de execuție de 500 ms (codul a rulat pe o placă RTX 3090).

5. Concluzie

Jev e un nou tip de AI construit pentru decizii structurate, rapide și ieftine, în interiorul sistemelor care rulează continuu. Asta l-ar putea face un candidat puternic pentru utilizarea computerului, robotică, procesarea de evenimente live, simulări mari și alte aplicații în care așteptarea de câteva secunde după un LLM după fiecare schimbare de stare e impracticabilă.

Dacă numerele TypeSafe se confirmă în afara propriilor evaluări, mă aștept ca acest tip de model să preia o mare parte din munca de decizie structurată deservită acum de LLM-uri. La 42 $ per miliard de tokeni de intrare și latență sub secundă, ai putea să-l conectezi la bucle de decizie potrivite care folosesc acum LLM-uri și să-ți reduci potențial factura.

Apoi mai e întrebarea scalării. Jev-ul actual atinge deja aproximativ calitatea de decizie Terra în testele TypeSafe. Comentariile lui Diogo despre versiuni mult mai mari sugerează că echipa țintește spre frontieră. Lucrurile ar putea deveni nebune.

Jev e cu siguranță unul dintre cele mai interesante lansări de AI pe care le-am văzut de ceva timp.