TypeSafe launches Jev: the model that generates no text

On September 15, 2026, TypeSafe, Diogo Almeida's lab, emerged from stealth mode and published its first System One Model, named Jev. Jev does not generate text. It chooses a response from predefined options and returns a structured value with calibrated probability, at $0.042 per million input tokens, with free output tokens, according to the official announcement of System One Models. The same announcement describes the result as a "frontier intelligence function call." The implication that matters for those who purchase inference: Jev is not a cheaper LLM, it is a different class of model, and it queues before the generative call.

What TypeSafe announced on September 15

TypeSafe is a lab founded by Diogo Almeida, a researcher who co-authored the InstructGPT paper in 2022, the human preference alignment method that underpins ChatGPT, published in 2022 on arXiv. Jev is the company's first model and the first of a class it calls System One. The class name honors Daniel Kahneman's division between fast and slow thinking, and the model name honors William Stanley Jevons, the economist of The Coal Question (1865) who described the paradox now known by his surname.

What Jev does differently is its output. A generative LLM receives an instruction in natural language and returns text in natural language, and transforming that text into something software can consume is left to the code writer: extracting the field, validating the format, handling cases where the model wrote a sentence where the program expected a number. Jev accepts the question in natural language, but the answer is chosen from options defined before the call, and comes out as a structured value accompanied by a probability.

This is where the claim that it "cannot hallucinate" comes from. TypeSafe maintains that the model cannot invent an output because the entire space of possible responses is defined beforehand. It is a vendor claim, public and dated, and this article records it as such. On the technical side, the announcement describes a parallel sampler and a training method dubbed RLCD, Reinforcement Learning for Calibrated Decisions, where the declared confidence must match the observed frequency of accuracy.

The price and latency figures are from the vendor, in the same announcement. They are $0.042 per million input tokens, or $42 per billion, with free output tokens. End-to-end latency is between 70 ms and 500 ms, which the company positions as 40 to 200 times faster than frontier LLMs. TypeSafe's home page, verified on September 17, adds 193.6 times faster and 444.6 times cheaper in workflow evaluations. These latter two numbers are vendor statements, not independent measurements, and are worth what any launch page benchmark is worth.

What independent verification exists outside the company is a vehicle test. On September 15, Every published an experiment that ran Jev over the author's own texts: 777 judgments in less than 0.7 seconds, for an estimated quarter of a cent. The median was 0.35 seconds per pass versus 8.83 seconds for a frontier LLM, and Jev detected 6 of the 7 planted defects, compared to 7 out of 7 for the comparison. The test author notes the caveat. The 86% coverage of defects, with one pass where the comparison got everything right, is the independent evidence available today, and it is small.

TypeSafe describes the use cases in a short, specific list: intelligent conditionals, classification, routing, scoring, field extraction, jailbreak detection, and map-reduce operations over large databases. This is repetitive decision work, not writing.

Why the class matters more than the multiplier

The relevant part of the launch is not the 193.6 on the home page. It is the word "class." Every model this blog has covered until today belongs to the same curve: it receives text, returns text, and the buyer compares price per million tokens, position on an intelligence index, or cost per completed task. The cost per task comparison only makes sense because the candidates are all generative. Jev is outside this curve by design, and a model that does not belong to the curve is not measured by it.

The number that supports this is the price. At $0.042 per million input tokens, with free output, the decision call costs a small fraction of the generative call, and responds in tens or hundreds of milliseconds instead of seconds. This does not make Jev a competitor to frontier LLMs; it makes it a candidate for a different stage of the same workflow. Classifying a request before choosing which model serves it, triaging whether a prompt is a jailbreak attempt, scoring the relevance of a passage before sending it to the context, all of this is currently done with the most expensive model in the house, because that is what is integrated.

The correct reading of the name also deserves a line. Jevons described coal consumption reacting to an efficiency gain by increasing use, and the name is the vendor's own choice. If the decision becomes 40 times cheaper, the system design that runs one decision per request can now run ten decisions per request. If this effect appears, the inference bill for those who adopt the model does not fall. It changes shape.

It is worth being precise about what remains to be proven, because this is where the article separates from the launch material. Calibrated probability is a verifiable promise, and verification has an exact form: among 100 cases where the model scores 0.9, about 90 should be positive.

Nothing in the announcement proves this property under a specific buyer's workload, and the only third-party measurement available covers 777 judgments from a single vehicle, with the caveat already noted. Add to this that the model is not indicated for rare events, which means that the declared confidence in an isolated case decides nothing. What decides is the proportion, measured in the buyer's own history.

There is a data limit in the way of anyone who tests it. TypeSafe does not publish, in the announcement, a task-by-task quality comparison against frontier models, and Jev is in early access. No search volume was measured for "TypeSafe" or "Jev" in this execution: the keyword tool was unavailable, so the recognition demand for these two names is a declared unknown, not a number.

What changes in practice

The change is in the address of the decision. What was a natural language instruction within a prompt, evaluated by the same model that writes the final answer, now becomes its own call, with an input and output contract and a confidence number attached to the result.

Read the last line carefully. The cost per million tokens does not describe a model that charges for input and ignores output. Anyone with only a price per token spreadsheet will measure the generative half of the bill and will attribute a cost to Jev that it does not have, or vice versa. The layer that applies policy by key, spending caps, and call tracking needs to learn to measure both things on the same dashboard, because the decision of where to spend now depends on comparing two different units.

It is worth situating Jev alongside the closest neighbor this house has already covered. Mercury 2.5, a diffusion LLM, is also not an autoregressive transformer, and that article showed that a non-standard architecture changes the economics of serving. The degree of difference between the two cases is large. Mercury remains a text generator by another path; Jev abandons text. That is why it does not enter any ranking of response quality, and the frontier index has no place for it.

