What Is the Jev Model?

What is the Jev model? Jev is a non-generative AI model from TypeSafe AI that answers typed questions about a piece of state — a support ticket, a transaction, a lead — with structured, probability-scored answers instead of generated text. You send it a state and a set of Choice, Score, or Noul questions; it evaluates the whole state in one parallel pass and hands back typed answers with a confidence value attached. Jev isn't a chatbot, and it isn't trying to write anything. Think of it as a decision layer you call the way you'd call a fast classifier, not the way you'd prompt an assistant.

The TypeSafe Jev Model in One Paragraph

Here's the TypeSafe Jev model in one paragraph. TypeSafe AI trained the AI model Jev to look at a structured snapshot of your application state — not a chat transcript — and answer a fixed set of typed questions about it. Each question is one of three primitives: a Choice (pick one option from a list), a Score (a number inside a range), or a Noul (the probability that a statement is true). Jev answers every question for a given state in a single pass and returns a typed response with a probability or confidence value on each answer. There's no sampling loop, no next-token generation, and no free text to parse afterward — if you've used a rules engine before, the shape will feel familiar, except Jev learns the mapping from state to answer instead of you hand-coding it.

System One Jev: Fast, Intuitive Decisions

Psychologist Daniel Kahneman split human thinking into two systems: System 1 is fast, automatic, pattern-matching judgment — recognizing a face, sensing that an email is spam. System 2 is slow, deliberate reasoning — working through a multi-step proof. TypeSafe borrows that framing for its model line: System One Jev handles the System 1-shaped decisions your software makes thousands of times a day — route this ticket, score this lead, flag this transaction — while a large language model plays the System 2 role for open-ended reasoning and generation.

Most of what a production agent or backend does isn't open-ended writing. It's a bounded decision with a right-ish answer already implied by the data — which queue, how urgent, does this look fraudulent — and that's the gap System One Jev is built to fill.

Is Jev an LLM? Why a Non-Generative AI Model Wins for Decisions

A lot of people search for a Jev LLM, but that's not quite what Jev is. A large language model is autoregressive: it generates a response one token at a time, sampling from a probability distribution over its vocabulary until it decides to stop. That loop is what makes LLMs good at open-ended writing, and it's also why a single call can take anywhere from a few hundred milliseconds to many seconds depending on how much text it has to produce.

Jev skips that loop. It's a non-generative AI model: given a state and a set of typed questions, it evaluates the whole state in one pass and returns structured answers with probabilities attached, with no token-by-token decoding and no free text to validate afterward. For a bounded decision with a known set of possible answers, that non-generative AI model design wins on both speed and reliability — there's no risk of the model rambling past the answer, inventing an option outside your schema, or wrapping a JSON object in a sentence your code has to strip out first. If your task looks more like "pick one of these five categories" than "write me an email," a non-generative model is the better fit than an LLM, generative or not.

Choice, Score and Noul

Every Jev call is built from three typed primitives:

• Choice picks one option from a fixed list you define — the ticket category, the routing destination, the next tool to call. Jev returns the selected option along with a probability for every option it considered, so you can see how close the runner-up was.
• Score returns a number inside a range you set, like a lead-quality score from 0 to 100 or a risk score from 0 to 1. You get the number plus a confidence value, not a paragraph explaining it.
• Noul is a yes/no primitive that returns a graded probability instead of a boolean — did this transaction look fraudulent, does this ticket need a human — so you get a confidence-weighted likelihood rather than a flat true/false flag.

You can mix all three across a single state in one call. A support ticket might carry one Choice question (which queue), one Score question (priority, 1–5), and one Noul question (needs a human), answered together. TypeSafe's System One docs describe the three question types, the POST /v1/systemone endpoint, the text-only input format, and the jev-latest model name you'll call once your access opens.

Calibrated Confidence Scoring

Every Jev answer comes back with a confidence value, and for that number to be useful it has to be calibrated: an answer returned with high confidence should turn out correct about as often as that confidence implies, across many calls — not just most of the time. That's the point of calibrated confidence scoring — it turns "the model's best guess" into a number your code can act on. A high-confidence Choice answer can go straight through automatically; a low-confidence one can fall back to a human reviewer or to a larger LLM for a second opinion.

TypeSafe hasn't published calibration numbers for Jev, so check it against your own traffic once you have access, rather than taking it on faith. The method: log every prediction alongside its confidence value, group the logged calls into confidence bands from low to high, and once you know the true outcome for each call, compare each band's actual accuracy rate against the confidence range it was drawn from. A well-calibrated model's bands line up closely with what they claim. If a high-confidence band turns out right far less often than its confidence implies, treat the score as a rough ranking signal rather than a reliable probability, and set your routing threshold from that measurement instead of trusting the number out of the box.

Software-to-Software Communication

Jev's typed output isn't a style choice — it's built for software-to-software communication rather than for a person reading a chat window. A Choice, Score, or Noul answer already comes back in the shape your code needs: an enum value, a number, or a plain probability. There's no prompt-engineering a response format, no regex to pull a decision out of a sentence, and no risk of the model padding its answer with caveats your parser has to strip. That matters most inside an agent loop or backend pipeline that calls a model dozens or hundreds of times per request, where every extra parsing step is a place a request can fail silently.

Try Jev API Endpoints once early access opens to see the request and response shapes for yourself. Both TypeSafe's own docs and the LiteLLM pass-through reference show a plain JSON request going in and typed JSON coming out — the same shape that makes Jev easy to drop into an existing service call instead of a conversation.

Who Built Jev: Jev (TypeSafe AI)

TypeSafe AI is a startup founded by Diogo Almeida, and it's the company behind Jev (TechCrunch). Almeida co-invented RLHF and InstructGPT and previously worked at Google Brain before starting TypeSafe (typesafe.ai/team) — a background that lines up with how Jev is positioned: a model built with the alignment techniques behind modern chat assistants, but pointed at structured decisions instead of conversation.

TypeSafe raised $40 million in a round led by DCVC (Yahoo Finance). The company announced early access to Jev on September 15, 2026, with access rolling out from a waitlist rather than opening to everyone at once (TechCrunch).

{
  "model": "jev-latest",
  "state": "Customer: I was charged twice for the same order — please refund one of them.",
  "questions": {
    "is_refund_request": {
      "type": "noul",
      "instructions": "Is the customer asking for a refund?"
    }
  }
}

Once you understand what Jev is and how it answers Choice, Score, and Noul questions, the next step is putting it to work. Build an Agent with Jev to see how a hybrid loop routes bounded decisions to Jev and open-ended steps to an LLM, or Review Jev Benchmark Data to see the latency and cost figures TypeSafe has published so far.