Jev Tutorial: How to Use TypeSafe's Decision Model, and Where It Differs from ChatGPT

Who it's for

• People who face a pile of customer messages, tickets, and leads every day and want AI to triage them first
• Developers who want AI to return constrained structured fields (enum values plus probabilities) they can feed straight into code
• Readers curious about where a decision model actually differs from ChatGPT

How to do it

1. Open the Playground at console.typesafe.ai and get clear on State (input) and Questions (rules)
2. Pick Noul (true/false), Score (rating), or Choice (classification) for the job, and write a clear boundary for every option
3. Use confidence to split results three ways: high confidence runs automatically, low confidence goes to a human, risky categories follow hard rules

Watch out for

• Jev doesn't write articles, hold long conversations, or explain its reasoning; it only classifies and decides
• The primitive is spelled Noul (probability of yes), not Null — a typo throws an error; only Choice and Score return confidence
• Confidence is not accuracy: the official docs state that calibration is measured across a set of predictions, and it doesn't guarantee that any single judgment is right
• It currently accepts text input only (strings, JSON objects, arrays of text) — no images, audio, or video

Author: UPGPTs Team·First published: 2026-09-21·Last updated: 2026-09-21

TL;DR: Jev doesn't write prose, it gives a decision — you define the options, and it returns the option, the probability, and the confidence, which decides whether that decision should run automatically or go to a human. This article tests its decision quality against three real customer service messages.

📚 Table of Contents (click to jump)

• 1. What Is Jev and Where It Differs from ChatGPT
• 2. Choosing Between the Three Primitives
• 3. Hands-On: Run Your First Decision in the Playground
• 4. Tested: Three Customer Service Messages
• Pros and Cons
• Who It's For
• 5. FAQ
• 6. Next Steps

---

1. What Is Jev and Where It Differs from ChatGPT

Jev is TypeSafe's flagship model and the first System One model, a class built to make fast, structured decisions for software rather than generate text. It's currently in early access. The name comes from Kahneman's Thinking, Fast and Slow: System 1 is fast and intuitive, System 2 is slow and deliberate, and Jev only does the first half.

ChatGPT writes content (how to say it), Jev makes decisions (where to route it next).

Input: "I paid but never got my plan. What's going on?"

ChatGPT writes the user a reply:
  "Sorry for the trouble — please send us your account and a screenshot of the order…"

Jev returns a decision to your code:
  choice:        "option_d"     ← which flow this enters
  confidence:    0.93           ← how certain this decision is
  probabilities: { ... }        ← each option's own probability

Dimension	General-purpose models (ChatGPT / Claude)	Decision models (Jev)
Core job	Generate text: writing, summarizing, conversation	Make decisions: classification, scoring, true/false
Output	Natural language, format drifts, needs parsing afterward	Constrained option values + probability distribution + confidence, fixed shape
Who consumes it	People	Code
What it can't do	Unstable results across the same input	Doesn't write sentences, generate code, or explain its reasoning

So the two don't replace each other: Jev is the triage officer at the door, ChatGPT is the specialist inside.

---

2. Choosing Between the Three Primitives

Every question has to land in one of three types. The three primitives answer different questions and return different fields.

Primitive	The question it answers	Typical use	What it returns
Noul	Is it or isn't it (true/false)	Whether a message carries fraud risk, whether it signals urgency	noul: a 0–1 probability of yes, no confidence
Score	How strong / how severe	Lead scoring, customer sentiment intensity	score (can land between two levels) + legend + probabilities + confidence, 2–10 levels
Choice	Which category it belongs to	Ticket classification, support routing, intent detection (most common)	choice (the top option) + probabilities + confidence, up to 255 options

Noul returns only a 0–1 probability of yes, and that probability is your only signal. The name is Noul, not Null — a typo throws an error.

How accurate the decision is depends on how clearly you write the boundary of each option. The sharper the boundaries, the less the decision gets pulled around by irrelevant cues; but however clear they are, there will always be inputs where two options both fit, and that ambiguity belongs to the input. The example values in the official docs are illustrative config, not a pre-trained set of categories.

---

3. Hands-On: Run Your First Decision in the Playground

