Jev is an AI model that never writes sentences. You ask it a question with a fixed kind of answer, such as “pick one of these four labels” or “how likely is this to be true,” and it hands back just that answer, ready for a program to use. A new company called TypeSafe AI released it in September 2026.
Picture the inbox you already deal with. A message arrives that says “you charged me twice.” You know at a glance it is a billing complaint, that the person is annoyed, and that a refund is probably due. Jev is built to make that same quick call for software, thousands of times a minute, without writing a reply.
TypeSafe was founded by Diogo Almeida, who worked at OpenAI on the research that taught ChatGPT to follow instructions. The model is named after the economist William Stanley Jevons. TypeSafe’s bet is that much cheaper and faster AI decisions will lead software to use far more of them. In its launch post on September 15, 2026, the company says Jev is roughly 100 times faster and cheaper than chatbots at this kind of quick decision.
Why Jev does not write text
Jev skips text because software needs a fixed, predictable answer, not a paragraph. Chat models were built for people to read. That choice causes delays and formatting problems once you wire them into a program.
Most AI at work today is a copilot. A person reads the draft, fixes it, and approves it before anything happens. That works because people are forgiving. If a chatbot adds a polite opener or drops a comma, you read past it without noticing.
Software is not forgiving. Say a script asks a model for a yes or no flag in JSON, a plain text format that programs use to pass data to each other. The model instead wraps its answer in markdown, the symbols chat apps use for bold text and lists, and opens with “Certainly! Here is your JSON.” The program that reads the answer breaks. Worse, the model might invent a label that was never allowed, such as “refund_pending_investigation” when the database only accepts “approved” or “denied.” Then the step either fails quietly or saves bad data.
Jev avoids this by design. You send it your program’s current data, called the state, and a list of typed questions. Each answer comes back in the exact shape you defined, which programmers call a schema: a fixed list of fields and allowed values. TypeSafe says a call takes 70 to 500 milliseconds from start to finish.
Three ways models get trained after pretraining
After a model’s first big training run, it gets a second round of training that shapes how it behaves. There are three common paths. Reinforcement learning from human feedback (RLHF) rewards what human raters prefer. Reinforcement learning with verifiable rewards (RLVR) rewards answers that pass an automatic check, such as a test. Reinforcement learning for calibrated decisions (RLCD) is TypeSafe’s own method. It rewards honest confidence: when the model says 80 percent, it should be right about 80 percent of the time.
Figure 1 compares the chat approach with Jev’s. Here is what each path aims for, and why it matters once software acts on the answer.
Path 1: RLHF, or reinforcement learning from human feedback
RLHF is the method that turned plain text predictors into InstructGPT and ChatGPT. People compare two answers and pick the one they like better. The model is trained to win more of those votes. That makes chatbots polite and confident, which is great in a chat window and risky inside software. Raters tend to like answers that sound sure. So the model learns to sound sure whether it is stating a fact or making one up.
RLHF can also cause what researchers call mode dropping. Unusual or nuanced answers get fewer votes, so the model’s range of answers shrinks toward one safe style. In a chat that is harmless. For a system that has to report real doubt, it is a problem, because the model loses the ability to say “I am not sure” in a way that means anything.
Path 2: RLVR, or reinforcement learning with verifiable rewards
RLVR is behind the slower “reasoning” models, such as OpenAI’s o1 and DeepSeek-R1. Instead of people, an automatic check scores the answer, such as a unit test (a small program that checks other code) or a math checker. The model is rewarded only when its final answer passes. This makes it good at hard problems. The cost is time and money each time you use it: the model works through a long hidden chain of reasoning before answering, which can take many seconds.
Path 3: RLCD, or reinforcement learning for calibrated decisions
RLCD is the method TypeSafe built for Jev. It does not chase human votes, and it does not reward long reasoning chains. It trains only on structured decision tasks, with one goal: calibration.
Calibration means a model’s stated odds match what really happens. Take a well-calibrated weather forecast. On the days it says 80 percent chance of rain, it rains about 8 days in 10. On the 20 percent days, it rains about 2 days in 10. Chat models often fail this test. One might say it is 95 percent sure while being right only 60 percent of the time. TypeSafe says Jev’s confidence does track its accuracy. If that holds for your data, you can write code that acts on a threshold, such as “refund only above 0.9,” and trust the number. Test it on your own examples before you rely on it.
Three ways to ask Jev a question
Every question you ask Jev uses one of three types, which TypeSafe calls primitives. Choice picks one option from a list. Score places something on a scale you describe. Noul answers a yes or no question with a probability.
You do not write an open-ended prompt and hope for a useful reply. You pick a type, describe the question, and get back a value of that type instead of a sentence.
Figure 2 shows what each type returns. Here is how each one works.
Primitive 1: Choice, for picking one option
Use Choice when the answer must be exactly one option from a set you define. You give Jev a list of option names, each with a plain description of what fits it. You can add an “other” option to catch anything that does not fit.
Jev reads the state and returns three fields:
choice: the option it picked, always one of your names.probabilities: how likely each option is, adding up to 1.confidence: one number for how clear-cut the pick was.
Primitive 2: Score, for placing something on a scale
Score places an input on an ordered scale that you describe in words. Many tools force answers into whole-number buckets. Jev can return a number that lands between your steps.
Say level 0 is calm, level 1 is frustrated but polite, and level 2 is furious. A message might come back at 1.4. That tells you the person is past ordinary frustration but not yet shouting. You can then set a precise cut-off 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 state? It returns one number from 0.0 to 1.0, the probability that the answer is yes.
Near 1.0 means almost surely yes. Near 0.0 means almost surely no. Near 0.5 does not mean “partly true.” It means Jev cannot tell. Imagine a customer writes that they might cancel if the bill is wrong. Is that a cancellation request? Honestly, it is unclear. A Noul of 0.48 says so, and your code can ask a follow-up question instead of guessing.
State references, or field dot-paths
You can point a question at one part of the state. Say your state holds a customer’s account, their recent orders, and a support chat. You send it all once. Inside a question, you name the field you mean with 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`?"
)
}Jev then focuses on the fields the question names. Your program still sends everything in one request instead of several.
A worked example: a triage and refund engine in Python
Here is a refund check in about 80 lines of Python. One call asks three questions at once: what the customer wants, how upset they are, and whether the charge qualifies for a refund. Plain Python then decides what to do.
It uses TypeSafe’s Python software development kit (SDK), typesafe_sdk, a library that handles the calls to Jev for you. To run it, install the SDK and set TYPESAFE_API_KEY in your environment.
Here is the complete script. Figure 3 shows the same four steps.
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.choices["primary_intent"]
frustration = response.scores["customer_frustration"]
refund_eligibility = response.nouls["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 I ran it on October 2, 2026, it printed the lines below. Another run can print slightly different numbers.
Primary Intent: refund_request (Confidence: 1.00)
Frustration Score: 1.00 / 2.0 (Confidence: 0.99)
Policy Refund Probability: 0.97
SUCCESS: High-confidence duplicate charge verified. Triggering automated payment reversal...The answers sit under response.choices, response.scores, and response.nouls, each keyed by the name you gave the question. The final decision is ordinary if logic that you control.
Why faster, cheaper decisions change how much AI gets used
Cheaper, faster decisions matter because they make AI worth using in places where it costs too much today. Every number below comes from TypeSafe itself, in its September 15, 2026 launch post and its published tests. Nobody independent has checked them yet.
TypeSafe’s headline claim, in the same launch post, is that Jev is up to 193.6 times faster and 444.6 times cheaper than frontier chat models on its workflow tests. A workflow here is a business task written as code, with many small decisions in a row. The company itself says those figures are “on the higher end of real world gains.”
Figure 4 puts TypeSafe’s reported numbers side by side, with the caveats the company lists.
- Speed: TypeSafe reports 70 to 500 milliseconds per Jev call, measured from its own office on the US West Coast, against 3 to 329 seconds per call for frontier models. Chat models write their answer one token (a word piece) at a time. Jev returns all its answers at once.
- Price: as of October 2, 2026, TypeSafe’s models page lists Jev at $0.042 per million input tokens, and the answers it sends back are free. The launch post puts frontier models at $0.20 to $10 per million input tokens, with output about five times more.
- How it was tested: according to the launch post, TypeSafe staff wrote the test workflows. The “right” answer was the average of two large models, GPT-6 Astra and Fable 5.1. The chat model speeds came from OpenRouter, a service that routes requests to many models. TypeSafe says each of these choices could bias the results.
- Demos: TypeSafe also showed a bot that plays the video game Doom, making 10 decisions a second for about $7 an hour. It also showed a Wikipedia racing game, where Jev picks the next link from up to 255 choices at once.
This is where the name comes from. In his 1865 book The Coal Question, Jevons argued that more efficient steam engines would raise Britain’s coal use, not lower it, because cheaper power would find new uses. That idea is now called the Jevons paradox. TypeSafe expects the same for AI. If a decision costs a tiny fraction of a cent and takes under a second, it can replace hand-written rules in ordinary software, from sorting email to flagging odd payments.
Where Jev falls short
Jev cannot write prose, only reads text and JSON, and a single Choice question can have at most 255 options. TypeSafe lists these and other known gaps on its jev-1.13 limits page.
Knowing where a tool breaks matters as much as knowing what it does well. Plan around these:
- Text and JSON only: Jev does not take images, audio, or video. To read a scanned document, first pull the text out with a document reader such as Docling, then pass that text to Jev.
- 255 options at most: if you need to sort into thousands of categories, such as a full product catalog, do it in two steps. Pick a broad group first, then ask again within that group.
- No writing: if someone needs an email draft, a report, or a chat reply, Jev cannot write it. Let Jev make the decision, then hand the writing to a chat model such as Claude or ChatGPT.
What to do next
The useful idea here is to split the work. A fast, honest decision model makes the small calls, and slower chat models handle writing and open-ended reasoning. Whether Jev lives up to TypeSafe’s numbers is something you can test on your own data in an afternoon.
- Find one place in your code where you ask a chat model for JSON, or where you match text with fragile rules. Those are the easiest decisions to move to a typed question, because they already have a fixed set of answers.
- Install the SDK with
pip install typesafe-sdk, create a key in the TypeSafe console, and run the example above. Running it yourself shows you the real speed from where you are. - Collect 50 past cases where you know the right answer, ask Jev about each, and check whether its confidence matches how often it is right. That tells you which threshold you can trust before anything runs unattended.
Sources
- TypeSafe AI: Introducing System One Models and Jev (Diogo Almeida, September 15, 2026).
- TypeSafe AI: Models, prices and limits (checked October 2, 2026).
- TypeSafe AI documentation, SDK guides, and API reference.
- TypeSafe AI workflow evaluations.
- TypeSafe AI: known limits of jev-1.13.
- Wikipedia: Jevons paradox.
- Diogo Almeida on Google Scholar.
Keep going
Same lessons in your feed
Short diagrams, hooks, and weekly tutorials on Substack, Instagram, X, and Facebook.
