← Use cases

Jev, the System One model

Jev is TypeSafe AI's first System One model. The name is borrowed from Daniel Kahneman: System 1 is the fast, automatic judgment your mind makes without deliberating; System 2 is the slow, effortful reasoning you do step by step. Today's chat and reasoning LLMs sit on the System 2 side — they deliberate in text, token by token. Jev is built for the other mode: a single, instant, calibrated judgment you can act on. This page explains what that category actually means and how to run a System One decision yourself.

Where the name comes from

In Thinking, Fast and Slow, Daniel Kahneman splits cognition into two modes. System 1 is fast, automatic and intuitive — it recognises a face or senses which answer is right before you can explain why. System 2 is slow, deliberate and sequential — it works a problem out one step at a time. TypeSafe AI borrowed the label for a model category: a System One model makes the fast, typed judgment directly, instead of reasoning out loud in prose. The upstream endpoint is even named for it — decisions are posted to /v1/systemone.

What makes Jev a System One model

A chat or reasoning LLM answers by generating text one token at a time, and you parse the value you actually wanted out of that text. Jev skips both ends. You declare the answer space up front — a set of options, an ordered scale, or a yes/no — and Jev returns the typed value directly in a single non-autoregressive pass. Nothing is generated outside what you asked for, so there is nothing to parse and nothing to hallucinate. That one parallel pass (not a smaller or dumber model) is why a decision lands in roughly 70–500ms, often 40–200x faster than prompting a frontier LLM for the same judgment, with 0% structured-output error.

SYSTEM 2 — reasoning LLM SYSTEM 1 — Jev state token token token… text → you parse it state + questions one parallel pass typed value + confidence
System 2 deliberates in text and leaves you to parse a value out. System One returns the typed value — and a calibrated probability — in a single pass.

System One vs System Two, side by side

System Two (reasoning LLM)System One (Jev)
How it answersDeliberates in text, token by tokenOne non-autoregressive pass, no decoding
What you get backFree text you have to parseA typed value: a choice, a score, or a yes/no
LatencySeconds of generation~70–500ms per decision
ConfidenceImplicit and uncalibratedA calibrated probability per option (RLCD)
Best forOpen-ended writing and multi-step reasoningDecisions: routing, ranking, grading, gates

The three things a System One model answers

Every Jev question is one of three typed primitives — that's the whole vocabulary of a System One decision:

Fast, but also calibrated

Being a System One model is not just about speed — an instant judgment is only useful if you can trust the number attached to it. Jev is trained with RLCD, Reinforcement Learning for Calibrated Decisions, so the probabilities it returns are meant to be honest: a 0.8 is right about 80% of the time across many calls. That is what lets you act on the number directly — auto-accept above a high threshold, send the uncertain middle to a human, fall back below a low one. Pin a model version in production so those thresholds stay stable. Jev was built by Diogo Almeida, a co-inventor of RLHF and InstructGPT; TypeSafe AI is backed by a $40M round from DCVC. The name 'Jev' nods to the economist William Stanley Jevons.

Run a System One decision

There is no SDK ceremony to learn — a System One decision is one HTTP request. You send some state and a map of typed questions, and you get a typed answer per question back. Here is a complete, paste-able call that routes a support ticket and flags urgency:

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: { message: ticket.body },
    questions: {
      queue:  { type: "choice", instructions: "Route this ticket.",
                criteria: { billing: "payments", bug: "something broken", sales: "pricing" } },
      urgent: { type: "noul", instructions: "Is it urgent?" },
    },
  }),
});
const { answers } = await res.json();
route(answers.queue.choice, answers.urgent.noul > 0.8); // typed + calibrated, no parsing

The official upstream endpoint is POST https://api.typesafe.ai/v1/systemone with the same request shape; jevtypesafeai.com/api/v1/decide is the hosted route that takes a jv_live_ key. You don't need a key to try it first — run a real decision in the browser playground with no signup. Each decision costs a fraction of a cent and output is free, so a classifier or guardrail that would be expensive on a frontier LLM is cheap here. Current tiers live on the pricing page.

What type of model is Jev?TaxonomyWhere System One sits next to LLMs, classifiers and rule enginesRead →Decision modelsCategoryThe broader 'model built to decide' category Jev definesRead →Jev 101PrimerFrom-scratch intro: the three questions and your first callStart →How does Jev workMechanismThe non-autoregressive pass and calibration, step by stepRead →PlaygroundTry itRun a System One decision in the browser, no signupTry →Who built JevPeopleDiogo Almeida, RLCD, and the TypeSafe AI storyRead →

FAQ

What is a System One model?

A System One model is a model built to make a fast, typed judgment directly, rather than reasoning out loud in text. The name comes from Daniel Kahneman's System 1 — the mind's fast, automatic mode. You give it state and a bounded question (options, a scale, or a yes/no) and it returns the typed answer with a calibrated probability, in a single pass. Jev is TypeSafe AI's first System One model.

How is a System One model different from a reasoning LLM?

A reasoning (System 2) LLM deliberates in text, generating tokens one at a time, and you parse the value you wanted out of the prose. A System One model like Jev returns the typed value itself — a choice, a score, or a yes/no — in one non-autoregressive pass, in roughly 70–500ms, with a calibrated confidence and nothing to parse. They are complementary: use an LLM to write and reason, use Jev to decide.

Is 'System One' a TypeSafe marketing term or a real category?

It's TypeSafe AI's name for the category, borrowed from Kahneman's System 1. The substance behind it is architectural: Jev is a non-autoregressive sampler that emits a structured, typed value in a single forward pass and is calibrated with RLCD. That is what the label points at — not a style of prompting an LLM.

Why is it called Jev?

The name nods to the 19th-century economist William Stanley Jevons. The model was built by Diogo Almeida, a co-inventor of RLHF and InstructGPT, at TypeSafe AI.

How do I try a System One decision?

Run one in the browser playground with no signup, then grab a jv_live_ key and POST to https://jevtypesafeai.com/api/v1/decide (the upstream endpoint is https://api.typesafe.ai/v1/systemone). A decision costs a fraction of a cent and output is free.

See also: What type of model is Jev · What is a decision model · Jev 101 · How does Jev work · Playground · Who built Jev

Make a System One decision

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. Sub-cent per decision, output free.

▶ Try Jev freeGet an API key →
Jev: the first System One model — what that means · Jev by TypeSafe AI