Jev uitgelegd: hoe je snelle, getypeerde beslissingen toevoegt aan een AI-agent

Jev kun je het best zien als een beslissingslaag voor software. Het leest tekst of gestructureerde status en geeft vooraf gedefinieerde classificaties, scores en ja-of-nee-kansen terug. Het schrijft geen antwoord voor de gebruiker. Die smallere interface maakt het relevant voor routering met een hoog volume, triage, verificatie en guardrail-stappen binnen AI-agents.

Het praktische patroon is eenvoudig: laat Jev frequente, omkeerbare oordelen vellen; laat bedrijfscode het beleid afdwingen; stuur onzekere of gevolgrijke gevallen door naar een capabel LLM of een mens.

Als Jev nieuw voor je is, is de kortste uitleg deze: Jev is een recent uitgebracht AI-beslissingsmodel van TypeSafe AI dat zich meer gedraagt als een semantische if-statement dan als een chatbot. Je levert context en een vaste set vragen; het geeft getypeerde keuzes, scores en kansen terug die applicatiecode meteen kan gebruiken.

Wat is Jev?

TypeSafe AI noemt Jev zijn eerste System One Model en leent de "snelle" kant van het onderscheid tussen System 1 en System 2. Een verzoek levert programmastatus en getypeerde vragen aan. Jev evalueert de vragen parallel en geeft kansen en betrouwbaarheidswaarden terug die software direct kan gebruiken.

De beschikbare vraagtypen zijn:

1. Noul voor de kans dat een ja-of-nee-bewering waar is.
2. Choice voor het kiezen uit vooraf gedefinieerde opties, met een kansverdeling en betrouwbaarheid.
3. Score voor het beoordelen van geordende niveaus, met een score, onderliggende verdeling en betrouwbaarheid.

Anders dan een autoregressief LLM genereert Jev geen willekeurige strings. TypeSafe stelt dat dit schemamatching garandeert: het antwoord kan geen veld verzinnen en niet het verkeerde datatype teruggeven. Het kan wel de verkeerde geldige keuze maken, dus typeveiligheid mag niet worden gepresenteerd als semantische onfeilbaarheid.

Waar past Jev in een agentarchitectuur?

Gebruik Jev tussen statuswijzigingen, wanneer het systeem een beperkt oordeel nodig heeft:

User or tool result
    -> Jev: classify, score, route, or check risk
        -> application policy
            -> execute a low-risk action
            -> call an LLM for reasoning or language
            -> request human review

Dit vult een LLM aan. Het LLM behandelt open redeneringen, uitleg en gegenereerde inhoud. Jev behandelt herhaalde vragen waarvan de mogelijke antwoorden vooraf bekend zijn.

Kies de juiste laag voor elke taak

Jev is het makkelijkst te begrijpen als één onderdeel in een groter automatiseringsstack:

Deze verdeling is het productidee achter Jev: het model beslist niet alles en hoeft ook niet alles te zeggen. Het zet vage semantische context om in een getypeerd probabilistisch signaal, terwijl het omliggende systeem verantwoordelijk blijft voor beleid en actie.

Stap 1: kies de juiste eerste workflow

Begin met een bestaande beslissing met een hoog volume die al een LLM plus gestructureerde output gebruikt. Goede kandidaten zijn ticketrouting voor support, kwaliteitscontroles van content, beoordeling van agent-traces, documenttriage en modelselectie.

Begin niet met een beslissing die onomkeerbaar of juridisch gevoelig is, of die zo waardevol is dat maximale nauwkeurigheid belangrijker is dan latentie en kosten. Vermijd ook taken die natuurlijketaaloutput of een controleerbare uitleg vereisen: Jev geeft beslissingen en kansen, geen redeneringsverhaal.

Stap 2: definieer de status en de vragen

Laat de status het bewijs bevatten dat voor de beslissing nodig is, maar houd het beleid in de applicatiecode. Splits een brede aanvraag waar mogelijk op in onafhankelijke vragen.

