Jev and typesafe AI: judgment, not text

Here is a pattern we meet constantly: a team wants AI inside a product — route this ticket, triage this lead, check whether this document supports that claim — and the plan always arrives at the same place. Prompt a chatbot, ask it to reply in JSON, and write a parser robust enough to survive the days it doesn’t. We have written that parser. You have probably written that parser. It is fragile because the model underneath is a writer, and writing was never the job — deciding was.

01What Jev is

Jev is the flagship model from TypeSafe AI and the first of what they call System One models — the name is a nod to Kahneman’s Thinking, Fast and Slow, where System 1 is the fast, intuitive thinker. Like an LLM, Jev reads natural language: your state goes in as text and JSON. Unlike an LLM, it does not write back. Ask it a question and you get a typed answer with a probability, never a paragraph. Which team should handle this ticket → "billing". Does this message request a refund → 0.95. No prose, no code, no improvised explanation. The decision is the product.

02Three primitives instead of a prompt

You define the answer space up front, using one of three question types:

• —Choice — pick one option from a set you define. Returns the pick, a probability for every option, and a confidence score. "Which handler fits this request: billing, technical, or account?"
• —Score — place something on ordered, descriptive levels you write. "How frustrated is this customer: calm, frustrated, very frustrated?"
• —Noul — the probability that a yes/no claim holds. "Does this message request a refund?" → 0.95.

Because the answers are typed, the interface is guaranteed: your code branches on "billing", not on whatever the model felt like emitting that day. And because Jev ingests your state once and evaluates every question against it in parallel, you batch independent judgments into a single call — ask the refund question, the duplicate-charge question, and the policy question together, then combine them with ordinary deterministic logic. Priced per input token with output tokens free (about four cents per million today), these judgments are cheap enough to sit inside hot paths.

03Probabilities you can actually act on

The deeper difference is calibration. LLMs are trained to produce plausible text, so their stated certainty is decoration. Jev is trained for decisions — its probabilities are optimized against outcomes. That hands software a second axis: the answer tells you what; the confidence tells you whether to act. Auto-refund at 0.98, hold for a human at 0.72. That is confidence-gated routing, and it is the same shape as our agent autonomy policy: deterministic code owns the workflow, the model supplies judgment, and the uncertain cases go to a person who can answer for them.

04Where we would use it tomorrow

• —Routing and triage: support tickets, inbound leads, internal requests — anywhere you currently maintain a growing rules engine and wish you didn’t.
• —Guardrails around LLMs: screen every message going into and out of a chatbot — jailbreak attempts, prompt injection, severity — and threshold the probabilities in code.
• —Verification: check whether a quote actually supports the claim it is cited for; validate extracted fields against their source before anything downstream trusts them.
• —Reranking: retrieve candidates with cheap keyword search, then let Jev select what is actually relevant — TypeSafe’s own cookbook lifts top-1 accuracy from 5% to 18% on a legal-retrieval benchmark.

05The honest caveats

• —A typed answer guarantees the interface, not the truth. Jev can be wrong in a well-formed way — you still validate on your own data and set thresholds with consequences in mind.
• —Text in, text out. No images, audio, or video; anything else has to be pre-processed into structured fields.
• —English is where it is strongest. Other languages are handled but need testing on your own content before you rely on them.
• —It is not a reasoning model. For genuinely hard analysis you still want System Two — a reasoning LLM or a person. Jev is for the fast, narrow judgments that make up most of the ones software actually needs.

We use Jev internally for exactly this kind of work — picking the best option from live web pages, checking a page against acceptance criteria — and the pattern holds: exact work stays in code, semantics go to the model, and the answer comes back as probabilities we can show, not vibes we have to trust.

The bigger point: the industry shorthand for "AI feature" is a chatbot, because generation is what LLMs do. But most software does not need more text — it needs small, trustworthy judgments in a thousand places where today you would write a regex, a heuristic, or a 700-line rules engine. Typesafe AI treats judgment as a primitive you call like a function. That is the right primitive, and it is the same division of labor we build everything else on: code owns the workflow, humans own accountability, and the model does the one thing code alone cannot — understand.