Disclosure: this article is based on TypeSafe AI’s launch post and documentation as reported by DataCamp, The New Stack, VKTR and others. We have not run Jev ourselves, and at launch there were no independent evaluations; speed, cost and accuracy figures are TypeSafe’s own.
TypeSafe AI launched Jev on September 15, 2026, after two years in stealth. It is the first of what the company calls System One models: AI models that take unstructured program state as input and return typed, probabilistic decisions your code can act on directly, instead of generating text one token at a time.
The honest summary: TypeSafe Jev is not a chatbot and not a general-purpose model, and judging it against GPT or Claude misses the point. It is built for the high-volume, repetitive decisions inside software, such as routing a ticket, scoring a lead or choosing the next step in a workflow, where the possible answers are known in advance. For that narrow job, TypeSafe claims it is dramatically faster and cheaper than language models and cannot produce malformed output. The catch is that “cannot hallucinate” means it always returns a valid answer, not that the answer is always right.
Table of Contents
- What TypeSafe Jev Is
- Why TypeSafe Jev Is Called a System One Model
- How TypeSafe Jev Works
- TypeSafe Jev Pricing and Speed
- What “Cannot Hallucinate” Really Means
- The Structured-Output Comparison
- TypeSafe Jev Adoption: The Vercel Numbers
- Where TypeSafe Jev Fits in a Stack
- TypeSafe Jev vs GPT-6 Luna’s Decisions API
- TypeSafe Jev Limits and Open Questions
- How to Trial TypeSafe Jev
- Who Should Use What
- FAQ
- Verdict
- Sources and Further Reading