Voor een supportworkflow kan één verzoek vragen:

• Welke wachtrij moet het ticket ontvangen?
• Hoe ernstig is het probleem?
• Wijst het bericht op misbruik?
• Is menselijke beoordeling nodig?

Voeg unknown of none_of_the_above toe wanneer je optielijst mogelijk niet elk echt geval dekt. Zonder een ontsnappingsroute moet een gesloten classificator een geldig maar mogelijk misleidend label kiezen.

Stap 3: roep Jev aan via LangChain

Installeer de integratie en geef de API-sleutel door via je omgeving of secret manager:

pip install langchain-typesafe
export TYPESAFE_API_KEY="your-api-key"

Maak daarna een getypeerde vraag aan:

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke(
    state=(
        "The deploy failed twice and customers are seeing 500s. "
        "Can someone look now?"
    ),
    questions={
        "urgent": Noul(
            instructions="Does this need attention right now?"
        ),
    },
)

urgency = response.nouls["urgent"].noul

Het resultaat is een kans die je beleid met een drempelwaarde kan vergelijken. Het is op zichzelf geen instructie om uit te voeren.

Stap 4: bouw een escalatiebeleid

Gebruik meerdere niveaus in plaats van één universele grens:

high confidence + low consequence -> automatic action
medium confidence                -> LLM verification
low confidence                   -> human review
high consequence at any score    -> stronger control or approval

Stel drempels per actie in. Het automatisch toewijzen van een ticketlabel en het automatisch goedkeuren van een betaling mogen niet hetzelfde risicobeleid delen alleen omdat beide kansen gebruiken.

Stap 5: gebruik routering en guardrails zorgvuldig

LangChains experimentele ModelRouterMiddleware kan Jev gebruiken om eenvoudig werk naar een snel model te sturen en complex of belangrijk werk naar een capabeler model. Dit kan het gebruik van het volledige model verminderen zonder elk verzoek via de goedkoopste optie te laten lopen.

De experimentele AutoModeMiddleware past Jev toe op risicocontroles van tool-calls en kan een voorgestelde call blokkeren voordat die wordt uitgevoerd. Houd deterministische controles rond gevoelige tools aan: allowlists, sandboxing, beperkte credentials, rate limits en menselijke goedkeuring blijven nodig, omdat een classificator false negatives kan produceren.

Stap 6: evalueer met je eigen data

TypeSafe rapporteert 70–500 ms end-to-end latentie, $0.042 per miljoen input-tokens en output zonder aparte kosten. In zijn vier workflow-evaluaties meldt het dat Jev gemiddeld 67.8% overeenstemming haalt met referentiekansen, tegen ongeveer $0.0004 en 0.4 seconden per sample. Hetzelfde testraamwerk geeft 67.9% voor GPT-5.6 Terra tegen $0.0304 en 10.1 seconden, en 74.1% voor GPT-5.6 Sol tegen $0.0836 en 23.3 seconden.

Dit zijn door de leverancier gepubliceerde resultaten, geen universele voorspelling. De referentie is het gemiddelde van de voorspellingen van GPT-6 Astra en Fable 5.1, en niet door mensen gelabelde waarheid. TypeSafe wijst op mogelijke bias van de workflowauteurs en stelt dat de grootste snelheids- en kostenwinsten die in de kop staan, waarschijnlijk aan de bovenkant van de verbeteringen in de praktijk liggen.

Vergelijk Jev voordat je het in productie neemt, waar mogelijk met je huidige LLM, eenvoudige regels en een domeinspecifiek model. Meet:

• Nauwkeurigheid, precisie en recall per klasse.
• Kalibratie en het percentage zelfverzekerde fouten.
• Het percentage waarin het systeem afziet en escaleert.
• p50-, p95- en p99-latentie vanuit je deploymentregio.
• De end-to-end kosten van de volledige cascade, inclusief fallbacks.
• Prestaties bij distributieverschuivingen en adversariële inputs.

Stap 7: voeg operationele veiligheidsmaatregelen toe

