Jev explained: TypeSafe's System One decision model

If you're searching for "what is Jev", this lesson opens by giving you the answer clearly: Jev is TypeSafe's flagship model and the first System One model—you give it a piece of material (state) and a set of typed questions (questions), and it returns structured answers and probabilities that code can use directly, without generating any text.

This lesson first draws a clear line between it and LLMs like GPT and Claude, then walks you through a real no-code test.

What you'll be able to do after this lesson

• Explain in one sentence what Jev is and the fundamental difference between it and LLMs like GPT / Claude
• Explain where the name "System One" comes from, and what it is and isn't good at
• Without writing a single line of code, complete a real Jev call in the official Playground
• Distinguish what the three question types—Choice / Score / Noul—each answer
• Judge whether your own use case (classification, scoring, yes/no judgment) is a fit for Jev

Your current predicament

• "Have ChatGPT decide which team a ticket should go to and output JSON"—sometimes it wraps the output in markdown code fences, sometimes it misspells field names, and the parsing code ends up longer than the business logic
• The model says it's "very confident", but you can't write an if in code: with 0.55 vs. 0.99 certainty you should take different branches, yet the text answer shows no distinction
• You've heard of Jev but can't tell whether it's the same kind of thing as GPT or Claude: can it be plugged into Claude Code as a model?

When to use this technique

When you need:

• A judgment your program can rely on: sorting content into fixed options, scoring on a scale you define, or judging whether a statement is true or false
• A judgment that comes with "how confident": probabilities and confidence go straight into code, deciding whether to execute automatically or escalate to a human

And you don't want to:

• Keep parsing an LLM's free-text output and repeatedly tweaking prompts because the format is unstable
• Treat "feels pretty sure" as an engineering basis

🎒 Preparation before you start