Open the Playground in the TypeSafe Console (docs.typesafe.ai is the documentation site, don't mix them up). You only need to understand two parts of the interface:

State (input) holds what you want decided. A JSON object beats plain text here — you can hand it several related fields at once and reference them by name in the rules:

{ "customer_message": "Pro 5x 一个月多少钱？可以开发票吗？" }

Questions (rules) is where you pick the primitive and write a clear boundary for each option. The rule below is the one we actually ran, so the option descriptions stay in Chinese:

{
  "new_choice_1": {
    "type": "choice",
    "instructions": "判断 customer_message 属于哪类客户消息",
    "criteria": {
      "option_a": "serious_buyer: 明确准备购买或升级",
      "option_b": "potential_buyer: 有需求，在比较价格方案",
      "option_c": "freebie_seeker: 仅索取免费试用或白嫖",
      "option_d": "high_risk: 付款异常、账号风险或退款纠纷"
    }
  }
}

Hit Run and the results panel returns the matched option, the full probability distribution, and the confidence.

Checkpoint: the bar for success is that the option it returns matches what you intended. If it keeps picking wrong, fix the boundary descriptions first, and don't rush to tune the thresholds.

---

4. Tested: Three Customer Service Messages

Three messages, all run through the same Choice rule.

Case 1: A general inquiry (ambiguous boundary)

"Pro 5x 一个月多少钱？可以开发票吗？"

Asking about price reads as a potential lead, but "can I get an invoice" carries the smell of reimbursement and procurement, so both options fit.

Case 2: A clear purchase (high-confidence match)

"我想开 Pro 20x，两个账号，今天能开吗？"

Plan, quantity, and timing are all present, and the probability sits almost entirely on one option.

Case 3: A billing risk (category takes priority)

"我之前一直是 Pro 20x，今天突然变成 Free 了，昨天扣的钱也没有到账，现在还能帮我恢复吗？"

Two red lines at once: an unexpected downgrade and a payment that never arrived. Don't treat confidence as a second piece of evidence — confidence is computed from the probability distribution, so when the probability is maxed out, it is necessarily 1.0.

The three messages side by side

Input traits	Matched	Probability	Confidence	Latency	Where it should go
Price question + invoice, ambiguous intent	option_b (potential buyer)	75%	67%	1.15s	Human review / decision support
Plan + quantity + timing all present	option_a (clear buyer)	98%	98%	1.67s	Run automatically
Downgrade + missing payment	option_d (billing risk)	100%	100%	0.7s	Risky category, route straight to a human

---

Pros and Cons

What Jev is good for

• Fixed output shape: it won't drift the way natural language does, so your code doesn't need a pile of defensive parsing
• You define the standard: the same criteria score repeatedly, so results stay stable and comparable, and when it gets one wrong you know which line to fix — the boundary description

Things to watch out for

• Text only: images, audio, and video aren't supported yet

Who It's For

Good fit: operations and support leads who handle a flood of customer messages, tickets, and leads every day and want AI to triage them first; developers who want purely structured fields they can feed straight into code.

Not a good fit: people who need AI to write replies or articles; scenarios that need image or audio input; anyone who doesn't plan to write the criteria clearly and just wants the AI to "take a rough look".

---

5. FAQ

What is the core difference between Jev and ChatGPT?

ChatGPT writes content: it returns natural language for a person to read. Jev makes decisions: it returns constrained options, probability distributions, and confidence for code to consume, with a fixed shape that doesn't drift.

How do I choose between Jev's three primitives?

Noul answers "is it or isn't it" and returns a 0–1 probability of yes. Score answers "how strong" and rates against ordered levels you define. Choice answers "which category" and returns the top option plus the full probability distribution. Only Score and Choice come with confidence.

What is the difference between confidence and probability?

The probability distribution gives you each option's own probability. Confidence compresses the shape of that distribution into a single 0–1 number: if all the probability sits on one option it is 1.0, and the flatter it spreads the lower it goes. So confidence is not an independent signal. It is derived from the probabilities, and it can't be used as accuracy.

How do I use confidence in a real workflow?

As a second gate on an automation switch. The official pattern is called confidence-gated routing: the answer tells you what, and the confidence tells you whether to act. High confidence runs automatically, low confidence goes to a human, and risky categories skip confidence entirely and follow hard rules.

Can Jev handle images or audio?

Not currently. The official docs state that Jev accepts text input only, as a string, a JSON object, or an array of text. Images, audio, and video are not supported.

Can Jev replace ChatGPT?

No, the two do different jobs. The official guidance is to keep control in your code and give System One only narrow, structured decisions; anything that needs language, long-form writing, or multi-step reasoning still goes to a general-purpose model.

---

6. Next Steps

• Official docs: https://docs.typesafe.ai/
• How confidence is calculated and how to use it: https://docs.typesafe.ai/confidence

If you already use Claude Code, TypeSafe also ships a Skill that lets the agent read this API on its own:

npx skills add typesafe-ai/skills --skill typesafe-ai

Restart afterward, then say "use the TypeSafe skill" in your project. To get comfortable with Claude Code itself first, see the Claude Code Guide.