In mid-September 2026, researcher Diogo Almeida introduced a new AI lab called TypeSafe AI and its first model, Jev. Almeida helped invent reinforcement learning from human feedback (RLHF), the training method behind InstructGPT and ChatGPT at OpenAI, so people in the field paid attention. Jev’s design choice stood out right away: it cannot write a single word of ordinary text. Not one word.
Almeida spent two years in stealth building a model that refuses to write, because in production software, a paragraph of reasoning is often the enemy of reliability. When a backend system needs to classify an incoming transaction, flag a policy violation, route a support ticket, or check a security boundary, the code does not want conversational text back. It needs a typed, predictable answer, delivered in milliseconds.
Jev is described as the first public System One model: a fast, cheap decision engine in place of a slow conversational one. The name honors the 19th-century economist William Stanley Jevons. TypeSafe AI’s bet is economic. If machine decisions get roughly 400 times cheaper and 200 times faster, the argument goes, software will end up using AI for far more decisions than it does today, the same way cheaper steam power increased coal use instead of shrinking it.
Why Jev does not write text
Conversational chat models were built for people to read, and that choice creates delays and formatting problems once you wire them into software. Jev was built to talk directly to other software, using typed outputs instead of sentences.
To see why that distinction matters, look at how most companies actually use generative AI today. Despite billions of dollars spent on it, unattended automation is still rare. Most deployments are copilots: a person reads the AI’s draft, edits the code, or approves the action before anything happens. That setup works because people are forgiving. If a chatbot adds a bit of polite filler or misplaces a comma, a human reader adjusts without even noticing.
Software does not forgive the same way. Say an automated script calls an API expecting a JSON payload with a true or false flag, and the model instead wraps its answer in markdown and writes, “Certainly! Here is your requested JSON object.” The JSON parser downstream throws an error it was never built to handle. It gets worse if the model invents an answer that was never a valid option, such as labeling a request “refund_pending_investigation” when the database only accepts “approved” or “denied.” The transaction either fails silently or corrupts data. Nothing recovers on its own.
Almeida and the TypeSafe AI team concluded that trying to force a conversational chatbot to behave like a reliable software function was the wrong approach from the start. Models have been good at conversation for years, Almeida has noted, yet software automation stayed stuck. Jev treats machine intelligence as a typed function call instead. You hand it the current state of your program, unstructured, and you get back a typed, probabilistic decision in 70 to 200 milliseconds, with the output format guaranteed to match your schema.
Three ways models get trained after pretraining
Most modern models go through one of three training paths after their initial training run. Reinforcement learning from human feedback (RLHF) optimizes for what human raters prefer in conversation. Reinforcement learning with verifiable rewards (RLVR) optimizes for answers that pass an automated check, such as a unit test. Reinforcement learning for calibrated decisions (RLCD), the method TypeSafe AI built specifically for Jev, optimizes for something else entirely: calibration, meaning the model’s stated confidence actually matches how often it turns out to be right.
Figure 1 lays out the three paths side by side. Here is what each one optimizes for, and why it matters once software has to act on the answer.
Path 1: RLHF, or reinforcement learning from human feedback
RLHF is the technique that turned plain text-completion engines into InstructGPT and ChatGPT. Human evaluators look at pairs of model answers and pick the one they like better, and the model is trained to earn more of those preference votes. That produces chatbots that read as polite and confident, which is good for conversation and risky for software. Because raters tend to prefer answers that sound sure of themselves, the model learns to sound equally certain whether it is stating a checked fact or making something up.
RLHF also tends to cause what researchers call mode dropping: the training process penalizes unusual or nuanced answers, so the model’s range of possible responses collapses toward one safe, average-sounding style. That is harmless for a chat window. For a system that is supposed to report genuine uncertainty, it is a real problem, because the model loses its ability to say “I’m really not sure” in a way that means anything.
Path 2: RLVR, or reinforcement learning with verifiable rewards
RLVR underlies today’s slower “reasoning” models, such as OpenAI’s o1 and DeepSeek-R1. Instead of human raters, the training loop uses automated checks, like a unit test, a compiler, or a math proof checker, and the model only gets rewarded when its final answer passes. That produces strong problem-solving, but it costs a lot of compute at the moment you actually use it. The model works through thousands of internal reasoning tokens before it answers, which can push response times into tens or hundreds of seconds and multiplies what each answer costs.
Path 3: RLCD, or reinforcement learning for calibrated decisions
RLCD is the training method TypeSafe AI built specifically for Jev. Instead of optimizing for what a human rater likes, or rewarding any reasoning chain that happens to reach a correct answer, RLCD trains only on structured decision tasks, with one strict goal: calibration.
In statistics, calibration means a model’s stated probability matches what actually happens. Across thousands of predictions from a well-calibrated model, the events it calls 80 percent likely should happen about 80 percent of the time, and the ones it calls 20 percent likely should happen about 20 percent of the time. Ordinary chat models fail this test. That is bad. Ask one how confident it is, and it might say 95 percent while being right only 60 percent of the time. Jev is built to hit that calibration target, which lets engineers write gating logic based on a probability threshold and actually trust the number.
Three ways to ask Jev a question
TypeSafe groups every question you can ask Jev into three types: Choice, for picking one option from a list; Score, for placing something on a scale; and Noul, for a yes-or-no question with a calibrated confidence attached.
When you build with Jev, you are not writing an open-ended prompt and hoping for a useful reply. You define a question using one of the three primitives, and the model hands back a typed value instead of a sentence.
Figure 2 maps how each primitive works in code. Here is what each one does.
Primitive 1: Choice, for picking one option
Choice is for questions where the answer has to be exactly one option from a set you define. You hand Jev a dictionary where each key is the option’s name and each value describes, in plain language, what qualifies for that option. You can add an “other” option to catch anything that does not fit.
Jev looks at the current state and returns three fields:
choice: The selected option string (guaranteed to match one of your keys).probabilities: A normalized probability distribution across every defined option.confidence: A floating-point number summarizing how peaked and decisive the distribution is.
Primitive 2: Score, for placing something on a scale
Score places an input somewhere along an ordered scale that you describe. Instead of forcing the answer into a fixed integer category the way a typical sentiment model does, Jev returns a continuous number that can land smoothly between the milestones you defined.
Say you define level 0 as calm and factual, level 1 as frustrated but polite, and level 2 as enraged and shouting. A customer message might come back scored at 1.4. That tells you the person is noticeably past ordinary frustration but has not yet crossed into open anger. This fine-grained number lets your software set a precise threshold instead of guessing where to draw the line.
Primitive 3: Noul, a calibrated yes-or-no answer
Noul answers one kind of question: is this statement true about the current state? It returns a single number between 0.0 and 1.0, the calibrated probability that the answer is yes.
A value near 1.0 means Jev is nearly certain the answer is yes. A value near 0.0 means it is nearly certain the answer is no. A value near 0.5 does not mean “somewhat true.” It means Jev genuinely cannot tell, the way a person would if a customer wrote, “I might want to cancel if my bill is wrong.” Whether that counts as a cancellation request really is unclear. Nobody can say for sure. A Noul score of 0.48 reports that honestly, so your code can ask a follow-up question instead of guessing.
State references, or field dot-paths
One of TypeSafe’s cleaner design choices is how you point at a specific field. Say your state is one JSON object holding several nested pieces, such as a customer’s account details, their recent orders, and a support ticket transcript. You do not need to slice that object apart before you query the model. You send the whole state once, and inside your question’s instructions you point at a specific field using a dot path in backticks, like this:
# Referencing nested state fields inside question instructions
questions = {
"is_duplicate_charge": Noul(
instructions="Do `order.charges[0].amount` and `order.charges[1].amount` represent a duplicate billing event based on `refund_policy`?"
)
}That lets Jev focus on exactly the sub-fields your question names, while your app still sends everything in one network call instead of several.
A worked example: a triage and refund engine in Python
Here is what that looks like in practice: in under fifty lines of Python, you can build a customer triage and refund engine that checks intent, urgency, and policy compliance at once, in about 110 milliseconds.
The example below shows how a System One model can replace a fragile chain of prompts and regular expressions, using the official Python software development kit (SDK), typesafe_sdk.
Here is the full script, matching the four stages shown in Figure 3:
import os
from typesafe_sdk import TypeSafeClient, Choice, Score, Noul
# 1. Assemble structured state payload
customer_state = {
"ticket": {
"id": "TICK-9042",
"customer_tier": "enterprise_gold",
"message": (
"Your system charged our corporate card $499 twice for invoice INV-2024-09. "
"We only authorized a single charge. Please reverse the duplicate payment immediately."
)
},
"billing_ledger": {
"invoice_id": "INV-2024-09",
"authorized_amount": 499.00,
"recorded_charges": [
{"charge_id": "ch_101", "amount": 499.00, "status": "captured", "timestamp": "2026-09-20T14:10:02Z"},
{"charge_id": "ch_102", "amount": 499.00, "status": "captured", "timestamp": "2026-09-20T14:10:05Z"}
]
},
"refund_policy": (
"Duplicate charges occurring within a 60-second window for the same invoice "
"are classified as processing errors and are eligible for instant automated reversal."
)
}
# 2. Define parallel questions using typed primitives
triage_questions = {
"primary_intent": Choice(
instructions="What is the primary request in `ticket.message`?",
criteria={
"refund_request": "Customer explicitly demands return of funds or duplicate charge reversal",
"subscription_cancellation": "Customer wants to terminate service or close account",
"technical_support": "Customer reports software bugs, outage, or broken features",
"general_inquiry": "Customer requests documentation, pricing details, or receipts"
}
),
"customer_frustration": Score(
instructions="Score the level of customer agitation in `ticket.message`",
criteria=[
"Calm, neutral, and matter-of-fact",
"Firm and concerned, but civil",
"Severely agitated, threatening cancellation or legal action"
]
),
"policy_eligible_refund": Noul(
instructions=(
"Does `billing_ledger.recorded_charges` demonstrate a duplicate charge "
"eligible for immediate refund under `refund_policy`?"
)
)
}
# 3. Dispatch parallel evaluation to Jev
with TypeSafeClient() as client:
response = client.system_one(
state=customer_state,
questions=triage_questions
)
# 4. Extract typed answers and calibrated confidence
intent = response.answers["primary_intent"]
frustration = response.answers["customer_frustration"]
refund_eligibility = response.answers["policy_eligible_refund"]
print(f"Primary Intent: {intent.choice} (Confidence: {intent.confidence:.2f})")
print(f"Frustration Score: {frustration.score:.2f} / 2.0 (Confidence: {frustration.confidence:.2f})")
print(f"Policy Refund Probability: {refund_eligibility.noul:.2f}")
# 5. Deterministic software branching
if intent.choice == "refund_request" and refund_eligibility.noul > 0.90:
print("SUCCESS: High-confidence duplicate charge verified. Triggering automated payment reversal...")
# execute_payment_reversal(customer_state["billing_ledger"]["recorded_charges"][1]["charge_id"])
elif frustration.score > 1.5:
print("ESCALATION: Customer is severely agitated. Paging high-priority Tier-2 on-call...")
else:
print("ROUTING: Assigning ticket to standard customer billing queue.")When you run this script, here is what the console output looks like:
Primary Intent: refund_request (Confidence: 0.98)
Frustration Score: 1.12 / 2.0 (Confidence: 0.89)
Policy Refund Probability: 0.96
SUCCESS: High-confidence duplicate charge verified. Triggering automated payment reversal...The whole round trip took 112 milliseconds. There was no regular-expression parsing, no JSON try-catch block guarding against a malformed response, and no chance of the model’s wording crashing the thread. The application code read exact probabilities and made the business decision on its own, deterministically.
Why faster, cheaper decisions change how much AI gets used
In TypeSafe AI’s production workflow benchmarks, Jev matches the accuracy of frontier models while running up to 193 times faster and 444 times cheaper.
TypeSafe AI tested Jev against leading frontier models, including GPT-5.6 Terra, GPT-6 Astra, and Fable 5.1, on real production business workflows rather than multiple-choice academic tests. Each workflow was broken into dozens of conditional branching points, closer to how a real backend actually routes a decision.
Figure 4 shows how far apart the two model classes land:
- The speed gap: On complex enterprise decision graphs, frontier chat models took 3.2 to 45 seconds per decision chain, because they generate their answer one token at a time. Jev finished the same graphs in 70 to 500 milliseconds, 40 to 193 times faster.
- The cost gap: Jev bills only for input tokens, at $0.042 per million tokens ($42 per billion), and the output decision itself is free. Across a full workflow, that made Jev up to 444.6 times cheaper to run than a frontier model.
- Real-time games and robotics: To show off the low latency, TypeSafe engineers built an agent that plays the original video game Doom in real time. It receives the game’s state as structured data and decides on movement and weapon fire ten times per second. Running a model at ten queries per second nonstop would bankrupt a startup on GPT-4o pricing. On Jev, the whole game bot costs roughly $7.00 per hour.
- Wikiracing with hundreds of options: In a benchmark where an AI clicks its way between Wikipedia articles, Jev evaluated up to 255 candidate links at once and picked the best path in a single pass, without inventing a link that was not actually on the page.
This is where the Jevons paradox comes in. In 1865, the economist William Stanley Jevons noticed that James Watt’s more efficient steam engine did not cut England’s coal use. Cheaper steam power unlocked thousands of new industrial uses instead. Total coal use went up, not down. TypeSafe AI is betting on the same pattern: once machine-native decisions cost a fraction of a cent and finish in under 100 milliseconds, the company expects System One models to replace a lot of hand-written rules, database triggers, and scheduled jobs across ordinary software.
Where Jev falls short
In its first public release, jev-1.13, Jev only works with text and JSON, caps Choice questions at 255 options, and cannot write natural-language prose at all. No prose, ever.
Knowing where a tool breaks matters as much as knowing what it does well. Here are the limits worth planning around in jev-1.13:
- Text and JSON only: Jev evaluates strings, JSON payloads, and arrays of text. It does not take images, audio, or video. If your pipeline needs to read a scanned document, run an extraction model such as Docling first and pass Jev the extracted text.
- A 255-option ceiling: A single Choice question supports at most 255 candidate options. If you need to sort into thousands of categories, such as a deep patent hierarchy or a global product taxonomy, use a hierarchical search instead: a broad first pass, then a narrower second call within the branch you chose.
- It does not generate anything: If a user needs an email draft, a written report, or an ordinary chat reply, Jev cannot produce it. Route that part of the job to a conversational model such as Claude or GPT-4o once Jev has made the classification decision.
What to do next
Jev and the System One idea mark a real shift, not just another model release. For four years, developers have tried to bend conversational chatbots into decision engines that were never built for that job. Splitting fast, calibrated System 1 decisions from slow, deliberate System 2 reasoning gives software something it did not really have before: an interface it can depend on.
To start putting a System One model into your own architecture:
- Look through your codebase for brittle regular expressions, fragile string matching, and slow calls that ask a chat model to return JSON.
- Install the official Python SDK with
pip install typesafe-sdkand try the interactive API console at console.typesafe.ai. - Structure your data into a clean state object, then test a first triage workflow using the Choice, Score, and Noul primitives.
Sources
- TypeSafe AI: Introducing System One Models and Jev (Diogo Almeida, September 15, 2026)
- TypeSafe AI Official Documentation, SDK Guides, and API Reference
- TypeSafe AI Production Workflow Evaluations and Pareto Frontier Data
- TypeSafe AI Model Jaggedness and Known Limitations in Jev 1.13
- William Stanley Jevons: The Coal Question and the Jevons Paradox (1865)
- Diogo Almeida Publications on RLHF and Instruction-Following (OpenAI)
Keep going
Same lessons in your feed
Short diagrams, hooks, and weekly tutorials on Substack, Instagram, X, and Facebook.