Productiegereedheid vereist meer dan modelkwaliteit:

• Log de statusversie, het vraagschema, de kans, de betrouwbaarheid, de gekozen tak en de latere uitkomst.
• Versioneer prompts of vraaginstructies en beslissingsdrempels.
• Voeg timeouts, begrensde retries, circuit breakers en een deterministische fallback toe.
• Beoordeel fouten met hoge betrouwbaarheid apart; dat zijn de gevaarlijkste automatiseringsfouten.
• Houd drift in de gaten en kalibreer drempels opnieuw wanneer de inputpopulatie verandert.
• Houd onomkeerbare of gereguleerde acties achter sterkere technische en menselijke controles.

Openbaar materiaal maakt op dit moment het aantal parameters van Jev, de gedetailleerde architectuur, het RLCD-beloningsontwerp, standaard kalibratiecurves, de productie-SLA en de p95/p99-servicelatentie niet bekend. Die hiaten moeten evaluatievragen worden, geen aannames.

Wanneer moet je Jev niet gebruiken?

Gebruik Jev niet als primair model wanneer je gesprek, samenvatting, codegeneratie, gedetailleerde uitleg of redenering over een lange horizon nodig hebt. Het is ook een slechte enige beslisser voor processen met hoge inzet die een controleerbare onderbouwing vereisen. In een vast domein kan een conventionele kleine classificator of een gespecialiseerde reranker nauwkeuriger, goedkoper om te beheren of makkelijker te valideren zijn.

Veelgestelde vragen

Is Jev een LLM?

Niet in de conventionele zin van een chatmodel. Het verwerkt tekstuele of gestructureerde status, maar geeft vooraf gedefinieerde beslissingstypen terug in plaats van gegenereerde tekst.

Betekent "geen hallucinatie" dat Jev niet fout kan zitten?

Nee. De vorm van de output kan gegarandeerd zijn, terwijl het gekozen antwoord semantisch onjuist is. Lees de claim als bescherming tegen schema- en typefouten.

Vervangt Jev het model dat een agent aandrijft?

Meestal niet. Het is beter te zien als aanvulling: Jev voor snelle gestructureerde beslissingen, een LLM voor redenering en taal, en code of mensen voor het afdwingen van beleid.

Wat is RLCD?

TypeSafe duidt het aan als Reinforcement Learning for Calibrated Decisions, bedoeld om de gerapporteerde kans af te stemmen op de waargenomen correctheid. De openbare bronnen geven nog niet genoeg trainingsdetails of standaard kalibratiebewijs voor een onafhankelijke technische audit.

Wat moet ik eerst prototypen?

Kies één classificatie met een hoog volume en omkeerbaarheid die al via een LLM loopt. Draai Jev in shadow mode, vergelijk de beslissingen met gelabelde uitkomsten en introduceer automatisering pas nadat drempels en fallbacks zijn gevalideerd.

Begin met één meetbare beslissing

Jev's sterkste propositie is niet "vervang elk LLM". Het is "stop met het betalen van een generatief model om beslissingen te produceren die al een bekende vorm hebben." Kies één tak in je agent-harness, definieer de acceptabele fout en het escalatiebeleid, en test dat met je eigen verkeer.

Gebruik de introductie van TypeSafe AI tot System One Models en Jev voor de oorspronkelijke modelclaims en kanttekeningen, en de gids van LangChain voor het bouwen van een harness met Jev voor de Python-integratie en middleware-patronen.

Begin met Jev via AIHubMix

AIHubMix heeft ondersteuning voor Jev toegevoegd, zodat ontwikkelaars op één plek toegang hebben tot het nieuwe beslissingsmodel, naast andere toonaangevende AI-modellen.

Bezoek AIHubMix om Jev uit te proberen en één bekende tak in je workflow om te zetten in een meetbaar experiment. Begin met een omkeerbare classificatie- of scoringstaak, definieer je succesdrempel en houd een LLM- of menselijke fallback klaar terwijl je de resultaten evalueert.