Every's independent test shows the other side of the same coin. Judging 777 text snippets in less than 0.7 seconds is a type of workload that no one runs in production today, because the prohibitive cost decides before the architecture. When the unit cost drops to a quarter of a cent in the vehicle's estimate, the workload comes into existence. It is the same argument that supports agent evaluation beyond the final answer: measuring during the task requires a judge cheap enough to run many times.

What to do now

The work is architectural, not acquisitional. Jev is in early access and nothing here is a purchase recommendation. The five decisions below are those that change shape when a decision class enters the queue, and the second is the one that usually gets stuck.

1. List the decisions that currently travel within a prompt. Classification, triage, scoring, field extraction, and tool selection are the candidates. If the expected response is one from a closed set, the step is a decision and not a writing task.
2. Define the acceptable confidence proportion before testing the model. The design is by proportion, not by isolated case: among 100 cases marked with 0.9, how many positives does your process tolerate. Without this number written down, the test has no acceptance criterion and becomes a demonstration.
3. Measure decision and generation on the same dashboard. Tracing LLM calls with model, cost, and latency per request is what allows comparing the two units. Two separate spreadsheets produce two contradictory conclusions about the same bill.
4. Treat the routing policy as a place that can accommodate more than one type of call. The router continues to choose which generative LLM serves each request; it can now also decide when the cheap decision response resolves before spending the expensive call. The routing layer within an LLM gateway is where this policy lives with per-key scope.
5. Reread the rule design when a non-generative model enters the list. What route decision with real traffic evidence requires is per-call logging. A new class of model forces a review of which fields the log needs to carry, because calibrated probability was not a field that existed before.

The order matters, because action 3 depends on 4 and 4 depends on 1. Those who start measuring without having the list of decisions end up optimizing the step that was not the bottleneck.

Frequently Asked Questions

Does Jev replace a frontier LLM?

No. It does not generate text by design, so it does not handle any task that requires writing, summarizing, or open-ended reasoning. It enters as a preceding, decision-making call, to classify, score, triage, or select a tool before the generative call goes out. The routing policy now has two types of calls to position.

What does "cannot hallucinate" mean in this case?

It is the vendor's statement, recorded as such. The claim is structural: the model only chooses from options defined before the call, so there is no room to invent an output that was not on the list. This is not the same as always being correct. Choosing the wrong option within the set remains possible, and that is what calibrated probability is for.

What is calibrated probability, in practice?

It is a verifiable promise: among 100 cases where the model scores 0.9, about 90 should be positive. Verification is done in the buyer's own history, accumulating cases and comparing the declared confidence with the observed accuracy rate. TypeSafe published RLCD as a training method for this property, and the model is not indicated for rare events.

Is Jev cheaper than the models I use today?

The advertised price is $0.042 per million input tokens, with free output tokens, and is a vendor statement. A direct comparison with a generative LLM does not work, because the units are different: one charges for natural language input and output, the other charges for input to return a structured value. What is compared is the cost per resolved decision, measured in your workload.

Have the 193.6x and 444.6x numbers been verified?

Not by third parties. Both come from TypeSafe's home page, in the company's own workflow evaluations. The only independent measurement available is Every's test from September 15, with 777 judgments in less than 0.7 seconds, and it includes the author's own caveat: Jev detected 6 of the 7 planted defects, compared to 7 out of 7 for the comparison.

References and Further Reading

• TypeSafe, September 15, 2026: Introducing System One Models and Jev, primary source of the event.
• TypeSafe, home page, verified on September 17, 2026, origin of the 193.6x and 444.6x claims, vendor statement.
• Every, September 15, 2026: Jev judged everything I've written in 0.7 seconds, technical interview with Diogo Almeida and the independent test with the author's caveats.
• InstructGPT, Ouyang et al., 2022, the method Diogo Almeida worked on before ChatGPT.
• Cost per task in AI model routing, the unit of cost that changes when output is free.
• Deciding LLM route with real traffic evidence, the evidence that a decision call natively produces.
• Evaluating agents beyond the final answer, the judge cheap enough to run multiple times during the task.
• Diffusion LLM: what Mercury 2.5 changes in routing, the other class outside the autoregressive transformer that has already been covered in the blog.
• Nexforce Router, the multi-model routing layer with one API.

What to observe in the next quarter

Two dates organize the reading. The first is the exit from early access, because that is when the advertised price and latency can be measured by those who are not TypeSafe. The second is the publication of third-party numbers on calibration, because it is the only property of Jev that can be verified without relying on vendor trust.

It is worth separating what the launch proves from what it promises. It proves that a model exists in production with structured output, closed options, and input-based pricing, and this is already a new class on the shelf. It promises calibration and speed in workloads that no one has measured externally yet. The distance between the two is what the next quarter resolves, and it is good to follow closely because it directly affects the bill for those running inference at volume.

The question that remains is not which model is better, but rather who gets to decide what is a decision and what is a writing task. While this boundary was fixed, the optimization criterion was singular, the price per token. With a class that only decides, the criterion becomes dual, and each workflow needs to say how many cheap decisions fit before an expensive call.

The Nexforce Router is the layer where this dual criterion becomes an executable rule: more than 300 models behind a single OpenAI-compatible API, with routing by cost, performance, latency, and context, automatic failover between providers, per-key budgeting, and an auditable call trail. When a new class of model enters the shelf measuring a different unit, the routing policy is what decides whether the novelty turns into real savings or just another integration without an owner.

Caption: The same workload evaluated across two call classes, decision and generation. Nexforce technical diagram, September 17, 2026.