What Is Jev? TypeSafe AI's System One Model (2026)

On September 15, 2026, US startup TypeSafe AI opened early access to Jev, a model that generates no text at all. You hand it program state and typed questions; it returns typed decisions with probabilities. The company is led by Diogo Almeida, a co-author of the InstructGPT paper that ChatGPT was built on. This guide walks through Jev and the new category the company proposes for it — the System One model — based on its official documentation.

What Jev is

Jev is a decision-only model, released as "the first System One model." The current version is jev-1.13. The difference from a large language model (LLM) is the output format.

An LLM generates prose for people to read. When you need structured data, you still make it write text and then parse that text in your code.
Jev generates no text. It takes program state and typed questions, and returns typed values, probability distributions and a confidence figure.

TypeSafe frames this as fixing a mismatch: coercing a text-generation system into emitting structured decisions. With Jev there is nothing to parse and nothing to retry — the returned value goes straight into your branch, your sort or your router.

What "System One" means

The name comes from Daniel Kahneman's fast and slow thinking. Extended reasoning and writing are System 2 work, which is what LLMs are good at; snap judgments are System 1, and that is what Jev is built for. A useful mental model: anything a domain expert would decide in five seconds, run at high volume and low latency.

The three question types

Jev takes three kinds of question, and you can mix them in a single API call. Questions are evaluated in parallel and in isolation against the same state, and per the documentation, adding questions barely changes response time.

Choice: pick one option from a defined set. You get back the chosen option, the probability distribution over all options, and a confidence value. Good for routing tickets or classifying document types. The docs recommend including an "other" option when your list may not be exhaustive.
Score: place the state on an ordered set of levels (for example: calm and neutral, concerned but civil, very angry). The score can land between levels. Good for severity, satisfaction or skill level.
Noul: answer a yes/no statement with a probability between 0 and 1. Near 1.0 is a strong yes, around 0.5 means the model cannot tell. Good for "is this a bug report" or "is this a refund request."

Every answer also carries a confidence value describing how peaked the distribution is. That is the hook for sending only the uncertain cases to a human or an LLM.

Speed and price (vendor figures)

End-to-end response time of 70-500ms, which the company describes as 40-200x faster than frontier models at equivalent intelligence for this class of task
$0.042 per million input tokens ($42 per billion). Output tokens are free; billing is on input only
Rate limits of 250,000 tokens per second and 1,200 requests per minute, described as adjusting dynamically under demand
64k tokens per request, with state plus the longest single question capped at 32k
Text input only — a string, a JSON object or an array of text values. No image, audio or video input

TechCrunch reports that Vercel measured 5-18x faster results with better accuracy on a classification task, and that Bryo AI found Jev 10-20x cheaper than Gemini for email classification. These are vendor and customer figures, so treat them as a reason to benchmark on your own data rather than as a result you can assume.

How to read "it cannot hallucinate"

Jev is marketed as producing no type errors and no hallucinations. What that guarantees is the shape of the output: you will never get a value outside your option list or malformed JSON, which is why the parsing and retry code disappears.

It does not mean the judgment is always right. What comes back is a calibrated probability, and a 0.7 answer is wrong roughly 30% of the time by design. The documentation itself recommends routing on confidence. Keeping "does not invent facts" separate from "is always correct" is the single most important distinction when evaluating the model.

The weaknesses TypeSafe publishes

TypeSafe documents where jev-1.13 is weak. For an adoption decision, this is the most useful page it publishes.

Arithmetic and counting are unreliable: character counts, occurrences and list lengths degrade as input grows. The docs state plainly that Jev is not a calculator
Dates and times are shaky: which of two dates comes first, whether one falls inside a window, how far apart they are
Indirection hurts accuracy: questions that require several reasoning hops, properties of properties, or double negatives
Irrelevant context costs accuracy: the more unrelated material in the state, the worse the decision
No text generation: chaining choices to synthesize text is slow and performs poorly
Instructions are read literally: it answers the question you wrote, not the one you meant, so boundary cases belong in the criteria
Adversarial input is not handled: instructions embedded in the state can shift the output
English first: other languages, CJK included, are "handled but not equally well"

If your content is not in English, write the instructions and criteria in English, leave only the material being judged in its original language, and measure accuracy before you commit.

Where it fits

Intent routing: classify an incoming request and send it to the right queue or handler
Priority and severity: score urgency and order the work
Guardrails and monitoring: check agent inputs and outputs against a policy in milliseconds — teams are using it to catch jailbreak attempts
Model routing: cheap model for easy requests, frontier model for hard ones
Re-ranking and retrieval support: reorder candidates, judge relevance
Agent control flow: keep the "what next" decision in your code

Pair it with an LLM, do not replace one

Because Jev cannot write, the productive pattern puts it in front of or behind an LLM rather than instead of it.

Run the high-volume decisions through Jev and escalate only low-confidence cases to an LLM or a person (confidence-gated routing)
Decompose a complex judgment into small questions composed in code instead of one large question
Let the LLM write and let Jev decide

Getting started

Access is early access: create an API key in the console at console.typesafe.ai
There is a Python SDK, a JavaScript/TypeScript SDK and an HTTP API. The default model alias is jev-latest, currently pointing at jev-1.13.0
Authentication uses the TYPESAFE_API_KEY environment variable. An agent skill for Claude Code and Codex is also published
Documentation is English-only, and pricing, rate limits and access terms may change — check the official pages for current conditions before you build on it

Summary

Jev is not the next LLM; it is a different component that covers what LLMs were bad at. It pays off wherever a decision needs no prose — classification, routing, scoring, guardrails — at volume and low latency, and it needs careful testing for arithmetic, dates, generation and nuance in non-English content. A practical first step: find the place in your current workflow where an LLM is only classifying something, swap Jev in, and measure latency, cost and accuracy against what you have.

Sources: TypeSafe AI blog, official documentation, TechCrunch, September 18, 2026. This article reflects public information verified on September 19, 2026.