Jev: The New AI Model That Makes Decisions, Not Text

Overview

For three years, every AI advance has looked the same: a bigger model that writes better text. Jev, released by TypeSafe AI on September 15, 2026, is the first genuinely different thing in a while — a model that doesn't write text at all. Instead, you hand it some data and a well-defined question, and it hands back a typed decision with a confidence score, in a single fast pass. TypeSafe calls this a "System One" model: where a chatbot is slow, deliberate "System Two" reasoning, Jev is fast "System One" intuition that software can act on directly.

It's the brainchild of Diogo Almeida, a former OpenAI researcher and co-author of the InstructGPT paper that helped make ChatGPT possible — so it's worth taking seriously, not dismissing as hype.

What "System One" Actually Means

Here's the whole idea in one comparison. A large language model answers by generating text one token at a time — great for writing, explaining, and open-ended reasoning, but slow and, crucially, unstructured: you get a paragraph you then have to parse, validate, and hope it didn't wander off.

Jev flips that. You give it:

1. some state (the text or data to judge), and
2. a question with the answers defined in advance (the categories, the scale, or a yes/no).

It returns a typed decision plus a probability for every option — no paragraph, no parsing, no "as an AI language model…". Because the possible answers are fixed by you, it literally cannot return something off-menu. That's what TypeSafe means by "type-safe": the output always fits the shape your software expects.

Why It's a Big Deal

The headline numbers are striking. TypeSafe's own claims (treat these as vendor benchmarks) are "193.6× faster, 244.6× cheaper" than LLMs on these decision tasks, at $42 per billion input tokens with free output — which they frame as hundreds of times cheaper than a frontier chat model.

More convincing than the marketing are the independent early reports: engineers at Vercel described 5–18× speed-ups swapping an LLM for Jev on classification, and one team (Bryo AI) reported it running 10–20× cheaper than Gemini for email sorting. When a decision that used to cost an LLM call and a second of latency becomes near-instant and nearly free, you can afford to run it on every message, row, or event — which changes what's practical to build.

The Honest Catch: "Zero Hallucinations" ≠ "Always Right"

TypeSafe markets "zero hallucinations," and there's a real, defensible core to it: Jev can't invent an answer outside the options you defined, and it can't return a malformed, wrong-type response. Those failure modes genuinely go away.

But be clear about what that does not mean. As Armin Ronacher (CTO of Earendil) put it, Jev "delegates the hallucination problem to you." It still returns a probability — and it can be confidently wrong or genuinely unsure. Your job is to read the confidence it gives you and decide what to do with a shaky answer. So the right mental model isn't "an AI that's never wrong"; it's "an AI that tells you how sure it is, so your code can handle uncertainty on purpose." That's a big upgrade over parsing an LLM's freeform text — but it's not magic.

Who This Is For

What You'll Learn

Before You Start

The Three Primitives: Choice, Score, Noul

Every Jev call is built from one or more questions, and there are exactly three types:

You can ask several at once in a single call — classify, score, and gate the same message in one round trip.

Hands-On: Your First Jev Decision

Step 1: Get a key and install the SDK

Grab your API key from the TypeSafe console, then install the official Python SDK (requires Python 3.10+):

bash
pip install typesafe-sdk

The SDK reads your key from the TYPESAFE_API_KEY environment variable, or you can pass it explicitly. Under the hood every call is a POST https://api.typesafe.ai/v1/systemone.

Step 2: Make a Choice call

Let's classify an incoming support message into a category:

python
from typesafe_sdk import Choice, TypeSafeClient
client = TypeSafeClient()
response = client.system_one(
    state="Hi, I was charged twice for my subscription this month.",
    questions={
        "category": Choice(
            instructions="Route this support message to the right team.",
            criteria={
                "billing": "Payments, charges, refunds, invoices",
                "technical": "Bugs, errors, the product not working",
                "sales": "Pricing questions, upgrades, new purchases",
            },
        ),
    },
)

Step 3: Read the decision

Every answer comes with the pick, the full probability distribution, and a confidence you can act on:

python
answer = response.answers["category"]
print(answer.choice)         # -> "billing"
print(answer.probabilities)  # -> {"billing": 0.97, "technical": 0.02, "sales": 0.01}
print(answer.confidence)     # -> 0.96  (0-1: how concentrated the distribution is)

Notice there's nothing to parse — answer.choice is one of your three strings, guaranteed.

Step 4: Score and Noul in the same call

You can define several questions together. A Score uses an ordered list of levels; a Noul is a yes/no:

python
questions = {
    "severity": {
        "type": "score",
        "instructions": "How severe is the reported issue?",
        "criteria": [
            "Cosmetic; no impact to functionality",
            "Broken feature, but a workaround exists",
            "Blocking issue; no workaround",
        ],
    },
    "wants_human": {
        "type": "noul",
        "instructions": "Is the customer asking for a human agent?",
    },
}

A Score answer returns a weighted score (e.g. 1.3 on a 0–2 scale), the per-level probabilities, and a legend. A Noul answer returns a single number — noul: 0.99 means a 99% chance the answer is "yes."

Step 5: The confidence-routing pattern (this is the important one)

Because Jev hands you a confidence, you decide the policy. The standard, production-safe pattern is: act automatically when confident, escalate when not.

python
answer = response.answers["category"]
if answer.confidence >= 0.85:
    route_ticket(answer.choice)          # trust it, act instantly
else:
    escalate_to_human(state)             # or fall back to a full LLM

That single if is the whole philosophy: Jev handles the easy, high-volume majority instantly and cheaply, and the genuinely ambiguous minority gets a human or a heavier model. You choose the threshold.

Where Jev Fits — and Where It Doesn't

Jev isn't an LLM replacement; it's a specialist for a specific job.

The most powerful setups use both: Jev as the fast, cheap decision layer, and an LLM for the moments that need real language.

Common Mistakes to Avoid

Pro Tips

Key Takeaways

Sources: TypeSafe AI · Jev documentation · TechCrunch coverage · The Register

Jev is in early access and evolving quickly; verify exact pricing, availability, and API details against the official docs before building on it.