On September 15, 2026, after two years in stealth, TypeSafe AI shipped something the current wave of AI releases had not produced: a model that writes nothing. It is called Jev. Ask it a question and it does not compose an answer. It returns a typed decision your software can act on, along with the probability behind it.
The company was founded by Diogo Almeida, who worked on RLHF and the research behind ChatGPT at OpenAI. Someone from the team that made chat models what they are today has now shipped a model class built in the opposite direction. He announced it himself, and the post passed 36 million views:
Diogo Almeida: announcing Jev (September 15, 2026)
The opening question is the company’s entire thesis: why superhuman chat models never produced the automation everyone expected.
What Jev Actually Is
Jev is the first public member of what TypeSafe calls System One Models. The name points at Daniel Kahneman’s fast, intuitive System 1 thinking. The model’s own name comes from economist William Stanley Jevons, whose paradox showed that making coal more efficient increased consumption rather than reducing it.
The mechanic is simple: you send a state plus typed questions about it. Jev evaluates every question in a single pass, in parallel and in isolation, and returns typed answers with their probability distributions. There is no string to parse, no schema to validate, no chance of a broken JSON body or an invented enum value.
TypeSafe’s own framing is the clearest one: treat Jev as a frontier-intelligence function call. Unstructured state goes in, typed probabilistic decisions come out.
RLCD, the Training Method
LLMs are trained with RLHF (reinforcement learning from human feedback) or RLVR (reinforcement learning with verifiable rewards). Both optimize for something a human prefers or a checker can verify.
TypeSafe trains with RLCD: Reinforcement Learning for Calibrated Decisions. The target is different. It optimizes for probabilities that are honest. Calibration means that when the model says 0.9, it is right roughly nine times out of ten.
That sounds like an academic detail and it is the whole point. As Almeida puts it, if a model can do a task 95% of the time but never tells you when you are in the other 5%, you cannot automate that task.
Where the Speed Comes From
When you ask an LLM for structured output, it does two jobs at once: it decides, and then it spells the decision out in JSON, character by character. The braces, the field names, the commas are all generated tokens. Each one depends on the last, so the work serializes and the hardware idles.
Jev has nothing to spell. It reads the state once, evaluates every question you defined in the same pass, and hands back probabilities directly. With no characters to emit, the sequential bottleneck disappears. That is what TypeSafe means by a new sampler: produce the whole output in parallel instead of queueing it.
The practical consequence: an LLM call’s latency is dominated by how much it writes, while Jev’s is dominated almost entirely by how much it reads. Going from three questions to fifteen barely moves the clock or the bill.
The launch thread reached 1,900 points and 499 comments, and Almeida answered questions all day as CompleteSkeptic. Three replies explain more than the launch post does:
Asked whether a string output type would make it an LLM again, and whether output would then cost the same, he gave the technical reason output is free: “strings (and all sequential data structures) are not allowed at all - this is how we make sure all outputs can be computed in parallel (thus no output token cost)” (comment ).
Asked whether Jev is a general model or something you have to train on your own data, the answer was three lines: “1. yes a general model, 2. no training at all, 3. but it is focused on ‘System 1’ tasks” (comment ). No fine-tuning, zero-shot, but scoped to human-judgment work rather than mathematical reasoning.
Pressed on the self-reported benchmarks, he pointed somewhere concrete: evaluations use Astra and Fable as the reference, and evals.typesafe.ai publishes example traces comparing Jev against opus and sol (comment ).
Full thread: Introducing System One Models and Jev .
Three Question Types: Choice, Score, Noul
The API rests on three primitives, and all three can be mixed in a single request.
| Question type | What it asks | What it returns |
|---|---|---|
| Choice | Which of these options? | choice, probabilities, confidence |
| Score | Which level? | score, legend, probabilities, confidence |
| Noul | Is this true? | noul (0 to 1) |
Choice picks one of your options and gives you the probability of each. Score rates the state against ordered levels, and the score can land between two of them. Noul is a yes/no question returning the probability that the answer is yes: near 1 is a strong yes, near 0 a strong no, near 0.5 means the model does not know. Noul carries no separate confidence value because the probability already says it.
The detail that matters most: questions are evaluated in parallel and in isolation. Adding questions barely changes response time, and they cannot contaminate each other. The context rot you get from stuffing one long prompt is structurally impossible here.
Calling It
There is one endpoint:
POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer <API_KEY>
Content-Type: application/json
A real request that grades one support ticket on three dimensions at once:
{
"state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
"model": "jev-latest",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this",
"criteria": {
"billing": "Payment or subscription issues",
"technical": "Bugs or integration problems",
"sales": "Pricing or account questions"
}
},
"frustration": {
"type": "score",
"instructions": "How frustrated the customer appears",
"criteria": [
"Calm, just stating facts",
"Frustrated but civil",
"Very angry, strong language"
]
},
"is_urgent": {
"type": "noul",
"instructions": "The message conveys urgency or time-sensitivity"
}
}
}
Nothing in the response needs parsing:
{
"model": "jev-latest",
"answers": {
"department": {
"type": "choice",
"choice": "billing",
"probabilities": { "billing": 0.84, "technical": 0.159, "sales": 0.001 },
"confidence": 0.596
},
"frustration": {
"type": "score",
"score": 1.035,
"legend": { "0": "Calm, just stating facts", "1": "Frustrated but civil", "2": "Very angry, strong language" },
"confidence": 0.842
},
"is_urgent": { "type": "noul", "noul": 0.999 }
},
"usage": { "input_tokens": 312, "output_tokens": 48 }
}
There is an official Python SDK (3.10+):
pip install typesafe-sdk
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
client = TypeSafeClient()
response = client.system_one(
state=ticket,
questions={
"department": Choice(
instructions="Which team should handle this",
criteria={
"billing": "Payment or subscription issues",
"technical": "Bugs or integration problems",
"sales": "Pricing or account questions",
},
),
"is_urgent": Noul(instructions="The message conveys urgency"),
},
)
print(response.answers["department"].choice) # "billing"
print(response.answers["is_urgent"].noul) # 0.999
A JavaScript SDK ships too. If you would rather not write code first, paste any text into the playground at console.typesafe.ai/playground and add questions there; API keys come from the same console. The error codes are familiar: 401 bad key, 422 validation failure, 429 rate limit, 529 overloaded.
Wiring Confidence into Code
This is where Jev separates itself. The confidence value collapses the shape of the probability distribution into one number. Concentrated on one option means high confidence, spread out means low.
TypeSafe’s suggested pattern has three bands: act automatically on high confidence, ask for confirmation on medium, route to a human on low. The threshold should scale with what the action costs if it is wrong:
action = response.answers["action"]
if action.confidence < 0.5:
route_to_human(user_message) # genuinely unsure, do not guess
elif action.choice == "check_balance":
show_balance(account_id) # low stakes, recoverable
elif action.choice == "approve_transfer":
if action.confidence > 0.9:
confirm_then_execute(account_id) # high stakes, high confidence
else:
ask_user_to_confirm(account_id)
Approving a transfer and showing a balance do not have to share a threshold. Your code encodes the risk tolerance, not a paragraph of prompt text.
Speed and Cost, with Real Numbers
| Item | Jev | Frontier LLMs |
|---|---|---|
| Input price | $0.042 / 1M tokens | $0.20 - $10 / 1M tokens |
| Output price | Free | ~5x the input price |
| End-to-end latency | 70 - 500 ms | 3 - 329 seconds |
| Sampling | Parallel, single pass | Sequential, token by token |
| Type errors | None (schema guaranteed) | 0.3% - 45% by model |
| Output | Typed value + probability | Text |
Quoting the price per billion tokens rather than per million is itself the message: $42 per billion input tokens, and decisions come out free, which TypeSafe describes as too cheap to meter.
The 193.6x faster, 444.6x cheaper headline on the home page is an average across four workflows and it is the company’s own measurement. Not independent, but TypeSafe publishes the method and the caveats alongside it.
Read the horizontal axis carefully: it is logarithmic. Jev sits about two orders of magnitude left of its nearest neighbour. On accuracy, opus 5 and sol are a few points ahead. On price, the gap is hundreds of times.
In TypeSafe’s side-by-side demo a single call costs $0.000081 and takes 0.114 seconds, against $0.013880 and 8.566 seconds for GPT-5.6 Terra. To see what that means at your own volume, Jev is now in our LLM cost calculator .
About That “No Hallucinations” Claim
The claim needs one qualifier. Because you define the possible outputs in advance, the model cannot leave the schema. It can be wrong, but it cannot be invalid.
The distinction matters more than it sounds. A malformed tool call in a chat app is an annoyance you retry. The same failure inside a system with latency guarantees, or five layers deep in a dependency chain, is a different kind of problem. In TypeSafe’s published measurements, structured output error rates reach 45.5% for haiku 4.5 and 13.2% for sonnet 5, with opus 5 and fable 5.1 in the 5-8% band. Jev’s share is zero by construction.
What a Real Workflow Looks Like
The simplest of the four workflows TypeSafe published is security alert triage. One alert arrives, code asks three questions about it, combines the answers into a close/queue/act decision, and when it acts, asks eleven more about the state of the incident before selecting a containment action.
The design principle behind it is the one the docs repeat everywhere: one snap judgment per question. Instead of asking the model to “rate this startup pitch,” ask separately about market size, technical feasibility and differentiation, then combine them with a formula you own. When priorities change you edit a coefficient, not a prompt.
The company’s fun demos make the same point. Jev plays Doom off structured game state (data, not pixels), and at ten queries per second that costs roughly $7 an hour. The second demo is Wikiracing: get from one Wikipedia page to another through links alone, choosing between hundreds of options at every step. Jev supports a cardinality up to 255; above that a two-stage system scores first and then picks.
Where It Does Not Fit
Jev is not an LLM and does not replace one. It writes no text, no code, no summaries, no conversation. Questions that need extended reasoning or weigh several independent factors are also the wrong shape; the docs tell you to decompose them instead.
The founder says the same thing in plainer terms:
Diogo Almeida: Jev cannot generate text, that is the trade-off (September 15, 2026)
The historical comparison he adds lands too: swapping sequential computation for parallel is exactly how Transformers left RNNs behind. Jev makes the same move on the output side.
Other things worth knowing before you build on it:
- Early access. The model opened to early access on September 16 through a waitlist, and demand caused API outages in the first days.
- The benchmarks are self-reported. TypeSafe states plainly that its model capabilities team built the workflows, that evals run from the team’s own laptops on the West Coast, and that reference answers are the average of GPT-6 Astra and Fable 5.1. Publishing example traces at
evals.typesafe.aiat least makes case-by-case checking possible. - Price sustainability is unproven. The company says it cannot prove the pricing is unsubsidized and expects prices to fall rather than rise.
- You own the thresholds. The model gives you a probability; what you do with it is a design decision.
- Jevons paradox. The name is a forecast, not a joke: cheaper decisions are expected to increase total token consumption, not reduce it.
Early independent reports are encouraging but mixed. Per TechCrunch, Vercel measured 5-18x faster safety classification. Bryo AI, classifying email, found it 10-20x cheaper than Gemini while rating Gemini slightly more accurate; what sold them was getting a real probability back.
The Ecosystem Moved Fast
In the first 72 hours LangChain shipped an integration (TypeSafeClassifier in langchain_typesafe), the model appeared in the OpenRouter and Cloudflare catalogues, and liteLLM added passthrough support. On Hacker News there is already mini-jev, which imitates the interface on top of a local LLM, plus open alternatives aimed at your own GPU.
TypeSafe also published a skill for coding agents. On Claude Code it is two commands:
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai
Porting an Existing LLM Call
If you already have a classification call in production, the migration does not start with translating the prompt:
- Split the prompt into questions. Every “also evaluate whether” clause becomes its own question. Three to five atomic questions beat one giant instruction on both consistency and cost.
- Pick a type per question. Closed list means Choice, ordered levels mean Score, yes/no means Noul. Anything that still needs free text stays with the LLM.
- Describe your options.
criteriacan be left empty, but one sentence explaining what each option means lifts accuracy noticeably. - Move thresholds into code. The “say unsure if you are not certain” line in your prompt becomes a confidence threshold.
- Shadow it for a week. Run both systems side by side and collect the disagreements. Even TypeSafe’s own evaluation uses the average of strong models as the reference rather than a single ground truth.
A hybrid is often the right answer: let Jev classify and route the request, and call an LLM only at the step that genuinely needs prose. TypeSafe’s intent routing pattern describes exactly that.
Who Should Care
The scenarios worth trying today are specific: routing inbound requests, scoring fraud risk, judging and guardrailing LLM output, detecting jailbreaks, map-reducing labels over large datasets, and real-time loops in games or robotics where 100 milliseconds is the budget.
Anywhere you are currently begging a model to “classify this and reply with JSON only,” Jev is likely the better tool. If you want an assistant, an editor, a code generator or a content engine, it is the wrong address; that work still belongs to models like GPT-5.6 and Claude Opus 5 .
Maybe the fairest reading is that these two model classes are not competitors at all. LLMs talk to people, System One models talk to software. Removing the translation layer between them is the piece automation has been missing.