What type of model is Jev?
Short answer: Jev is a System One model — TypeSafe AI's category for a model that makes decisions rather than writing text. It is not a large language model. Where a chat LLM decodes a sentence token by token and leaves you to parse a value out, Jev takes some state and a set of typed questions and returns the typed value directly — a pick, a score, or a calibrated yes/no — in a single non-autoregressive pass. Here's how that slots into the model types you already know.
People reach for familiar buckets — "is it an LLM? a classifier? a fine-tuned something?" Jev doesn't fit the generative bucket at all. It belongs to a different family that TypeSafe AI calls System One, after Kahneman's fast, intuitive mode of thinking. The defining trait isn't its size; it's how it produces output.
Where Jev sits in the model taxonomy
| Model family | How it produces output | Typical output | Examples |
|---|---|---|---|
| Autoregressive LLM | Decodes text one token at a time | Free-form prose you must parse | GPT, Claude, Gemini |
| Encoder classifier | One forward pass over fixed labels | A label (often uncalibrated) | BERT-style fine-tunes |
| Diffusion model | Iterative denoising steps | Images, audio, some text | Stable Diffusion |
| System One model | One non-autoregressive parallel pass | A typed, calibrated decision per question | Jev (TypeSafe AI) |
Not an LLM — a non-autoregressive sampler
An LLM is autoregressive: each token is conditioned on the ones before it, so output arrives serially and the model can drift into text that doesn't match the shape you wanted. Jev is a non-autoregressive parallel sampler: it evaluates your whole question set against the state in one forward pass and emits the structured answer at once. That single pass — not a smaller or cheaper model — is why a Jev decision lands in roughly 70–500ms, often 40–200x faster than prompting a frontier LLM for the same call, and why it has 0% structured-output error: a choice is always one of your options, a yes/no is always a number. Nothing to repair.
What kind of output does it return?
Jev answers with one of three typed primitives, chosen per question:
- choice — pick one option from a labelled set; returns the winning option plus a probability for each
- score — rate on an ordered scale you define (2–10 levels); returns a possibly-fractional score with per-level probabilities
- noul — a calibrated yes/no; returns a single 0–1 probability that the answer is yes, ideal for gates and guardrails
Then is it just a classifier?
It's closer to a classifier than to an LLM, but three things set it apart. First, it's calibrated: Jev is trained with RLCD — Reinforcement Learning for Calibrated Decisions — so a 0.8 means it's right about 80% of the time across many calls, which lets you set action thresholds on the number itself. Second, it isn't pinned to one fixed label set baked in at training time — you declare the answer space at call time as typed questions, and you can ask several at once against the same state. Third, it spans pick-one, ordinal scoring, and yes/no in one model. It's best described as a decision model: a programmable primitive you put in front of an LLM to route, rank, extract, verify, or gate.
Who built it, and the name
Jev is TypeSafe AI's first System One model, created by founder Diogo Almeida — a co-inventor of RLHF and a contributor to InstructGPT — with $40M led by DCVC. The model is named after the 19th-century economist William Stanley Jevons; "System One" nods to Kahneman. It's generally available now, hosted, with pinned versions so your thresholds stay stable in production.
What it looks like in code
Because the type of each answer is fixed by your request, you branch on the result in plain code — no prompt, no parsing, a calibrated decision back for less than a cent:
const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
},
body: JSON.stringify({
state: { review: text },
questions: {
sentiment: { type: "choice", instructions: "Classify sentiment.",
criteria: { positive: "happy", neutral: "mixed", negative: "unhappy" } },
ship: { type: "noul", instructions: "Safe to auto-publish?" },
},
}),
});
const { answers } = await res.json();
// answers.sentiment.choice is one of your labels; answers.ship.noul is 0–1 — typed, never malformedFAQ
Is Jev a large language model?
No. An LLM generates text token by token; Jev is a System One decision model that returns a typed value — a choice, score, or calibrated yes/no — in one non-autoregressive pass. It doesn't write prose at all. You still use an LLM when you need text, and put Jev in front of it to route, classify, or gate.
What does "System One model" mean?
It's TypeSafe AI's category for a model that makes fast, structured decisions rather than generating text — named after Kahneman's System 1, the fast intuitive mode of thought. Jev is the first one.
Is Jev just a classifier?
It's close, but it's calibrated (trained with RLCD, so a 0.8 is right about 80% of the time), the answer space is declared per call instead of fixed at training, and one model handles pick-one, ordinal scoring, and yes/no. It's best called a decision model.
Is Jev generative or discriminative?
Discriminative in spirit: it maps state plus typed questions to decisions and never samples free-form text. That's why there's nothing to parse and 0% structured-output error.
Why is a non-autoregressive model faster?
It emits the whole structured answer in one forward pass instead of decoding a sentence token by token, so a decision lands in ~70–500ms — often 40–200x faster than prompting a frontier LLM for the same thing. The speed comes from the single pass, not from a smaller model.
See also: What is Jev · How does Jev work · System One models · What is a decision model · RLCD calibration · Playground
See the model type for yourself
Run a real typed decision in the browser with no signup, then grab a jv_live_ key and call /api/v1/decide from your own code.