In mid-September 2026, an unusual announcement rippled through the artificial intelligence research community. Diogo Almeida, a prominent researcher who co-invented Reinforcement Learning from Human Feedback (RLHF) and helped build InstructGPT and ChatGPT at OpenAI, unveiled a new research lab called TypeSafe AI and its flagship model, Jev. But unlike every other frontier model released over the past four years, Jev came with a shocking design decision: it deliberately cannot write a single word of text.
Why would one of the primary architects of modern conversational AI spend two years in stealth building a model that gives up text generation? Because in production software engineering, conversational text generation is frequently the enemy of reliability. When your backend systems need to classify an incoming transaction, detect a policy violation, route a support ticket, or check a security perimeter, your code does not want a paragraph of conversational reasoning. Your code needs typed, predictable, memory-safe decisions delivered in milliseconds.
Jev is the industry’s first public System One model. Named after 19th-century economist William Stanley Jevons, Jev is built around a powerful economic premise: by making machine decisions 400 times cheaper and 200 times faster, the total consumption of AI inside software logic will explode. In this deep-dive guide, we break down how Jev works under the hood, examine its novel RLCD training algorithm, master its three core decision primitives, and walk through a complete, production-ready Python implementation.
From ChatGPT to Machine-Native Automation: Why Jev Drops Strings
Bottom Line Up Front: Conversational chat models were designed for human reading, which introduces severe latency and formatting hazards when integrated into software; Jev was designed to communicate directly with machines using typed outputs.
To understand the motivation behind TypeSafe AI, consider the reality of enterprise automation today. Despite billions of dollars poured into generative AI, true unattended automation remains rare. Most deployments are human-in-the-loop copilots. A human reads the AI draft, edits the code, or approves the action. That setup works well because humans are forgiving. If a chatbot adds polite conversational filler or misplaces a comma, a human reader naturally adjusts.
Software is not forgiving. When an automated script calls an API expecting a JSON payload with a boolean flag, and the model instead returns markdown-wrapped text saying, “Certainly! Here is your requested JSON object,” the downstream JSON parser throws an unhandled syntax exception. Even worse, if the model hallucinates an invalid enum value like “refund_pending_investigation” when the database only accepts “approved” or “denied,” the transaction fails silently or corrupts the database state.
Diogo Almeida and the TypeSafe AI team realized that attempting to make conversational chatbots behave like reliable software functions was the wrong abstraction. As Almeida noted, models have been superhuman at conversation for years, yet software automation remained stalled. Jev solves this by treating machine intelligence as a typed function call: you pass an unstructured program state in, and you receive typed, probabilistic decisions out in 70 to 200 milliseconds with mathematically guaranteed schema adherence.
RLCD vs RLHF vs RLVR: The Three Post-Training Paths
Bottom Line Up Front: While RLHF optimizes for human conversational preference and RLVR optimizes for verifiable reasoning proofs, RLCD trains models specifically for calibrated uncertainty, ensuring assigned confidence directly matches empirical accuracy.
To understand why Jev behaves so differently from ChatGPT or Claude, you must look at how models are adapted after their initial pre-training. Modern foundation models follow one of three distinct post-training pathways:
Let us analyze the three post-training paradigms shown in Figure 1:
Path 1: RLHF (Reinforcement Learning from Human Feedback)
RLHF is the technique that turned raw text completion engines into InstructGPT and ChatGPT. Human evaluators review pairs of model responses and select the one they prefer. The model is optimized to maximize this preference score. While this produces articulate, polite, and helpful chatbots, it has a dangerous side effect in software engineering: it rewards sycophancy and overconfidence. Because human raters prefer confident, authoritative answers, models learn to sound equally certain whether they are stating a verified mathematical fact or hallucinating a nonexistent legal case.
Furthermore, RLHF causes mode dropping. In generative modeling, mode dropping occurs when the training process penalizes unusual or nuanced outputs, collapsing the model’s probability distribution around a narrow stylistic consensus. For conversational chat, this is harmless. For automated decision systems, it is catastrophic because it destroys the model’s ability to express nuanced statistical uncertainty.
Path 2: RLVR (Reinforcement Learning with Verifiable Rewards)
RLVR is the foundation of modern System 2 reasoning models like OpenAI o1 and DeepSeek-R1. Instead of human raters, the training loop uses automated verification harnesses, such as unit tests, compiler passes, or mathematical proof checkers. The model is rewarded only when its final output passes programmatic validation. This produces phenomenal problem-solving capabilities, but it requires massive test-time compute. The model generates thousands of internal chain-of-thought tokens, driving latency into tens or hundreds of seconds and multiplying token costs.
Path 3: RLCD (Reinforcement Learning for Calibrated Decisions)
RLCD is the proprietary training methodology invented by TypeSafe AI for Jev. Instead of optimizing for human stylistic approval or open-ended reasoning chains, RLCD trains the model exclusively on structured decision tasks with a strict mathematical objective: calibration.
In statistics, calibration means that predicted probabilities match empirical outcomes. Across thousands of predictions from a well-calibrated model, events assigned an 80 percent probability must occur roughly 80 percent of the time. Events assigned a 20 percent probability must occur 20 percent of the time. Standard LLMs fail this test miserably: when prompted for confidence, an LLM might claim 95 percent certainty on answers that are only correct 60 percent of the time. Jev achieves true calibration, allowing software engineers to write reliable automated gating logic based on probability thresholds.
The Three TypeSafe Primitives: Choice, Score, and Noul
Bottom Line Up Front: TypeSafe structures all evaluations into three foundational primitives: Choice for categorical selections, Score for continuous spectrums, and Noul for calibrated booleans.
When you build with Jev, you do not write prompts that ask the model to generate a response. Instead, you define questions using one of three typed primitives, and the model returns corresponding typed values.
Let us examine how each primitive operates in code as mapped in Figure 2:
Primitive 1: Choice (Categorical Selection)
The Choice primitive is used when the answer must be one discrete option from a predefined set of possibilities. You provide a dictionary of options, where each key is the enum value and the value is a natural-language description of what qualifies for that option. You can also specify an “other” option to catch edge cases.
Jev evaluates the 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 (Continuous Ordered Spectrum)
The Score primitive evaluates where an input falls along an ordered, descriptive spectrum. Unlike traditional sentiment analysis models that output rigid integer classes, Jev returns a continuous floating-point score that can fall smoothly between defined milestones.
For example, if 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 return a score of 1.4. This indicates the customer is noticeably more agitated than standard frustration, but has not yet escalated to profanity. This continuous granularity allows your software to set precise operational thresholds.
Primitive 3: Noul (Calibrated Probabilistic Boolean)
The Noul primitive answers a fundamental question: “Is this statement true about the input state?” It returns a single floating-point number between 0.0 and 1.0 representing the calibrated probability that the answer is yes.
A value near 1.0 represents an overwhelming yes. A value near 0.0 represents an overwhelming no. Crucially, a value near 0.5 does not mean “moderate severity.” It means the model identifies genuine epistemic ambiguity. For example, if a customer writes, “I might want to cancel if my bill is wrong,” whether they requested a cancellation is genuinely uncertain. A Noul score of 0.48 accurately communicates that uncertainty, allowing code to prompt for clarification rather than making an erroneous assumption.
State References via Field Dot-Paths
One of TypeSafe’s cleanest design patterns is field dot-path referencing. When your state is a structured JSON object containing multiple nested fields (such as user metadata, recent orders, and ticket transcripts), you do not need to slice and dice the data before querying the model. You pass the entire state once, and in your question instructions, you reference specific fields using backtick dot paths:
# 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`?"
)
}This allows Jev’s attention heads to bind directly to the targeted sub-objects while keeping your network payload consolidated into a single request.
Production Walkthrough: Building a Triage and Refund Engine in Python
Bottom Line Up Front: In under fifty lines of Python, you can construct an end-to-end automated customer triage and refund engine that evaluates intent, urgency, and policy compliance simultaneously in 110 milliseconds.
To demonstrate how System One models replace fragile LLM pipelines, let us implement a complete customer support automation engine using the official typesafe_sdk Python package.
Here is the complete, runnable Python script that executes the four-stage lifecycle illustrated 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 execute 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...Notice the power of this execution. The entire query completed over the wire in 112 milliseconds. There was no regex parsing, no JSON deserialization try-catch block, and zero chance of a string hallucination crashing the thread. The application code inspected exact statistical probabilities and executed the business transaction deterministically.
Benchmarks and the Jevons Paradox: Why Speed and Cost Explode Usage
Bottom Line Up Front: In comprehensive production workflow benchmarks, Jev achieves accuracy comparable to frontier models while running up to 193 times faster and 444 times cheaper.
TypeSafe AI published extensive evaluations across production business workflows comparing Jev against leading frontier models, including GPT-5.6 Terra, GPT-6 Astra, and Fable 5.1. Rather than testing on generic multiple-choice academic benchmarks, the evaluations tested complex, decomposed software workflows containing dozens of conditional branching points.
The Pareto frontier in Figure 4 demonstrates the dramatic separation between model classes:
- The Speed Gap: On complex enterprise decision graphs, frontier LLMs took between 3.2 and 45 seconds per decision chain due to sequential autoregressive token generation. Jev completed identical workflow graphs in 70 to 500 milliseconds, representing a 40x to 193x speedup.
- The Economic Chasm: Because Jev bills only for input tokens at $0.042 per million tokens ($42 per billion tokens) and offers output decisions for free, overall workflow execution was up to 444.6 times cheaper than calling frontier models.
- Real-Time Robotics and Gaming: To prove Jev’s low-latency capabilities, TypeSafe engineers built an AI agent that plays the original video game Doom in real time. The agent receives structured game state tensors and issues movement and weapon firing decisions ten times per second. Running an AI model at ten queries per second continuously would bankrupt a startup using GPT-4o; with Jev, the entire game bot costs roughly $7.00 per hour of continuous execution.
- High-Cardinality Wikiracing: In a Wikiracing benchmark where an AI navigates between Wikipedia articles by clicking hyperlinks, Jev evaluated up to 255 candidate links in parallel, selecting the optimal path in a single pass without suffering from choice hallucination.
This is where the Jevons Paradox takes hold. In 1865, English economist William Stanley Jevons observed that James Watt’s more efficient steam engine did not decrease England’s coal consumption; instead, by making steam power dramatically cheaper, it unlocked thousands of new industrial uses, causing overall coal consumption to skyrocket. By making machine-native decisions fractions of a cent and sub-100 milliseconds, TypeSafe AI is positioning System One models to replace millions of hand-written heuristics, database triggers, and cron jobs across global software infrastructure.
Jagged Edges: Knowing Where Jev Falls Short
Bottom Line Up Front: In its current release (jev-1.13), Jev is restricted to text and JSON states, enforces a 255-option cardinality ceiling on choices, and cannot generate natural language prose.
An honest engineering assessment requires understanding a tool’s limitations. In its initial public version (jev-1.13), Jev has several jagged edges you must account for in production design:
- Text and JSON State Only: Jev currently evaluates strings, JSON payloads, and arrays of text. It does not accept image embeddings, audio streams, or video frames. If your pipeline requires visual OCR verification, you must preprocess the document using an extraction model (like Docling) before passing the extracted text state to Jev.
- 255 Option Cardinality Ceiling: Choice questions support a maximum of 255 candidate options in a single call. If you need to classify across thousands of categories (such as deep patent hierarchies or global product taxonomies), you must use hierarchical beam search, cascading from broad divisions to narrow classes across two successive requests.
- Non-Generative by Design: If your user expects an email draft, a synthesized report, or an interactive chat response, Jev cannot generate it. You must route the decision to a conversational model like Claude or GPT-4o once Jev has completed the initial classification.
Summary and Next Steps
The release of Jev and System One models marks a pivotal transition in the evolution of artificial intelligence. For four years, developers have tried to bend conversational chatbots into brittle software decision engines. By separating System 1 fast, calibrated decisions from System 2 slow deliberate reasoning, the industry has finally established an interface contract that software can depend on.
To begin integrating System One models into your architecture:
- Audit your codebase for brittle regular expressions, fragile string matching routines, and slow LLM JSON extraction calls.
- Install the official Python SDK using
pip install typesafe-sdkand explore the interactive API console at console.typesafe.ai. - Structure your data into clean, declarative state objects and test your first triage workflow using 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.
