TypeSafe AI's Jev, a System One model that does not generate text — the conditions behind its 0.4-second and 67.8% claims
Jev, a model that does not generate text: the conditions behind TypeSafe's claims of 0.4 seconds per case and 67.8% agreement in its own evals.
On this page
On September 15, 2026, TypeSafe AI released a model called Jev. It is a model that does not write text. It returns only judgments in a predefined answer format, such as classifications, scores and yes/no decisions, each with probabilities, and the vendor claims it is 40–200 times faster than large language models (LLMs) and hundreds of times cheaper. On Hacker News it drew more than 1,700 points and a debate that ran all day. We read the vendor's announcement, docs and evaluation page, as well as that debate, in the original, and set out the conditions behind each number. There is no independent measurement yet. Keep that in mind as you read.
1. Executive summary
The Claude Opus 5 workflow took 37.8 s [3]
Vendor homepage, checked 2026-09-17 [1]
Vendor's own evaluation, four workflows [3]
First, the terms. System One model is TypeSafe AI's name, taken from psychologist Daniel Kahneman's "System 1," fast and intuitive thinking. The vendor defines them as frontier models "built to make fast, structured decisions that software can use directly" [2]. Jev is the name of the first such model. A structured decision answers a question whose answer format is set in advance, such as "Is this inquiry about a refund, shipping or something else?", "What score from 1 to 5 does this log get?" or "Does this claim match the evidence?" RLCD (Reinforcement Learning for Calibrated Decisions) is the name of the method the vendor says it used to train Jev. The announcement says only that it optimizes for "calibrated decisions: answers with epistemically honest probabilities on System One tasks," and no paper or technical report has been published.
The figures in this article are exactly as stated on the vendor's homepage, docs and evaluation page, and the multipliers are the vendor's own calculations. We did not run our own measurements.
2. What Jev and System One models are
An ordinary LLM answers any question by generating tokens one at a time, in order. Even for a classification question, it writes sentences: "This inquiry appears to be a refund request, because…" The vendor describes this as paying "a high tax for autoregressive generation" [6]. In other words, even a question that needs a one-word answer costs a sentence's worth of time and tokens.
Jev gives up that generation. In the docs' words, System One models "do not write replies, produce code, or generate explanations of their reasoning" [2]. Instead, they return a probability distribution over predefined options. Three options give three probabilities; a five-level score gives five. Your code reads those probabilities and branches on them.
- Pick one of a fixed set of options (classification, routing)
- Score on a fixed scale (severity, relevance)
- Answer yes/no as a probability from 0 to 1 (whether a policy is violated, whether a citation matches)
- Take several questions in a single call (the fan-out pattern in the docs [2])
- Generate sentences, summaries or replies
- Generate code
- Explain why they reached a judgment
- Give an answer that is not among the options. The vendor calls this "Zero Hallucinations" (we come back to this in section 5)
Some background on the company. The founder, Diogo Almeida, previously worked at OpenAI and is a co-author of the InstructGPT paper (arXiv 2203.02155), which set out a method for tuning language models with human feedback. We confirmed this in the arXiv author list [7]. The Register reported that the company has raised $40 million [5]. As of 2026-09-17, Jev is in early access through a waitlist, and Python and JavaScript SDKs and an HTTP API are documented [2].
3. The API: three question types and two numbers
According to the docs, there are three question types, and all three take the same input format. You send the state to be judged (a string, a JSON object or an array) and one or more questions [2].
| Question type | What it asks | What comes back | Where it is used |
|---|---|---|---|
| Choice | One of a fixed set of options | The chosen value, a probability for each option, confidence | Intent classification, routing, function selection |
| Score | One level on an ordered scale | A score, a probability for each level, confidence | Severity, relevance, reranking |
| Noul | A yes/no judgment | A single probability from 0 to 1 | Policy violations, citation checks, duplicate detection |
Choice and Score return two kinds of numbers. probabilities is the probability distribution across all the options, and confidence is, in the docs' words, "a statistic computed from the probability distribution the answer already gives you" [2]. Noul returns a single probability, so it has no separate confidence. When the distribution is concentrated on one option, confidence is high; when it is spread out, confidence is low. The docs suggest dividing confidence into three ranges: act automatically when it is high (0.9 or above for high-stakes actions), confirm first when it is medium, and hand off to a person or another system when it is low (below 0.5). But the docs are explicit that "the correct threshold values depend on your domain and the performance of the model for your use case" [2].
4. The vendor's numbers and their conditions
The numbers are spread across three places: the multipliers on the homepage, the price list, and an evaluation page on a separate domain. Each comes with different conditions.
The homepage multipliers
The homepage headline reads "193.6x Faster, 444.6x Cheaper." with a footnote: "based on workflows for System One tasks" [1]. The announcement says these values come from the workflow comparison on the evaluation page described below [1]. Calculating from the evaluation table (our derived values), Jev's 0.4 s against Claude Sonnet 5's 78.1 s is about 195x, and Jev's $0.0004 against Claude Opus 5's $0.1761 is about 440x, the same order of magnitude as the homepage figures. The table values are rounded, so the results do not match to the decimal. In other words, the multipliers compare speed against the slowest model in the table and cost against the most expensive one. Against Terra in the same table, Jev is about 25x faster and 76x cheaper.
Next to the multipliers, the homepage has one more small comparison: per request, $0.000081 and 0.114 s (TypeSafe) against $0.01388 and 8.566 s (LLMs). These are not the basis for the multipliers; they are values from a video demo [1]. The Register reported that in the Doom demo from the announcement (a demonstration in which the model looks at the game state and picks the next action), Jev took 0.114 s and GPT-5.6 Terra 8.566 s [5]. The ratios between these two sets of values are about 75x and 171x (derived values), and the demo's input was structured game state, not screen images.
Price
The vendor announced $42 per billion input tokens, or $0.042 per million tokens, and said output tokens are free. The homepage says this is 238x lower than Claude Fable 5.1's input price [1]. For comparison, The Register cited GPT-5.6 Terra's prices of $2 for input and $12 for output [5]. These are early-access prices and may change.
The evaluation page
The vendor published results from running several models on four workflows (security incident triage, agent trace observability, invoice processing and customer service) [3]. The values are per case; below are the rows in which the models were run as workflows.
| Model (as named on the evaluation page) | Agreement with reference labels | Cost per case | Time per case |
|---|---|---|---|
| Sol | 74.1% | $0.0836 | 23.3 s |
| Claude Opus 5 | 73.1% | $0.1761 | 37.8 s |
| Terra | 67.9% | $0.0304 | 10.1 s |
| Jev | 67.8% | $0.0004 | 0.4 s |
| Claude Sonnet 5 | 67.8% | $0.1174 | 78.1 s |
| Luna | 66.8% | $0.0033 | 12.9 s |
| DeepSeek v4 Pro | 65.5% | $0.0413 | 86.5 s |
| DeepSeek v4 Flash | 64.4% | $0.0059 | 51.9 s |
| Claude Haiku 4.5 | 53.6% | $0.0195 | 12.5 s |
Source: [3]. Sol, Terra and Luna are named exactly as on the evaluation page; The Register calls Terra "GPT-5.6 Terra" [5]. The same page also has rows in which each model was run as a single prompt rather than a workflow; for all eight models listed, those rows show lower agreement and higher cost and time than the workflow rows. For example, Opus 5 as a single prompt comes in at 64.8%, $0.3417 and 70.5 s.
Four conditions apply when reading this table.
- The reference labels are not ground truth. In the evaluation page's words, "the reference labels are generated via an average of the responses of GPT-6 Astra and Claude Fable 5.1, both at high thinking, answering every question in the harness" [3]. So the agreement rates above measure how often a model gave the same answers as two top models, not how often it was right. There are no human-labeled answers.
- The comparison models ran at default reasoning settings. Apart from the two models that produced the reference labels, every model was run with "the provider's default reasoning settings" [3]. Giving the other models more reasoning time would change both their agreement rates and their run times.
- The comparison LLMs were also constrained to structured output. According to the announcement, the LLMs in the workflow comparison went through the vendor's "System One LLM" wrapper, which constrained them to output only structured decisions compatible with the vendor's API [1]. So the time differences in the table are not text generation vs. judgment; they are the difference between an LLM and Jev answering the same questions. How many reasoning tokens the LLMs generated inside the wrapper, however, has not been disclosed.
- The workflow structure is the vendor's. All four workflows are broken down into Choice, Score and Noul questions. In effect, the problems were broken up in advance into forms Jev can answer. The fact that every model in the table improved when run as a "workflow" also reflects the effect of splitting a problem into small judgments, an effect you can get without Jev.
- The case counts and data are not published. The page gives no number of cases per workflow and no way to download the dataset. The results cannot be reproduced.
5. Three things Hacker News argued about
The announcement post received 1,793 points and 474 comments on Hacker News (checked 2026-09-17) [6]. The reactions followed three main lines, and the founder replied in person.
| Issue | Criticism | The vendor's reply | Our assessment |
|---|---|---|---|
| What the speed multiplier is compared against | The hundreds-fold figures compare against LLMs that generate text. Ask the same LLM for structured output, or take a single token, and the gap shrinks a lot. | Today's LLMs pay a high tax for autoregressive generation, and removing that tax is the whole point. | The announcement's workflow comparison also put a structured-output wrapper on the LLMs, so this criticism does not apply as is. But the homepage's 193.6x compares against the single slowest model in the table, and the number of reasoning tokens inside the wrapper was not disclosed. |
| "Zero Hallucinations" | Being unable to answer outside the options is not the same as answering correctly. Confidently picking the wrong option is the real problem. | Because probabilities come with every answer, low-confidence answers can be filtered out. | The criticism is right, and the announcement says as much: "Our number is not empirical. Schema matching is guaranteed, thus we can confidently add 0% into the plots." [1] We read "Zero Hallucinations" as zero out-of-schema outputs. With no calibration metric, the claim that such answers can be filtered out is also still only a claim. |
| Doesn't this already exist? | People have been doing the same thing with structured outputs from OpenAI and Anthropic, log probabilities (logprobs) and fine-tuned small classifiers. | Those approaches still run a generative model, and they were not trained with calibrated probabilities as the goal. | Section 6 compares them. There are differences, but there is no independent measurement of how large they are. |
Fourth, several comments pointed out that there is no RLCD paper. The announcement gives only the training method's name and its effect; it does not disclose the data, the model size, the base model or the training procedure. As of 2026-09-17, we could not find a related paper on arXiv or on the company's site. This article, too, says nothing about RLCD beyond its name.
6. How it differs from existing methods
Classification, scoring and yes/no questions are not new problems. Put side by side with four methods developers use today, Jev's place becomes clear.
| Method | What you need | Latency and cost | Does it give probabilities? | Weaknesses |
|---|---|---|---|---|
| LLM + structured output JSON schema enforced | A prompt and a schema | Seconds, because it generates tokens. Less with a short schema | Not by default. With some providers, possible if you turn on log probabilities | The prompt must be retuned when the model changes. No guarantee that the probabilities are calibrated |
| Fine-tuning a small classifier BERT-style models, small LLMs | Hundreds to thousands of labeled examples | Milliseconds; almost free if self-hosted | Yes, but calibration has to be done separately | Retraining whenever the options change. Building the data is the largest cost |
| Embeddings + rules | An embedding API and reference examples | Milliseconds, cheap | A similarity score, not a probability | Weak on subtle judgments (policy violations, citation matching) |
| Jev (vendor's claims) | Only the question definitions. No labeled data needed on the user's side (vendor's claim) | 0.4 s and $0.0004 per case [3] | Yes. A distribution over all the options | No independent measurement. Depends on one company's API. No explanations |
Jev's selling point is that it meets three conditions at once: no labeled data, options you can change, and probabilities included. A small classifier needs data, an LLM with structured output is slow, and embeddings do not give probabilities. On the other hand, there is no evidence yet that Jev matches the accuracy a fine-tuned classifier achieves on its own data.
The vendor has released a tool for running the comparison yourself. typesafe-ai/system-one-adapter-python is an MIT-licensed adapter [4]. It takes the same Choice, Score and Noul questions and has an OpenAI-compatible API or the Anthropic API answer them through structured output. You can choose between the provider's native structured output mode and JSON mode with a retry on validation failure, and when asked for probabilities (probability mode), it renormalizes the distribution the LLM returns so that it sums to 1. So even without access to Jev, you can build a baseline that splits your own workflow into the three question types and runs them on an LLM today. When you get access to Jev later, swap it into the same code and compare.
7. When it is worth trying
- High-volume judgments with short answers. Routing inquiries, scoring log severity, reranking search results, filtering RAG passages. Most of what the cookbooks in the docs cover is of this type [2].
- Guardrails before and after an LLM. Checking first, at lower cost than an LLM call, whether an input violates a policy or whether an output matches its sources.
- Branch points in an agent. Making judgments such as picking a tool or selecting a skill without generating text. As we saw in our article on agent tool interfaces, choices like these happen many times in every agent run.
- Teams without labeled data. When you have no data to train a classifier and the options change often.
- Judgments that need an explanation. If you have to tell users why they were rejected, you need text. Jev does not produce explanations.
- Problems that already have plenty of labeled data. If you have a classifier fine-tuned on your own data, there is no evidence that Jev beats its accuracy.
- Image input. In the docs, state is a string, an object or an array [2]. The Doom demo, too, fed in structured state, not the screen.
- Systems that have to go into production right now. Jev is in early access, and prices, limits and models may change.
8. Checklist to apply today
- Count the short-answer judgments among your LLM calls. Check what percentage of all calls are routing, classification and yes/no checks, and how many tokens they use. If that share is small, switching to Jev saves little.
- Rewrite those judgments in the three forms: Choice, Score and Noul. Rewriting them this way makes the prompts clearer on its own. It is also why every model in the vendor's table did better in workflow form.
- Build labeled data first. Without human-assigned labels, no model's agreement rate can be interpreted. The vendor's evaluation has no human labels either.
- Measure an LLM baseline with the adapter. Use
system-one-adapter-pythonto record the accuracy, latency and cost of the model you use now, with the same question forms [4]. - Set confidence thresholds from your own data. The docs' 0.9 and 0.5 are examples. Plot the actual accuracy for each confidence range and decide which range to automate.
- Re-measure the speed multiplier with your own calls. The baseline should be an LLM with structured output turned on, not an LLM that generates text. Only then do you get the number that would actually change.
- Count the external API dependency as an operational risk. Jev is one company's hosted API. Keep a fallback path (an LLM fallback through the adapter) in your code from the start.
9. What this is not yet
- There is no independent measurement. Every performance and cost figure in this article was produced and published by the vendor. As of 2026-09-17, we could not find any third-party benchmark.
- The reference labels are a consensus of models. The average of GPT-6 Astra and Claude Fable 5.1 stands in for ground truth. Cases where both models are wrong count as "correct" in the table.
- We do not know what RLCD actually is. No paper, technical report, model size or base model has been published. There is no evidence yet for the claim of "calibrated probabilities" either.
- There is no calibration metric. The evaluation page reports only agreement, cost and time, not whether the probabilities match actual accuracy. Users have to build the evidence for confidence-based automation themselves.
- The multipliers depend on what you compare against. 193.6x and 444.6x come from dividing by the slowest and the most expensive model picked from the vendor's workflow table; dividing the two sets of Doom demo values gives 75x and 171x. The comparison LLMs went through a structured-output wrapper, but their reasoning token counts were not disclosed.
- Prices and limits are for early access. $0.042 per million input tokens with free output is the homepage figure as of 2026-09-17, and we could not find request limits or input size limits in the docs.
- Hacker News comments are opinion, not measurement. The criticisms in section 5 are logically sound, but the comments did not include measurements to back them up either.
- Korean-language performance is not mentioned. Neither the docs nor the evaluation page lists supported languages or gives results for Korean.
10. Sources
All checked on 2026-09-17. [1]–[4] are the vendor's own materials and carry a conflict of interest. [5] and [6] are secondary sources.
| Source | What we checked | Scope of the evidence |
|---|---|---|
| [1] TypeSafe AI homepage · announcement "Introducing System One Models and Jev" (2026-09-15) | 193.6x and 444.6x; $0.000081 and 0.114 s vs. $0.01388 and 8.566 s; $42 per billion input tokens; 238x vs. Fable 5.1; the System One definition | Vendor marketing pages. Comparison conditions not stated |
| [2] TypeSafe AI docs · System One concept · confidence · state · fan-out | Definitions of Choice, Score and Noul; how probabilities relates to confidence; example thresholds (0.9, 0.5); the state format; no replies, code or explanations generated; early access | Vendor documentation. No calibration guarantee, limits or supported languages |
| [3] TypeSafe AI · Workflow Evals | The four workflows; agreement, cost and time per model (workflow rows and prompt rows); reference labels = the average of GPT-6 Astra and Claude Fable 5.1 (high thinking setting); all other models at default reasoning settings | The vendor's own evaluation. Case counts and data not published |
| [4] typesafe-ai/system-one-adapter-python | MIT license; supports OpenAI-compatible APIs and Anthropic; the provider's structured output, or JSON mode plus retries; renormalization of the distribution in probability mode | Vendor's published code. Based on the repository README |
| [5] The Register · report on TypeSafe AI (2026-09-16, Thomas Claburn) | $40 million raised; Doom demo 0.114 s vs. GPT-5.6 Terra 8.566 s; GPT-5.6 Terra prices of $2/$12 for comparison | Secondary source. Tech press report |
| [6] Hacker News · discussion of "Introducing System One Models and Jev" | 1,793 points and 474 comments; the debate over what the speed multiplier is compared against, zero hallucinations and existing methods; the founder's reply ("a high tax for autoregressive generation") | Secondary source. Community discussion, no measurements |
| [7] Ouyang et al. · Training language models to follow instructions with human feedback (InstructGPT, 2022) | Diogo Almeida is on the author list | The author list on the arXiv abstract page |
Editorial standard: we labeled every vendor figure as a vendor claim and put its measurement conditions before the figure. Because there is no paper on the training method RLCD, we wrote nothing about it beyond its name.