In less than 72 hours, TypeSafe AI launched Jev. A new model that skips text generation to achieve up to 200x faster and 400x cheaper performance than frontier models. People are calling it “the future” already.
My biggest problem as an indie dev is the rising cost of frontier models. Many other devs feel the same. Go check out the hate comments on social media.
I dumped Claude a few weeks ago because of how expensive Fable 5.1 is. When OpenAI Astra was released, Tibo gave us a handful of weekly resets, which was super cool! Even then, it was not enough now that the weekly resets are gone, it is not enough.
OpenAI needs a lot of improvement in terms of token management. Anthropic too. We are constantly charged for thousands of input tokens and verbose conversational output tokens when all our code actually wanted was a single boolean flag.
Tbh, I do not really mind the speed. Coding models are already fast enough for my coding use case. Cost is just not acceptable anymore. That is why I find Jev a very interesting model. It promises the biggest advantage I have been begging for, which is near-zero cost for structured decisions.
I spent time digging into the architecture, the benchmarks, and the early developer reactions.
What is Jev?
Jev is the first public entry in a category TypeSafe AI calls System One models.
The company was founded by Diogo Almeida, a former OpenAI researcher who worked on InstructGPT and the early foundations of Reinforcement Learning from Human Feedback.
“I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev”
To understand why this model exists, you have to look at the name and the underlying cognitive theory.
The name comes from William Stanley Jevons, the 19th-century British economist famous for the Jevons paradox. In 1865, Jevons observed that when steam engines made coal consumption vastly more efficient, overall coal usage did not decrease. It exploded. Making a resource radically cheaper made people deploy it everywhere.
TypeSafe is betting the exact same economic rule will apply to software decisions.
The term System One comes directly from Daniel Kahneman’s cognitive framework in Thinking, Fast and Slow.
Human cognition operates on two gears.
- System 1 is fast, automatic, subconscious, and intuitive. When you glance at an angry facial expression or answer what two plus two equals, you do not sit down with scratch paper. Your brain surfaces the answer instantly.
- System 2 is slow, analytical, deliberate, and effortful. If someone asks you to multiply seventeen by twenty-eight, you pause. You hold intermediate states in your working memory and calculate step by step.
Every major frontier language model we use today behaves strictly like System 2. They reason out loud, calculating one word after another in a linear sequence.
System 2 (Frontier LLMs):
Input Context -> Token 1 -> Token 2 -> Token 3 -> ... -> Verbose JSON Output
Cost: High ($3 - $15 per million tokens)
Latency: 3 to 15 seconds
System 1 (Jev Architecture):
Input State + Bounded Questions -> Single Parallel Forward Pass -> Typed Probabilities
Cost: Near Zero ($0.042 per million input, $0 output)
Latency: 70 to 300 milliseconds
Jev does not write essays for you. It does not produce marketing copy, and it will not write your next software feature. It takes unstructured state, evaluates bounded questions against that state, and returns typed decisions with calibrated probabilities.
How Jev works
The technical bottleneck of modern language models sits in how transformers generate tokens.
A standard transformer is autoregressive. If you ask a chat model to classify a customer email, the model has to project its internal vector state across a vocabulary of over 100,000 potential tokens.
It samples one token, adds that token back into the context window, and runs another entire forward pass through dozens of GPU transformer layers just to predict the next word.
If your model produces a 60-token JSON response, your hardware runs 60 separate sequential passes. Memory bandwidth bounds the process. Step 40 cannot physically run until step 39 finishes.
Check out the side-by-side comparison of Jev against an LLM:
Jev breaks that autoregressive loop by constraining the candidate answer space before inference begins.
Instead of predicting open-ended words across an enormous vocabulary, Jev evaluates three explicit typed primitives against an ingested state.
Jev’s three types of supported questions. Image from Langchain
- Choice: You provide a question and a closed set of options, up to 255 items per call. Jev evaluates the input state against those options in parallel and outputs the winning label alongside an exact confidence score.
- Score: You establish a continuous scale or an ordered rubric, like evaluating customer sentiment from one to ten, or grading technical debt from low to critical. Jev places the state on that scale and returns the position with confidence metrics.
- Noul: This is a binary probability primitive, which Vercel surfaces simply as a boolean. It determines whether a specific condition is true or false, returning a raw floating-point probability between 0.0 and 1.0.
Because the answer candidates are strictly defined, Jev does not generate arbitrary strings. It processes all questions against the state in a single, parallel forward pass.
// How a System One evaluation call looks in TypeScript
import { typesafe } from "@typesafe/sdk";
const decision = await typesafe.decisions.create({
model: "typesafe/jev-1.13",
state: {
userTier: "free",
daysActive: 4,
lastAction: "export_csv_failed",
ticketText: "My export button is broken and I have a client meeting in an hour!"
},
questions: {
urgent: {
type: "noul",
instruction: "Does the user express urgent time sensitivity?"
},
intent: {
type: "choice",
options: ["bug_report", "billing_inquiry", "feature_request", "churn_risk"]
},
churnRisk: {
type: "score",
range: [1, 5],
rubric: "1 means completely satisfied, 5 means actively looking to leave"
}
}
});
Here’s an easy to understand animation of how Jev works.
This architecture sparked a debate on the LocalLLaMA subreddit. Several developers pointed out that this structure looks identical to Natural Language Inference (NLI), a classic NLP task that researchers solved years ago using classification heads on top of BERT or RoBERTa.
In one Reddit post, someone claimed they built this exact setup a year ago with open-weight sequence classifiers.
Reddit: I literally built the Jev architecture one year back. Image by Jim Clyde Monge
I checked the details and found it almost similar to how Jev works, but there are, of course, differences. Fine-tuning a local BERT classifier requires collecting hundreds of labeled training pairs for every single business logic change, hosting dedicated endpoints, and babysitting model drift. Jev brings frontier-grade zero-shot reasoning to arbitrary programmatic questions without requiring a custom dataset or retraining.
Another interesting detail is how TypeSafe trained the model.
They discarded traditional Reinforcement Learning from Human Feedback (RLHF), which encourages models to sound polite and persuasive to human evaluators.
Instead, they developed Reinforcement Learning for Calibrated Decisions (RLCD).
Traditional RLHF:
Objective: Maximize human rater approval
Side Effect: Overconfidence, hallucinations, sycophantic agreement
TypeSafe RLCD:
Objective: Statistical calibration of probability distributions
Result: A 0.85 score means the model is verifiably right 85 out of 100 times
In standard chat models, confidence scores are notoriously unreliable. A chatbot will sound 100 percent convinced of a completely hallucinated citation.
RLCD forces statistical calibration. If Jev evaluates a batch of decisions and assigns them an 80 percent probability, roughly 80 out of 100 of those evaluations will be objectively accurate.
TypeSafe also touts a 0 percent structured output error rate.
It is guaranteed by construction. Because Jev never decodes text tokens, it is physically incapable of emitting broken curly braces, unescaped quotes, or invalid keys.
However, schema validity is not semantic truth. Jev will never break your JSON parser, but if your instructions are poorly phrased, it can still pick the wrong option.
In TypeSafe’s benchmarks, the error rate for Jev is literally 0%.
TypeSafe’s benchmarks on Jev’s error rate. Image by TypeSafe AI
How it achieves 20x to 200x speed
In official workflow evaluations, TypeSafe reports speedups ranging from 19.3x to 193.6x over frontier models.
On live public endpoints like OpenRouter and TypeSafe’s hosted API, measured end-to-end latency tells a very consistent story.
LLMs vs Jev in terms of end-to-end latency. Image by Jim Clyde Monge
One architectural leverage comes from what TypeSafe calls speculative fan-out.
Sources
- TypeSafe AI launched Jevtypesafe.ai
- Tibox.com
- Diogo Almeidax.com
- https://x.com/CompleteSkeptic/status/2099925682726002904x.com
- William Stanley Jevonsplato.stanford.edu
- Jevons paradoxnews.northeastern.edu
- Thinking, Fast and Slowdn790002.ca.archive.org
- autoregressive
