What Is Jev? A Decision Model That Picks Instead of Writing

Before you start#

This is an intermediate lesson. It goes faster if you already know these:

• What an LLM is, and that it writes text one token (a small piece of text) at a time. The lessons "What Is an LLM?" and "Tokens and Tokenization" cover it.
• Structured output: asking an LLM to answer as data with fixed fields, such as JSON, instead of free prose. A later lesson goes deep on it.
• A probability or confidence score: a number from 0 to 1 for how likely something is.
• Checking a model against labelled examples: answers you already know are right. The LLM Evals lessons, such as "LLM Eval Methods", show how an eval (a repeatable test of a model's answers) works.

Alex pays for a sentence to get one word#

Alex runs a small app for selling second-hand bikes. Every new listing needs two answers before it goes live: which category it belongs in (road, mountain, kids or parts), and whether it looks like a scam. Today an LLM answers. For a child seat for a rear rack, it writes: "This is a child seat that fits a rear rack, so the kids category fits best." Alex's code keeps one word, kids, and throws away the other fifteen. Alex pays for the whole sentence on every listing, and the seller waits for it.

So the question for this lesson: when should Alex stop asking a model to write, and ask it to pick instead? By the end you'll know what a decision model is, how to read its confidence score, and when to choose one over an LLM.

Think of a school exam. An essay answer is written word by word, and anything can end up on the page. A multiple-choice bubble sheet only has the printed options: you fill in one circle, and as you do, you know how sure you are. An LLM is the essay writer. This lesson is about the bubble sheet.

How a decision model works, in three steps#

1. Three things go in. A question ("Which category?"), the fixed list of allowed answers (road, mountain, kids, parts) and the text to decide on, the listing. Whatever happens, the answer is one of those options.
2. Every option is scored at once. Instead of writing tokens one after another, it gives each option a score. For the child seat, in this example: road 0.02, mountain 0.01, kids 0.94, parts 0.03.
3. The top option comes back with its score. Kids, at 0.94: that's the top option's score, which this lesson reads as how sure the model is. TypeSafe's API returns the option probabilities plus a separate confidence number (how far the top option stands out from the rest, not a probability itself), so check both on your own data. The model only answers; Alex's code decides. Alex's rule looks at the lower confidence of the two questions: at 0.9 or more the app acts (publish, or block a scam); under 0.9 a person checks the listing.

A model that picks from your list and tells you how sure it is is called a decision model. Jev, released by TypeSafe AI on 15 September 2026, is one. TypeSafe calls it a "System One" model, borrowing the psychology term for fast, gut-level judgement, as opposed to slow, step-by-step reasoning.

Six listings through a 0.9 threshold#

Here is Alex's rule on six listings. The answers are made up for this lesson, not real Jev output. The lower confidence column is the one the rule reads.

# decide() is a stand-in for a real decision model: it returns this
# lesson's made-up answers. No network, no real SDK.
ANSWERS = {
    "Carbon road bike, £850": [("road", 0.97), ("no", 0.95)],
    "Kids' 16-inch bike, £40": [("kids", 0.98), ("no", 0.97)],
    "New e-MTB £300, bank transfer only": [("mountain", 0.93), ("yes", 0.96)],
    "Pair of wheels, £120": [("parts", 0.94), ("no", 0.92)],
    "Vintage frame, price on WhatsApp": [("parts", 0.58), ("no", 0.71)],
    "Child seat for a rear rack, £35": [("kids", 0.94), ("no", 0.97)],
}
QUESTIONS = [
    ("Which category?", ["road", "mountain", "kids", "parts"]),
    ("Does it look like a scam?", ["yes", "no"]),
]
THRESHOLD = 0.9


def decide(questions, listing):
    """Answer every question at once: one (option, confidence) each."""
    answers = ANSWERS[listing]
    for (_, options), (pick, _) in zip(questions, answers):
        assert pick in options  # it can only return one of your options
    return answers


for listing in ANSWERS:
    (category, c1), (scam, c2) = decide(QUESTIONS, listing)
    lowest = min(c1, c2)
    if lowest < THRESHOLD:
        action = "send to a person"
    elif scam == "yes":
        action = "block"
    else:
        action = "publish"
    print(f"{listing:<35} {category:<8} scam={scam:<3} {lowest:.2f} {action}")

Now the bill, using TypeSafe's list price as third-party reports give it. Assume 50,000 listings a day at about 300 tokens each, counting the question and options as well as the listing (real prompts can be longer):

Because only what you send is charged, Alex knows the price of a decision before sending it. On speed, TypeSafe reports about 70–500 ms per decision and headline figures of tens to hundreds of times faster and cheaper than LLMs; those are the vendor's numbers, and they vary by source. Independent tests are still few. In one public test of spotting phishing emails (2,000 phishing emails, September 2026), Jev's median reply took 239 ms against 687 ms for Claude Haiku 4.5, at about a twelfth of the cost.

Could an LLM with structured output do Alex's job? Yes. What changes is the wait, the price of each decision, and a confidence you can put a threshold on. Together they make running a check on every listing practical.

Where it breaks: confident, wrong, uncalibrated#

Belief one: it can only pick from the list, so it can't be wrong. Look at the child seat. Alex files seats under parts, but the model said kids at 0.94. It can't invent an answer outside your list. It can still pick the wrong one, confidently.

Belief two: 0.94 means right 94 times in 100. That's only true if the model is calibrated: its scores match reality, so of all answers scored about 0.8, about 8 in 10 are right. TypeSafe's confidence page describes the score as how peaked the option scores are and tells you to test thresholds on your own data. One public phishing test (September 2026) measured an average gap of about 0.15 between score and hit rate (for example, answers scored 0.9 that are right only 3 times in 4); its author recommends calibrating per question on labelled data.

So before trusting 0.9, Alex hand-labels a few hundred past listings, groups the model's answers by score band (0.9–1.0, 0.8–0.9 and so on) and checks how often each band was right.

• Few independent benchmarks yet: most numbers are TypeSafe's own. One pre-registered 400-item study reports 95.9% right with no examples given, but the same article reports a set where it was right only 44.7% of the time, on a question it had no way to know, at an average probability of 0.74: confident, and often wrong.
• Text only, and no outside knowledge: no web search; it decides only on what you send.
• No explanation: you get an answer and a probability, not a reason.
• Reported weak spots with date comparisons and arithmetic (TypeSafe's own docs).
• Closed weights, one vendor, early access: pricing and terms can change.

When to use a decision model, and when an LLM#

• Decision model: one answer from a fixed set, many times a second or millions of times a day. Sorting text into labels, scam and safety checks, choosing which tool or model handles a request, quick yes/no checks inside a bigger AI workflow.
• LLM: open-ended writing, explanations, summaries and multi-step reasoning, where the answer isn't on any list.
• Both: a big model plans the work, and cheap decisions run at every step.

Check yourself: a listing comes back road at 0.91 and scam "no" at 0.88. Publish, block or send to a person? A person checks it: the rule reads the lower confidence, and 0.88 is under 0.9.

Practice

Check your understanding

FAQ

Frequently asked questions

Sources

Where the facts come from

• TypeSafe docs: Introduction (Jev, System One, choice questions)
• TypeSafe docs: Confidence (what the score means, thresholds)
• Rajesh Beri: TypeSafe's Jev, independent tests compared
• The New Stack: TypeSafe launches Jev, a System One model
• VKTR: ChatGPT co-creator launches TypeSafe AI with Jev