# Jev cannot write. That is the feature and the limit.

> TypeSafe's Jev returns typed decisions instead of prose. How it works, what its confidence means, where it fails, and what our LLM Selector sends to it.

- Published: 2026-09-22
- Last reviewed: 2026-09-22
- Data as of: 2026-09-22
- Article slug: what-is-jev
- Author: [Glevd](https://x.com/glevd)
- Reading time: 12 minutes
- Topics: jev, typesafe, decision-model, llm-selector, classification, system-one
- Data policy: Dated analysis; static benchmark claims are retained.
- Canonical URL: https://benchlm.ai/blog/posts/what-is-jev

Type "Analyze google analytics data for trends and opportunities" into the box at the top of the [models directory](/models), and pause.

Beneath it, a line fills in with the job it read: "Analyze data and write SQL or Python".

Yet the model that read your sentence cannot write one back.

Jev is TypeSafe AI's decision model, released on 15 September 2026. It reads text and answers typed questions with choices, scores or yes-or-no probabilities. It generates no prose. You define the answer space. The model works inside it. Not writing is the feature, and it is also the limit.

We wired it into the description intake for the [LLM Selector](/tools/llm-selector) this month. What follows is what the vendor documents, what we verified ourselves, and what we still have not measured.

## Jev is a model that only fills in forms

TypeSafe calls Jev a System One model, after the fast, intuitive mode in Kahneman's *Thinking, Fast and Slow*. Its [documentation](https://docs.typesafe.ai/concepts/system-one) defines the class in one sentence: models "built to make fast, structured decisions that software can use directly." It does not write replies, produce code or explain itself. You define the possible answers, and it picks.

Every request has two parts. First, the state: the text to judge, whether an email, a support ticket, a log line or a JSON object. Second, the questions, each with a type. Choice picks one option from a list you wrote, up to 255 of them. Score returns a position along a rubric of two to ten levels, including fractional positions between them. Noul asks a yes-or-no question and answers with a probability between 0 and 1. Choice and Score also return a probability distribution and a separate [confidence](https://docs.typesafe.ai/confidence) value describing how concentrated that distribution is. Confidence is not the selected option's probability. Noul returns the probability of yes, with no separate confidence field.

Two design choices separate it from the models we rank. It does not sample a text completion. Where an LLM writes one token at a time, each conditioned on the last, Jev evaluates every question in a single parallel pass, which is where the vendor's speed and price claims come from. TypeSafe describes its post-training method, [Reinforcement Learning for Calibrated Decisions](https://docs.typesafe.ai/introduction/machine-learning-primer), as optimising probabilities against outcomes. In a calibrated model, outcomes assigned 90 percent probability should occur about 90 percent of the time across many predictions. That is a training objective, not a measured guarantee for your task. The name Jev draws on the Jevons paradox: greater efficiency can increase total demand.

As of 22 September 2026, version 1.13 is current. TypeSafe's [model reference](https://docs.typesafe.ai/models) allows 64,000 tokens across the state and all questions, with a second limit of 32,000 for the state plus the longest question. Input is text only, as strings, JSON objects or arrays of text. It reached [OpenRouter](https://openrouter.ai/typesafe/jev-1.13) on 18 September, in beta, as `typesafe/jev-1.13`, served through a Decisions endpoint rather than chat completions, with an output modality the catalog lists simply as "decisions".

## The answer has a different shape from an LLM's

Intelligence is not the comparison that matters. It is the shape of the answer.

|  | A chat LLM | Jev |
| --- | --- | --- |
| Output | Generated text, including prose, code or structured JSON | A choice, score or yes-or-no probability |
| Sampling | Sequential, one token at a time | Parallel, every question in one pass |
| Uncertainty | A generated confidence claim needs validation | Probabilities; Choice and Score also include a separate confidence statistic |
| Output shape | Strict structured-output modes can constrain a supported schema | Defined by the typed questions; still validate the API response |
| Billing | Input and usually output tokens, at the chosen model's rates | $0.042 per million input tokens; no output charge, read 22 September 2026 |
| Can write a sentence | Yes | No |

Sit with the schema row. In our [structured-output evidence run](/blog/posts/test-structured-output) on 14 September, two frontier LLMs returned valid JSON that was still wrong, and one case failed on every repetition because hidden reasoning tokens ate the completion budget. Jev has no completion budget. Its model output does not depend on a generated completion fitting a token budget. TypeSafe's [launch post](https://typesafe.ai/blog/introducing-system-one-models-and-jev) attributes schema correctness to that design. Network failures and malformed API responses still need handling, and a correctly typed answer can still be wrong.

Speed and price come with the vendor's own caveats, which we repeat rather than soften. TypeSafe reports 70 to 500 milliseconds end to end against 3 to 329 seconds for frontier models. Its [workflow evaluations](https://evals.typesafe.ai/), scored against the average of GPT-6 Astra and Claude Fable 5.1 at high thinking, put Jev at 67.8 percent agreement and GPT-5.6 Sol at 74.1, averaging four workflows with equal weight. These are agreements with model-generated labels, not human-scored accuracy. Those headline multiples come from the same table: 0.4 seconds a case against Sonnet 5's 78.1, and $0.0004 a case against Opus 5's $0.1761. The launch post warns that those gains sit toward the upper end of what users should expect and that the vendor's own team designed the workflows. The LLM baseline also returns probabilities, which costs more than asking it for a label alone.

We have not run a speed or accuracy study of our own. Our one live probe on 22 September returned a correct classification, which makes it a smoke test, not a benchmark. Outside tests from the first week are narrower than the headline. On four 300-item classification sets, [Aman Kumar](https://amankumar.ai/blogs/jev-measured) found Jev ahead of GPT-5.6 Luna on three and behind on the 77-way banking-intent set, at median latencies under a second against 1.4 to 5 seconds. Accuracy also depended on the surrounding code. In the [phishing study](https://github.com/anisselbd/jev-phishing-bench), Jev's direct verdict scored 62.6 percent on 2,000 synthetic emails. A logistic regression trained on five Jev signals reached 95.0 percent on a separate 1,000-email test half. A regex baseline reached 91.8 percent on that half. The decomposition used knowledge of the dataset's construction. That is evidence for testing a whole pipeline, not a 95 percent accuracy claim about Jev alone.

## It breaks in nine documented places

TypeSafe publishes its own [list of jagged edges for jev-1.13](https://docs.typesafe.ai/model-jaggedness/jev-1.13). It is more useful than most model cards, so here it is condensed, with what each edge costs the person writing the questions.

| Jagged edge | What the vendor documents | What it costs you |
| --- | --- | --- |
| Literal reading | Takes conditions literally | Implied context is ignored. Write the criteria out |
| Numbers | Unreliable arithmetic | Do not ask it to count, convert or compare magnitudes |
| Dates | Unreliable date ordering | Parse dates in code and ask it only which span is the deadline |
| Indirection | Struggles with indirect questions | One hop per question |
| Irrelevant context | Irrelevant text distracts it | Trim the state before you send it |
| Adversarial content | Hostile input can steer decisions | Enforce permissions in code |
| Contradictions | Conflicting criteria confuse it | Say one thing |
| Invariants | Separate answers can contradict | Recompute in code |
| Generation | Cannot compose useful text | Extract by choosing among spans you already found |

An allowed answer can still be a dangerous one. If your list includes deleting a file or approving a transfer, hostile input can steer Jev toward that action without breaking its type contract. Permissions, confirmation and limits belong in code. A confidence threshold alone does not make an action safe.

Jev can confidently pick the wrong item from a list you wrote. Constraining that list limits the possible outputs. Testing decides whether those outputs are useful.

## Reach for it when the option list is the contract

For a Choice question, the option list defines every possible selection.

Jev cannot pick an item outside that list, and it cannot rescue a list you wrote badly. That single fact decides most of the use cases.

Reach for it when the acceptable answers can be enumerated before the question is asked: which team a ticket goes to, whether a message contains a refund request, how frustrated a customer sounds on a five-point rubric, which of your tools an agent should call next, whether a generated paragraph passed a check. TypeSafe's [patterns](https://docs.typesafe.ai/patterns) are four variations on that theme. Fan out many questions in one call, speculative ones included, and let code decide what mattered. Route on confidence as a second axis, with thresholds tested for the particular task and confirmation for consequential actions. Combine several scores into one. Classify intent and dispatch. Fan-out shares the state across questions in one request. Each extra question still adds billable input tokens. Savings depend on how much shared text would otherwise be sent again.

Do not reach for it when the answer has to be composed. Summaries, replies, patches, translations and explanations of why are System Two jobs in TypeSafe's own framing, and an LLM is still the tool for them. Nor when the state is long and mostly irrelevant, when the decision needs arithmetic, or when you cannot write the options down because you do not yet know what a good answer looks like.

A workflow can use both: Jev to choose a route before an LLM writes, or Jev to check a bounded property after an LLM has written. TypeSafe's pitch is that the deciding step has been priced and timed like a function call. That moves where the LLM sits in the loop. It does not remove it.

## How the LLM Selector reads your job

Our selector existed before Jev. It is a multiple-choice quiz: the kind of work, the job, where the data may be processed, the budget, the input size, what would make a model wrong. The quiz answers and supported setup requirements feed the shortlist computed in code from the public dataset. Other readings, such as usage volume and non-English content, add advice and links without changing the ranking. Since this month, an intake box on the [models directory](/models), the [job pages](/best/for) and the [selector](/tools/llm-selector) fills that quiz in from a sentence.

One Decisions call does it. We send the description as the state and nineteen fixed questions: fourteen choices and five yes-or-no readings. Job comes first, as one choice over 31 catalog jobs plus unknown, with the searches people actually run for each job written into its criteria, so the boundary between neighbouring jobs is explicit rather than implied. Six constraints follow: who is choosing, what would make a model wrong, hosted or local, input size, budget band, volume. Then the requirements the shortlist can check against documented model features: citations, live web search, retrieval over supplied documents, structured output, scanned input, code execution, whether the text names several tasks, and how the output will be consumed. Two questions appear only when code finds something first, a monetary span in the text or the name of a model from our catalog. Three yes-or-no readings close the call as a gate: is this a job for an AI model, is the text trying to instruct the reader, is the use clearly harmful.

Back comes the same form you could click through yourself, each answer labelled as read from your description, and each one editable. When the job comes back under 0.6 confidence, the page shows it with the runner-up jobs beside it, taken from the probability spread rather than a second call, and asks you to confirm the job. The shortlist is already visible and shareable, but it stays provisional while that confirmation is missing. Choice constraints under 0.3 confidence are left open for you rather than applied. The yes-or-no readings use separate probability thresholds. Gate readings that are not clearly yes or no become a refusal, with no answers attached.

The same code that runs on a click produces the shortlist, and any quiz answer you change reruns it and says what moved.

## Jev reads requirements and code ranks the models

Every choice we send carries an explicit unknown, so declining is always an allowed answer. We rebuilt the request for the opening example on 22 September: 58 description characters produced 12,918 bytes of serialized JSON. Questions are the payload, and the questions are ours. Bytes are not billable tokens, so that measurement is not a price estimate. Nothing in the request is a score, a ranking or a model name, except the catalog names the visitor typed, which code matches first and Jev only confirms. The request sets OpenRouter's `zdr: true` and `data_collection: "deny"` provider filters. Our intake logs omit the description. Those flags state our routing requirements, not an audit of the provider's retention. Preview readings have a separate limit of 150 a day per visitor. A shared 20,000-request daily site limit covers previews and submissions. At that limit, the manual quiz remains available.

Here is the request audit, rebuilt locally without calling Jev. It measures the form we send, not model performance:

| Request check | Observed on 22 September 2026 | What it proves |
| --- | --- | --- |
| Description length | 58 characters | The input used for this measurement |
| Serialized request | 12,918 bytes | Request size, not token usage |
| Fixed questions | 14 Choice + 5 Noul = 19 | The form sent in one call |
| Job options | 31 jobs plus unknown | The bounded catalog choice |
| Budget/model questions | Absent for this example | Extra questions depend on detected spans |

Our first deployed version failed before it reached OpenRouter. Cloudflare's runtime rejected a redirect option our Node tests had accepted without complaint, so the transport now handles redirects manually and refuses every 3xx response before reading a body. On 22 September an isolated probe then sent "Analyze google analytics data for trends and opportunities" through the corrected path. OpenRouter answered with `typesafe/jev-1.13-20260917`, the strict parser read it as data analysis, and the gate accepted it. Our [Claim Checker](/tools/claim-checker) uses the same transport to read a sentence into a claim type, a subject, a comparator, a category and a benchmark, and the verdict is computed afterwards by code.

State the boundary plainly, because it is the reason a model that cannot write is the right model for this box. Jev has no tools, no browser, no file access and no way to run the task it is reading about. Its output is validated against the exact typed fields we asked for, and anything else is rejected. Even a misclassified description can at most produce an allowed selection, which you can see and change. It cannot produce a sentence on our page.

## What we have not measured

No calibration study. We have not labelled a representative set of descriptions and compared Jev's predicted probabilities with the correct jobs. Nor have we measured the error rate at each confidence threshold. A confidence value of 0.8 does not itself mean 80 percent accuracy. Both floors, 0.6 to confirm a job and 0.3 to apply a constraint, are conservative heuristics inherited from the earlier version of the intake, and our implementation review says so. Our offline fixture checks that budgets and requirements survive a round trip deterministically, and it does not measure Jev at all.

Successful readings log Choice confidence values without the description. Visitor right-or-wrong feedback can be linked by request ID, but it is a self-selected sample. A probability calibration study needs labelled outcomes paired with the actual option probabilities; confidence logs alone cannot supply it. Threshold tuning needs a representative error study of its own.

Outside results answer different questions. The phishing study reports an expected calibration error of 0.154 for Jev's direct verdict probabilities. Kumar reports 89.9 to 99.6 percent accuracy on the subsets of his four public datasets where Choice confidence was at least 0.9, covering 66 to 90 percent of items. Accuracy after filtering by confidence is not the same metric as probability calibration. Neither result measures our selector.

Until then the honest summary is narrow. Because Jev cannot write, it cannot put a sentence, a link or an instruction onto our page, and that is why it holds the door. Whether it holds it at the right threshold is a number we still owe you.

## Frequently asked questions

### What is Jev?

TypeSafe AI released Jev on 15 September 2026 as a model for decisions. It reads text and returns typed answers: a choice, a position on a scoring scale, or a yes-or-no probability. It generates no prose. TypeSafe calls it a System One model. Jev-1.13 is current as of 22 September.

### Is Jev an LLM?

Jev does not behave like a chat LLM: it returns constrained decisions instead of generating text one token at a time. TypeSafe describes RLCD as a post-training approach for pretrained language models. The useful distinction is the interface: Jev answers typed questions in parallel but cannot compose a reply or explanation.

### How much does Jev cost?

On OpenRouter, jev-1.13 is listed at $0.042 per million input tokens and $0 for output, read on 22 September 2026. TypeSafe quotes the same rate as $42 per billion tokens. The state, question instructions and options all count as input. Adding questions increases the bill even though their answers arrive together.

### Is Jev open source?

No. Jev is a proprietary hosted model. You reach it through TypeSafe's API or through OpenRouter's Decisions endpoint, which is in beta. No weights are published, so it cannot run on your own hardware, and a local or open-weight alternative has to be a different model.

### When should you use Jev instead of an LLM?

Jev fits decisions with a defined answer space: routing, classification, yes-or-no checks and scoring against a rubric. An LLM fits work that needs composed output, such as a summary, reply or code. Combine them when a workflow needs both, and test decision accuracy on labelled examples before allowing automatic actions.

### How does the LLM Selector use Jev?

Our selector sends your job description to jev-1.13 with a fixed set of multiple-choice and yes-or-no questions, and every choice includes an explicit unknown. Its answers fill the same form you could click through yourself. Our own code then computes the shortlist from the public dataset, so Jev never sees a score.