Why Jev Refuses to Chat: Inside System One Models
Jev skips text entirely, answering only yes/no, choices and scores — yet it's Vercel's fastest-adopted model ever. Inside System One models and the caveats.
On September 15, TypeSafe AI opened early access to Jev, the first of what it calls System One Models. Jev does not write a single word. You hand it a chunk of program state plus a set of typed questions; it hands back a choice, a score or a boolean, each carrying a calibrated confidence between 0 and 1. Within 24 hours it became the fastest-adopted model in Vercel AI Gateway history — nearly 13% of paid teams — and inside 72 hours it was wired into Cloudflare Workers AI, LangChain and Langfuse. The waitlist cleared 140,000 people in under 36 hours.
The real signal here isn't "another model." It's that the invisible decision calls inside agents — routing, classifying, scoring, verifying, guarding — finally have a dedicated supplier that is two orders of magnitude cheaper than a general-purpose LLM. Jev's author, Diogo Almeida, was one of the researchers behind RLHF, the method that made ChatGPT usable. His framing question for the launch: models have been superhuman at chat for years, so where is all the automation?
What It Actually Does: Three Question Types, One Endpoint
Jev exposes a single endpoint. A request carries two things: state (unstructured program state) and questions (a map of typed questions). There are exactly three kinds:
| Question type | What it does | What it returns |
|---|---|---|
| Choice | Pick one option from a list | The selected option + per-option probabilities + confidence |
| Score | Rate against ordered levels | The score + per-level probabilities + confidence |
| Noul | Is this statement true? (boolean) | A probability from 0 to 1 |
from typesafe_sdk import Choice, Noul, TypeSafeClient
client = TypeSafeClient() # reads TYPESAFE_API_KEY
r = client.system_one(
state=ticket,
questions={
"department": Choice(
instructions="Which team should handle this",
criteria={"billing": "Payment issues", "technical": "Bugs"},
),
"is_urgent": Noul(instructions="The message conveys urgency"),
},
)
print(r.answers["department"].choice, r.answers["is_urgent"].noul)Three design details matter. First, every question in a request is evaluated against the same state in parallel — adding questions barely changes response time. Second, a Choice supports up to 255 options, so high-cardinality decisions (picking the next step out of thousands of links, say) don't need to be smuggled through prose. Third, and most practically: every answer ships with a confidence value.
The docs example is instructive. A classification returns billing at a probability of 0.84, but confidence is only 0.596 — because technical still holds 0.159. The recommended pattern is three paths: act on high confidence, review the middle, hand low confidence to a human. Confidence is the product. It turns "I might not know" into a return value, which is the precondition for letting software automate anything that matters.
Where the Two-Order-of-Magnitude Gap Comes From: Parallel Sampling + RLCD
Existing LLMs reason sequentially: one token at a time, each conditioned on the last. Jev swaps in parallel sampling — all possible outputs are sampled in a single query, which TypeSafe describes as extremely efficient and hardware-aware.
On the training side, TypeSafe calls its method RLCD — Reinforcement Learning for Calibrated Decisions — positioning it against RLHF (human preference) and RLVR (programmatically verifiable rewards). RLCD optimizes for epistemically honest probabilities: if the model says 95%, it should actually be right 95% of the time.
Giving up strings buys two hard guarantees. Because output structure and value ranges are defined in advance by the developer, the model cannot produce type errors — TypeSafe stresses this is mathematically impossible and falsifiable by a single counterexample, not an empirical statistic. And since it never generates free text, there is no conventional hallucination surface. The trade-off is equally clear: it will not draft your email. It only decides.
| Dimension | General-purpose LLM | System One model (Jev) |
|---|---|---|
| Optimized for | Human preference / verifiable rewards | Calibrated decision probabilities |
| Input emphasis | Sequential messages (chat) | Structured program state |
| Output | Strings requiring parsing and validation | Pre-defined typed structures |
| Sampling | Sequential, token by token | Parallel, all outputs in one query |
| Latency | 3–329 seconds end to end | 70–500 milliseconds |
| Price | $0.20–$10 per million input tokens; output ~5x input | $0.042 per million input tokens; output free |
| Confidence | Verbal estimates, often overconfident | Calibrated probability on every output |
The naming is worth noting too. The model class borrows from Daniel Kahneman's System 1 — fast, intuitive thinking — while the model itself is named after William Stanley Jevons, the 19th-century economist whose paradox holds that better steam engines increased coal consumption rather than reducing it. TypeSafe's corollary: every order-of-magnitude drop in the cost of intelligence unlocks an order of magnitude more use cases.
The Real Numbers — and the Limits TypeSafe Admits To
Start with what can be cross-checked. Vercel CEO Guillermo Rauch gave an independent figure: on software command safety review, Jev came in up to 18x faster at the 95th percentile than GPT-class models, with better accuracy — Vercel is replacing the GPT-5.6-Luna setup it had been using for production safety review. Vercel's data also shows Jev running for nearly 13% of paid teams by hour 24, more than double the adoption rate of any prior launch, including the GPT-5.6 family. Forbes reported that once you account for real production usage, cost reductions land closer to 100x — not the 400x-plus TypeSafe markets.
Then read the self-disclosure, which I'd argue is more informative than any marketing number. TypeSafe annotated the boundaries of its own claims directly in the launch post:
- The 193.6x faster / 444.6x cheaper figures come from the company's own workflow evals, and the workflows were written by its own capabilities team — TypeSafe concedes some bias may exist;
- The reference answers are the average of GPT-6 Astra and Fable 5.1, which the company admits skews toward OpenAI's and Anthropic's models and "likely underestimates" Jev and DeepSeek;
- TypeSafe cannot prove its pricing isn't subsidized and says only long-term operations will settle that;
- "0% hallucination" is a mathematical guarantee of schema matching, not an empirical measurement;
- The comparison hallucination numbers come from OpenRouter routing statistics, which carry their own selection bias.
Third-party notes point the same way: Bryo AI's CTO found Gemini slightly more accurate but 10–20x more expensive, while Browser Use ran a Zurich-to-London flight search with Jev in 7.1 seconds.
Put together, my read is this: Jev doesn't solve "is the answer right?" It solves "when it's wrong, does it fail in an uncontrollable way?" For a research lab, accuracy is the headline. For a production system, controllability is often the thing that actually kills you — a type error buried three layers deep in a dependency chain costs far more than an answer that wasn't quite smart enough.
The Open-Source Answer Arrived in 48 Hours
Jev is a closed API: no weights, no parameter count, no self-hosting. The method, however, was reproduced startlingly fast.
Bespoke Labs spent two days LoRA-finetuning Qwen3.5-9B on just 2,676 synthetic samples and shipped Bespoke Nimble. On its 324-example held-out set: base Qwen 66.36%, Qwen3.8-27B (3x the parameters) 84.88%, Nimble 90.12%, Jev 93.21%. The key technique is contrastive data curation — slightly mutating one focal fact so the correct answer flips, forcing the model to learn which evidence actually drives the outcome. No probability labels, and no distillation from Jev (which was used for evaluation only). Around 106 ms on an H100, with weights and recipe released under Apache 2.0.
Jared Palmer's Kev goes the opposite direction: a Qwen2.5-0.5B base with only 9.3M trainable parameters, trained in 1 hour 45 minutes on a MacBook, offered in 0.5B through 8B sizes. The cost shows up out of domain — kev-4b scores 0.79 and kev-8b 0.80 against Jev's 0.86, with the gap concentrated in knowledge-heavy tasks (MMLU 0.69–0.75 versus 0.90) and date arithmetic. There's also Simple Jev, which turns ordinary Hugging Face models into typed decision services.
Closing three points in three days tells you the method itself isn't the moat. The interface contract, calibration quality and gateway ecosystem are. For buyers this is good news: decision models will commoditize like databases. What stays scarce is the judgment about which decisions are worth automating at all.
If You Build Agents: Split the Decision Layer From the Generation Layer
The most immediate value here is a two-layer cost structure. Keep frontier LLMs for the generation layer — writing, explaining, summarizing for humans — and move the high-frequency decision layer behind it (routing, classifying, scoring, verifying, guardrailing) onto purpose-built decision models. A single support agent may make a dozen classification calls before it produces one sentence, and none of those calls is visible on a line item. They are billed at frontier prices anyway.
Three practical notes before you refactor anything. One: use confidence as a threshold, and scale that threshold with the cost of being wrong. Misrouting a ticket is fine; auto-approving a payment is not. Two: don't hand knowledge-heavy judgments to a small decision model — Kev's MMLU drop already marks the boundary. Three: watch the evaluation basis. There is no standard decision-model benchmark yet; every number comes from a vendor's own held-out set, and Bespoke itself notes relative performance may differ on other metrics.
This also connects to a broader thread we've followed: the design of an AI foundation that survives model churn, in the age of model fatigue, and the argument that context, not model weights, is the scarce asset in the interface-layer war. Jev adds a footnote: once a judgment costs almost nothing, the thing to re-audit isn't the model leaderboard — it's how many judgments in your workflow never needed language in the first place, yet got written as prompts.