• Read the quick start overview to know this stage's roadmap
• A modern browser (this lesson uses the official Playground throughout, no installation needed)
• A TypeSafe account that can log in to console.typesafe.ai (if you don't have one yet, the Sign-up and API Key lesson gets you set up in 5 minutes)

Core idea

What a request looks like. Every call to Jev has the same shape: a state (the content to judge: a string, JSON object, or array of texts) plus a set of questions (typed questions), returning one typed answer per question, with probabilities attached, and some question types also include confidence. All questions are evaluated in parallel and independently against the same state, and adding questions barely increases response time.

Where the name "System One" comes from. The official source borrowed Kahneman's System 1 (fast thinking) from Thinking, Fast and Slow: this class of models specializes in "fast, focused judgments"—the kind of conclusion a knowledgeable person can reach in seconds given the right material. Jev is TypeSafe's flagship model and the first System One model.

The difference from LLMs, laid out in one table.

	LLMs (GPT, Claude…)	Jev (System One model)
Optimized for	Generating text for humans to read	Making decisions code can use directly
Output	Free text; getting JSON requires prompt constraints	Typed answers + probabilities, some question types with confidence
Are probabilities trustworthy	Not calibrated; "I'm very sure" is just wording	Trained with calibration against real outcomes; probabilities reflect uncertainty
Does it explain its reasoning	Yes, at length	No: it doesn't write replies, produce code, or explain reasoning
Typical uses	Chat, writing, code completion	Routing, classification, scoring, guardrails, yes/no judgment

Three question types (officially called primitives).

Question type	What it answers	Returns
Choice	Picks one from fixed options, e.g. routing a ticket to billing / technical / sales	choice, each option's probabilities, confidence
Score	Rates on a scale you define, e.g. customer frustration in three tiers	score (can fall between two tiers), probabilities, confidence
Noul	Judges whether a single statement is true or false, e.g. "this message requests a refund"	noul: 0–1 probability

(The fourth question type, Box, is used to locate things in images and is covered separately in the Box and images lesson.)

How to call it. Use the official SDK (Python / JavaScript), or make requests directly to POST https://api.typesafe.ai/v1/systemone; the model field in the request selects the model—the official examples all use jev-latest, which is also the SDK default and currently points to the latest stable version Jev 1.14.

What it looks like wired into a real workflow. The official refund example: package the customer message, relevant transaction records, and refund policy into a single state; one request asks three independent questions—whether a refund was requested, whether the evidence points to a duplicate charge, and whether the policy supports a refund; the code combines the three answers with a certainty check to decide between automatic handling and escalation to a human.

What it is not is equally important. Jev is not the kind of model behind Claude Code, Cursor, or Copilot—it does not stream generated text, call tools, or edit files, and no model: "jev-latest" configuration can swap a coding agent for Jev power. The right approach is the reverse: let the coding agent do its work as usual and write "code that calls Jev".

⚠️ A note on non-English content

English is Jev's primary training language and delivers the best accuracy; other languages (including Chinese) work, but the official documentation explicitly states that accuracy is lower than in English. Before deploying for Chinese-language scenarios, test with your own data and pay close attention to confidence.

Follow along

(This lesson is done entirely in the official Playground: no SDK installation, no code—just building intuition first.)

Step 1: Open the official Playground and paste in your first state

Why: every Jev call is "state + questions", and the Playground lets you see the full process with zero code.

Open console.typesafe.ai/playground and log in, then paste the following official sample ticket into the state input area:

Our API integration started returning 500 errors on every request about 20 minutes ago, and we can't process any customer orders until this is fixed.

You should see: this text appears in the state area. This is the material Jev will evaluate—in a real project it can be a string, a JSON object, or an array of texts.

Step 2: Add a Noul question and see how Jev answers a true/false question

Why: Noul true/false questions best showcase Jev's output form—not a paragraph, but a probability.

Add this question in the questions area (choose your own ID; here we use the official example's is_urgent):

{
  "is_urgent": {
    "type": "noul",
    "instructions": "The message conveys urgency or time-sensitivity"
  }
}

You should see: the answer is a number between 0 and 1; in the official example this ticket gets 0.99—very urgent. Actual values may vary with Jev versions.

• What I got is a probability between 0–1, not a piece of text

Step 3: Mix all three question types in one request and fully understand what Jev is

Why: evaluating multiple questions in parallel within one request is Jev's core way of working, and it's the foundation for the later patterns of parallel questions and combined scoring.

Add two more questions, combined with the is_urgent from step 2 in the same request:

{
  "department": {
    "type": "choice",
    "instructions": "Which team should handle this",
    "criteria": {
      "billing": "Payment or subscription issues",
      "technical": "Bugs or integration problems",
      "sales": "Pricing or account questions"
    }
  },
  "frustration": {
    "type": "score",
    "instructions": "How frustrated the customer appears",
    "criteria": [
      "Calm, just stating facts",
      "Frustrated but civil",
      "Very angry, strong language"
    ]
  }
}

You should see: all three answers return at once—

• department: the selected technical, with a probability and confidence for each option
• frustration: a score between 0–2; the official example is 0.67, falling between the "calm statement" and "frustrated but restrained" tiers
• is_urgent: still that same probability, 0.99 in the official example

The official code example prints exactly these three lines (actual values may vary with Jev versions):

technical
0.67
0.99

• Three answers return in one go—no need to send three requests

Checkpoint ✅

• I can name the two inputs of a Jev request: state and questions
• I know that Jev does not generate text—it returns typed answers and probabilities, plus confidence for some question types
• I got a probability between 0–1 with my own hands in the Playground
• I know that Jev cannot replace the model behind Claude Code / Cursor
• I can name the three question types: Choice picks an option, Score rates on a scale, Noul judges true/false

Pitfall warnings

❌ Putting jev-latest into Claude Code to use as the model

Jev does not stream generated text, call tools, or edit files—none of the three things a coding agent relies on. The right approach: have the coding agent write code that calls Jev; to make it better understand the TypeSafe API, you can install the official agent skill (covered in the working with Claude Code lesson).

❌ Expecting Jev to explain "why"

Its answers are just typed values and probabilities—there is no reasoning process. For finer judgments, break a big question into multiple small questions and combine them in code—for example, split "score this startup plan overall" into three Scores for market size, technical feasibility, and differentiation, and weight them yourself.

❌ Deploying for Chinese-language scenarios without testing first

English is the language where Jev delivers the best accuracy; Chinese works but with lower accuracy. Test with your own data first, watch confidence closely, and set thresholds more conservatively for scenarios with higher-stakes actions.

Advanced tips (optional)

How to choose when two question types both fit: pick the one "code can act on directly". Choice maps to a ready-made branch, Score maps to a threshold check, and Noul maps to an if.

Noul's 0.5 means fifty-fifty, not "medium": to measure "degree" (e.g. Python proficiency), use a Score with well-defined tiers; Noul only makes clean true/false judgments, and the condition should be written so it can be settled decisively.

Lesson summary

✅ You can now answer "what is Jev": TypeSafe's flagship model, the first System One decision model—it takes a state and typed questions as input and outputs structured answers, probabilities, and (for some question types) confidence, without generating text.

✅ You now know how it divides labor with the LLM: the LLM is responsible for generation, and Jev is responsible for judgment. It can't get into the model column of Claude Code, but it can get into every line of business code you write.

✅ You completed a real call in the Playground and saw the official example answers technical / 0.67 / 0.99.

Key configuration fields recap:

Field	Recommended value	Description
state	String / JSON object / text array	The material to be judged, shared by all questions in one request
questions	Choice / Score / Noul mix	Each question = a self-chosen ID + type + instructions + criteria (Choice / Score required, Noul optional)
model	jev-latest	SDK default alias, currently pointing to Jev 1.14 (jev-1.14.0)
Endpoint	POST https://api.typesafe.ai/v1/systemone	Request header carries Authorization: Bearer <你的API Key>

Next lesson preview

With the concepts clear, the next lesson is about getting your key: Registration and API Key: get your TypeSafe key in 5 minutes.

You will learn:

• Where the TypeSafe console is and on which page the API Key is generated
• Why the official recommendation is to store the Key in an environment variable TYPESAFE_API_KEY
• Where to check rate limits in the console, and what is returned when the limit is exceeded