What TypeSafe Jev Is
TypeSafe AI is a San Francisco lab founded in 2024. Its chief executive, Diogo Almeida, is a former OpenAI researcher who worked on InstructGPT and the reinforcement learning from human feedback techniques behind ChatGPT, which is why launch coverage called him a ChatGPT co-creator. The company came out of stealth alongside a $40 million seed round led by the venture firm DCVC, according to VKTR.
Jev, named after the Jevons paradox according to Dealroom, does one thing. You describe a situation and define the shape of the answer you want: a choice from a list, a score in a range, a yes or no, a probability. TypeSafe Jev returns exactly that, with a calibrated confidence attached.
DataCamp gave a clear example. To route a support ticket, you might define a Choice over billing, technical, sales and spam, plus a Score for urgency from 0 to 100, and Jev fills in both in one pass. There is no JSON to parse and no risk of the model writing a paragraph instead.
It is proprietary, not open-weight. At launch it was in early access from a waitlist at typesafe.ai, and it has since appeared on OpenRouter, listed on September 18, and Vercel’s AI Gateway. FreeAPIHub reported the version as Jev 1.13 in September.
Why TypeSafe Jev Is Called a System One Model
The name comes from Daniel Kahneman’s book Thinking, Fast and Slow, which distinguishes fast, intuitive System 1 thinking from slower, deliberate System 2 reasoning. Language models with long chains of thought are, in this framing, System 2 machines: slow, verbose and good at open-ended problems.
TypeSafe’s argument is that most decisions inside software are System 1 decisions. Is this email spam? Which queue does this request belong in? Should this transaction be flagged? These need to be fast, consistent and cheap, and they do not benefit from a model reasoning aloud for paragraphs.
The New Stack’s headline captured Almeida’s view bluntly: sequential, token-by-token language models are poorly suited to what computers actually need from AI. Whether or not you accept the strong version of that claim, the weaker version is hard to dispute. Using a frontier chatbot to classify millions of records is like hiring a novelist to sort the post.
How TypeSafe Jev Works
Architecturally, TypeSafe Jev is a real departure from a transformer language model, DataCamp reported. Three pieces matter.
Typed outputs. Valid outputs are defined in a schema before the model runs. TypeSafe’s documentation describes question primitives such as Choice and Score. Because the model can only fill those slots, it cannot return something outside the schema.
Parallel sampling. Instead of generating tokens one after another, Jev uses what TypeSafe calls a parallel sampler that produces all outputs in a single query. That is the main source of the speed.
Calibrated training. TypeSafe trains with a method it calls Reinforcement Learning for Calibrated Decisions, or RLCD, positioned against the RLHF and RLVR methods used for chat models. The goal is that when Jev says it is 80% sure, it is right about 80% of the time. DataCamp noted that standard language models are notoriously overconfident even when prompted to give probabilities, which is why calibration is built into Jev rather than added afterwards.
The result is a model whose output a program can branch on directly. High confidence: act. Low confidence: escalate to a person or a larger model.
TypeSafe Jev Pricing and Speed
| Item | TypeSafe’s figure |
|---|---|
| Input price | $0.042 per million tokens |
| Output price | Free |
| End-to-end latency | 70 to 500 milliseconds |
| Speed versus frontier LLMs | 20 to 200 times faster |
| Cost versus frontier LLMs | 40 to 400 times cheaper |
| Structured output error rate | 0% |
The New Stack reported the launch post’s headline figures as 20 to 200 times faster and 40 to 400 times cheaper, with output tokens free. DataCamp cited a 40 to 200 times speed range in places; the exact multiplier depends on the comparison.
Free output makes sense given what the model produces. A decision is a handful of values, not a page of text, so output costs almost nothing to generate. You pay for reading the input, which is the state you want a decision about.
For perspective, GPT-6 Luna, one of the cheapest capable language models, costs $0.10 per million input tokens and $0.50 per million output. TypeSafe Jev’s input price is less than half of that, with no output charge at all.
What “Cannot Hallucinate” Really Means
TypeSafe’s boldest claim is that Jev cannot hallucinate or produce type errors. It is worth being precise about what that guarantees.
Because valid outputs are defined in the schema in advance, Jev cannot invent a category that does not exist, return a number outside the allowed range or produce malformed data. In that sense, it cannot hallucinate. What it can still do is choose the wrong valid option. As one widely shared commentary put it, Jev cannot produce an invalid type or out-of-schema output, but it can still make the wrong decision.
StartupHub made the same point: zero hallucinations means a guaranteed schema match, not a zero error rate. That distinction matters for anyone designing a system around the model. A ticket can still be routed to the wrong team. A transaction can still be scored too low. The guarantee removes a whole class of engineering problems, malformed output, retries and parsing failures, but not the need to measure accuracy.
The calibrated confidence is the other half of the safety story. If the probabilities are honest, you can set thresholds: act automatically above 95%, send to a person below 70%. That is only as good as the calibration, which needs checking on your own data.
The Structured-Output Comparison
TypeSafe published a comparison of how often models produced invalid structured output on its test. DataCamp reported the figures:
| Model | Structured output error rate |
|---|---|
| TypeSafe Jev | 0% |
| OpenAI’s Luna and Terra models | 0.58% |
| Claude Opus 5 | 5.73% |
| Claude Haiku 4.5 | 45.5% |
On tool calls, GPT-5.6 Sol had the highest error rate in the comparison at 17.0%. These are TypeSafe’s tests of its own design, compared against older-generation models in several cases, and a schema-constrained model will naturally score zero on a test of schema errors. The comparison shows the engineering pain Jev removes. It does not show which model makes better decisions.
Cloudmagazin’s review summed up the evidence gap: speed and pricing figures come solely from the vendor, and independent measurements were lacking at launch.
TypeSafe Jev Adoption: The Vercel Numbers
Early demand was striking. Vercel said that within 24 hours of launching on its AI Gateway, Jev reached more than twice as many paid teams as any previous model launch, making it the fastest-adopted model in the gateway’s history, The New Stack reported. Tech Insider reported that nearly 13% of all paying teams on the gateway used it within that first day.
There is a caveat Tech Insider was careful to include. During that period, Jev was available free through a promotion that ran until September 25, according to Vercel’s own announcement, which lowered the barrier to trying it. Trying a free model is not the same as running it in production. The adoption figures show strong curiosity; sustained usage is the number to watch.
Where TypeSafe Jev Fits in a Stack
The clearest picture of the intended architecture came from Maxim’s explainer: a two-tier stack, where narrow, high-volume decisions move to a System One model while generation stays with a language model.
Good candidates for TypeSafe Jev share three traits. The possible answers are known in advance. The decision happens many times, often continuously. And speed or cost matters more than explanation. Examples include:
- Routing support tickets, emails or documents to the right queue.
- Scoring leads, risk or urgency.
- Moderating content against a fixed policy.
- Choosing the next step in an agent workflow from a known set of actions.
- Extracting a field or flag from messy input.
- Deciding whether a case needs a human.
Poor candidates are anything open-ended: writing, summarising, explaining, coding or answering questions where the answer space is not fixed. Those stay with language models.
The most interesting use may be inside agents. Many agent loops spend a lot of tokens deciding what to do next. Handing that decision to a fast, typed model, and reserving the language model for steps that need generation, could make agents both cheaper and more predictable.
TypeSafe Jev vs GPT-6 Luna’s Decisions API
TypeSafe is not alone in seeing this market. OpenAI’s Decisions API, which reached general availability on October 22 and runs only on GPT-6 Luna, also returns typed answers such as predicate probabilities, choices or scores instead of free text, with up to 400 questions per request.
| Dimension | TypeSafe Jev | GPT-6 Luna Decisions API |
|---|---|---|
| Underlying model | Purpose-built non-generative model | A small language model with a typed interface |
| Price | $0.042 per 1M input, free output | Luna rates: $0.10 input, $0.50 output per 1M |
| Speed claim | 70 to 500 ms end to end | OpenAI claims 10x faster than its Responses API |
| Calibration | Trained specifically with RLCD | Probabilities from a general model |
| Ecosystem | New vendor, early access | Inside OpenAI’s platform |
The two approaches converge on the same interface from opposite directions. OpenAI wraps a language model in a typed API. TypeSafe built a model that only produces typed answers. If you already run on OpenAI, the Decisions API is the easier test. If you want the lowest cost and latency and are willing to add a vendor, Jev is the one to benchmark.
TypeSafe Jev Limits and Open Questions
Several questions remain open. Independent benchmarks of decision accuracy, rather than schema errors, were missing at launch. Calibration claims need testing on real data, since a model that is well calibrated on one domain can be overconfident on another.
It is also a young company with a proprietary model. Pricing at launch may not be pricing in a year, and early access means limits and availability can change. Runware’s creator page still listed Jev as coming soon at the time of writing, a sign that distribution is still rolling out.
And the category itself is unproven at scale. TypeSafe argues that most production AI does not need text generation. That is plausible for many workflows, but the industry has spent years building around language models, and switching parts of a pipeline to a new model class takes engineering effort that only pays off if accuracy holds up.
How to Trial TypeSafe Jev
A fair trial is straightforward because decisions are easy to score. Pick one decision your product makes at volume, such as ticket routing. Collect a few hundred historical examples with known correct answers. Define the schema, run them through TypeSafe Jev and through your current approach, and compare three things: accuracy, latency and cost per decision.
Then test calibration. Group the predictions by confidence and check whether the high-confidence ones are actually more accurate. If they are, you can automate above a threshold and escalate below it. If not, the confidence scores are not yet trustworthy for your data.
Keep a fallback. Route low-confidence cases to a language model or a person, and log every decision so you can audit mistakes. A typed answer is easier to audit than a paragraph, which is one of the quieter advantages of the approach.
Who Should Use What
| If you are | Start with | Why | Link |
|---|---|---|---|
| Making millions of routing or scoring decisions | TypeSafe Jev trial | Built for fast typed decisions at low cost | Read the guide |
| Already on OpenAI | GPT-6 Luna Decisions API | Same interface idea, no new vendor | See Luna |
| Needing explanations or generated text | A language model such as Claude Haiku 5.5 | Jev does not write text | See Haiku 5.5 |
| Building agent workflows | Jev for step selection, an LLM for generation | Two-tier stack cuts cost and variance | See the architecture |
Frequently Asked Questions About TypeSafe Jev
What is TypeSafe Jev?
An AI model from TypeSafe AI that returns typed decisions with calibrated probabilities instead of generating text. TypeSafe calls it the first System One model.
When was it launched?
September 15, 2026, when TypeSafe AI came out of two years in stealth with a $40 million seed round led by DCVC.
How much does it cost?
At launch, $0.042 per million input tokens, with output tokens free. TypeSafe reports end-to-end latency of 70 to 500 milliseconds.
Can it really not hallucinate?
It cannot return an answer outside the schema you define, so it never produces invalid types or invented categories. It can still choose the wrong valid answer, so accuracy must be measured.
Where can I use it?
Through TypeSafe’s early access, OpenRouter and Vercel’s AI Gateway. It is a proprietary model, not open-weight.
Who founded TypeSafe AI?
Diogo Almeida, a former OpenAI researcher who worked on InstructGPT and the RLHF techniques behind ChatGPT, leads the San Francisco company, founded in 2024.
Verdict
If your software makes the same kind of decision thousands or millions of times, TypeSafe Jev deserves a trial. The typed output removes parsing failures entirely, the price is tiny, and calibrated confidence gives you a clean way to decide when to automate and when to escalate.
The honest caveat is that every performance figure at launch came from TypeSafe itself, “cannot hallucinate” means a schema guarantee rather than perfect accuracy, and the company and its model are both new. The early Vercel adoption numbers were boosted by a free promotion.
Next step: take one high-volume decision in your product, gather a few hundred labelled examples, and compare TypeSafe Jev with your current approach on accuracy, latency, cost and calibration before moving anything into production.
Sources and Further Reading
- DataCamp: Jev, the System One model, for architecture, pricing and the structured-output comparison.
- The New Stack: System One models, for the launch claims and Vercel adoption.
- VKTR: ChatGPT co-creator launches TypeSafe, for the company and funding.
- Maxim: what is Jev, for the two-tier architecture.
- TechJack Solutions: model breakdown, for documentation details and evidence limits.
On this site: compare the Decisions API in GPT-6 Luna, see a fast small LLM in Claude Haiku 5.5, cut costs with LLM API cost optimization, and build agent workflows with the best MCP servers.

