Meet TypeSafe AI’s Decision Model: Jev

LLMs write, agents act, Jev chooses the next move. Splitting intelligence from execution…

What is Jev?

Unlike traditional LLMs that output text, Jev is designed purely for software automation and returns structured data. It is a a specialized non-text-generating AI model launched by TypeSafe AI. It’s trained using reinforcement learning for calibrated decisions (RLCD). Our code uses those results to guide what an agent does next, without a full chat LLM call for each decision.

The TypeSafe AI team calls it as a System One model:

System One models are a class of AI models built to make fast, structured decisions that software can use directly. A System One model evaluates a state and returns typed answers and probabilities.

TypeSafe AI’s first public model — Jev, available in early access. Jev achieves similar levels of intelligence on System One tasks compared to existing LLMs, while being two orders of magnitude faster and more efficient. While Jev gives up string generation, it’s optimized for structured outputs and can’t hallucinate.

Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.

What is Jev Engineering?

In the context of TypeSafe AI’s revolutionary Jev model, Jev engineering (or developing with Jev) refers to a completely new paradigm of building software where you decompose complex business logic into strict, typed, probabilistic queries instead of writing open-ended text prompts.

Because Jev is a “System One” non-autoregressive model, it cannot write a single sentence and has zero text generation capabilities. Instead, it acts as a hyper-fast, ultra-cheap “smart if statement" or classifier inside your code.

“Engineering” for Jev fundamentally shifts away from traditional prompt engineering in several key ways:

1. Structuring the Three Primitives

Instead of prompting an LLM to “return a JSON object with fields X, Y, Z,” Jev engineering requires you to define a structural schema built on Jev’s three fundamental question types (primitives):

• Noul (Boolean): A yes/no question that returns a strict probability between 0 and 1 (e.g., Is this support ticket urgent?).
• Choice: Selecting a single option from a predefined list (up to 255 options), returning the choice alongside a full probability distribution.
• Score: An ordinal rating across a scale (e.g., low, medium, high) that returns a probability-weighted numerical score.

2. State vs. Question Separation

Jev engineering requires separating your data payload from the evaluation. You feed the model a consolidated application “State” (a text string or JSON object representing a customer email, log file, or document) and then run multiple typed questions against that state in parallel in a single request. Because Jev samples options concurrently, adding more questions doesn’t significantly impact its 70–500ms latency.

3. Keeping Logic in the Code

A core rule of Jev engineering is to keep the loop, safety guardrails, and arithmetic in ordinary software code. You use Jev strictly for the narrow human-like judgment in the middle that traditional code finds difficult to phrase (e.g., determining sentiment or routing a workflow). Because Jev outputs direct typed values rather than string text, your software consumes the response immediately without needing brittle regex or complex JSON parsing.

4. Navigating “Jaggedness” (Failure Modes)

Engineering for Jev involves defending against its specific structural limitations, which TypeSafe AI explicitly documents as “jaggedness”:

• Literalism: Jev reads instructions incredibly literally. It answers the exact question you wrote, not the one you intended.
• State Overload: Its accuracy degrades if you pack the “State” with irrelevant fluff that the question does not actually need to evaluate.
• Prompt Injection / Hostile Text: Jev does not inherently filter out hostile inputs. Text engineered by an end-user to argue for its own classification can skew Jev’s answer, meaning you must engineer validation logic in your own code before passing user text into the state

In a nutshell

JEV IS AN “INTERNET MOMENT” FOR AI — that is up to 193x faster and 444x cheaper in tests with Claude Fable 5.1 and GPT-6 Astra. What TypeSafe AI’s Jev bring in, how to use it, and where its 100x advantage comes from. Turn every agent fork into three primitives: Choice selects one route, Score measures a defined scale, and Noul returns the probability of yes/no.

The end result: one slow, expensive agent now becomes an always-on decision machine that routes, scores, and escalates in milliseconds.

Testing Jev: —

To invoke a Jev model, you send it a state (the context) and questions about that state. Here’s an example — where we test JEV model to grade a student answer like a human examiner using the "score" primitive. To learn more — read through their docs here.‍

In the above example, we test a 2 mark question “Explain the difference between a gene and an allele” from here. [Question: 5 (a)(ii)], with an example candidate answer and the criteria's. The decision model also returns a probability for every level in probabilities, and a confidence value for the answer. So, the candidate answer “A gene is a basic unit of heredity made of DNA that codes for a specific trait, while an allele is a specific variant or alternative form of that gene” is given the following probabilities for the respective mark outcomes — 0 mark: 16%; 1 mark: 2% and 2 mark: 82% with the confidence score of 48% the answer being classified as getting 2 mark.