Jev vs a language model: when to use which

Every team that reads about Jev asks the same question first: should we replace the language model? The answer is that you should replace the part of the language model's work that was a decision, and keep the part that was writing. This page gives the rule for telling them apart, the figures TypeSafe and others have published on speed, cost and accuracy, with who measured each, and the shape of the hybrid that most products end up with.

The decision rule

Ask two questions about each place your product calls a model.

Is the set of possible answers known before the request is sent? A queue name from a list of five, a severity from 0 to 3, a yes or no on whether a diff stays in scope. If you can write every possible answer down in advance, the answer is yes.

Does the decision repeat at volume? Every ticket, every tool call, every change in the pipeline. If the same question is asked thousands of times with different states, the answer is yes.

Two yeses mean a Jev question. The answer set is fixed, so a Choice, Score or Noul can express it, and the volume is where the speed and cost differences accumulate. Either no means a language model. If the answer might be an option nobody listed, a fixed list will silently pick the nearest wrong one. If the decision is made once, the difference in cost and speed is not worth an integration.

A third question decides the hybrid. Does anyone need to read a sentence? A user needs a reply, a reviewer needs a reason, a log needs a summary. If yes, a language model writes that sentence, and the only question is whether Jev makes the decision that the sentence is about. Usually it should.

The speed and cost figures, and who measured them

TypeSafe's launch post reports 70 to 500 milliseconds end to end for Jev, against 3 to 329 seconds for the frontier language models in its comparison, and states "40x-200x faster" [1]. Its headline benchmark, reported by MarkTechPost on 19 September 2026, has Jev finishing one workflow decision in 0.114 seconds for $0.000081 against GPT-5.6 Terra at 8.566 seconds for $0.013880, which TypeSafe reports as "193.6x faster and 444.6x cheaper" [2]. Tom's Hardware ran the same figures under the headline that Jev "claims to be 193x faster and 445x cheaper" [3], and the word claims is the right one.

Two caveats travel with those numbers, and TypeSafe supplied both. The workflows were written by TypeSafe's own capabilities team [2], so they are the tasks the vendor chose to show. And TypeSafe says it cannot prove the price is unsubsidised [2], so the cost ratio holds at a launch price that may change. Read the figures as the vendor's best case, and note that the direction of the difference does not depend on the workload: a model with no output tokens is faster and cheaper than one that writes its answer out, on any task, by some ratio. What the workload decides is the ratio.

Third parties have published their own ratios on their own tasks. LangChain measured Jev at 0.44 seconds per call at $0.00035 against 2.16 to 2.83 seconds per call for the language models it tested, with a full run costing $0.34 with Jev and $28.17 with Claude Sonnet 4.6 [4]. Openlayer measured Jev latency at a median of 244 milliseconds and a 95th percentile of 371 milliseconds on its own benchmark [5]. Those are smaller ratios than TypeSafe's headline and the same direction.

The accuracy figures, and who measured them

Speed is only worth having if the answers are good enough, so this is the section to read most carefully.

DataCamp reports a TypeSafe workflow evaluation in which Jev agreed with the reference answer 67.8 percent of the time, against 67.9 percent for GPT-5.6 Terra, 74.1 percent for GPT-5.6 Sol and 73.1 percent for Claude Opus 5 [6]. On the same evaluation Jev had 0 percent structured-output errors against 45.5 percent for Claude Haiku 4.5 [6]. Those are TypeSafe's own workflows, so the accuracy comparison is the vendor's, reported by an independent outlet.

Read plainly: on the tasks TypeSafe chose, Jev is close in accuracy to one frontier model, below two others by 5 to 6 points, and never returns a malformed answer. A team choosing Jev for a decision is accepting an accuracy close to the mid-range language models in exchange for a large speed and cost gain and a guarantee about the shape of the answer. Whether that trade is right depends on the decision, which is why every threshold should be set per action from labelled data, as calibrated probabilities and confidence, explained describes.

LangChain's test is the one independent accuracy measurement, and it is small. Five weather-agent cases, 100 repetitions per judge per case, against a human-labelled reference. On the binary pass question Jev agreed with the reference 100 percent of the time, GPT-5.6 Terra 99.8 percent, GPT-5.6 Luna 96.4 percent and Claude Sonnet 4.6 80.0 percent. Jev's mean per-case variance on the quality score was 0.0000149; Luna's was 433 times higher, Terra's 913 times higher and Claude's 92 times higher [4]. The authors call the results "promising, but early" and "observational, not evidence", say the experiment "cannot tell us why Jev's scores varied less", and warn that "low cost can amplify mistakes" [4]. Five cases is a small set, and a 100 percent on five cases says less than a 95 percent on five hundred would.

Where each one wins

Jev wins on routing, classification, scoring and yes/no checks that repeat. It wins wherever the answer's shape has to be guaranteed, because the answer always matches the schema [7]. It wins on latency-bound paths, where a user is waiting and 300 milliseconds is acceptable and 8 seconds is not. And it wins on the cost of a check that runs on every item, because a check that costs $0.00035 can run on everything and a check that costs $0.05 gets sampled.

A language model wins wherever text has to be produced: the reply, the code, the summary, the explanation. It wins when the answer might be new, because it can say so. It wins on tasks that need a chain of reasoning before the answer, because a System One model has no such chain, and TypeSafe's jaggedness page lists the consequences: no reliable counting, no reliable numeric comparison, dates as text, weaker handling of double negatives [8]. And it wins on a task done once, where integration cost dominates.

TypeSafe's own coding-agents page draws the line the same way. Jev "is not a drop-in replacement" for the language model running a coding agent; it is used inside the application for routing, rubric scoring and statement verification [9]. The vendor is telling you not to try to replace the agent's model, and it is right.

The hybrid: Jev decides, the language model writes

Here is the shape that most products end up with. Every incoming item goes to Jev first with the questions that decide what to do with it. Code reads the probabilities and takes the branch. On the branches that need a sentence, a language model writes it, with the decision already made and included in its prompt as a fact.

A support product: Jev picks the queue, the urgency and the flags in one request. Code routes. On the branch where a reply is written, the language model writes it, told which queue and urgency Jev chose. The language model never decides the queue, so it never decides wrongly in a way that also writes a confident reply.

An agent: LangChain's harness uses a TypeSafe classifier as middleware that checks a tool call before it executes and blocks the risky ones [10]. The language model plans and writes; Jev checks each step against a fixed set of questions in one round trip. Browser-use took this further in Jev Ultrafast, where Jev picks the action and its target from a structured element table and the median time for one Google Flights task fell from 9.45 to 7.09 seconds over six alternating runs, with browser protocol calls down from 1,092 to 101 [11]. Browser-use says that is three repeats of one task and no general benchmark. We covered it in AI News.

An eval suite: this is what Reveneau did. We generate all of our code and every change has to pass a suite written from the specification. The checks that have a deterministic answer stay in code. The checks that need a judgment with a fixed answer, whether the change matches the criterion, whether the diff stays in scope, whether the trace followed the plan, whether the text follows the instruction, used to go to a language model as judge and now go to Jev as Noul and Score questions. The language model still writes the code. On our own suite the run is ten times faster than with the previous grader. How Reveneau uses Jev has the setup, evals with Jev is the how-to, and LLM as judge for code review is the page we would have pointed you to before this month.

How to run the comparison yourself

Take one decision your language model currently makes whose answers are a fixed list. Collect a few hundred cases with labels. Send each through both, and record the answer, the time and the cost. Compare agreement with the labels, and look hardest at the cases where the two disagree, because that is where you learn what each one gets wrong. Then set a threshold for Jev on those cases and count how many would have gone to a person.

If Jev's agreement is within a few points of the language model's and the disagreements are ones a threshold catches, move the decision. If Jev is wrong in a way that clusters, such as on cases needing a count or a date, check whether code can supply the fact and ask again. If the gap stays, keep the language model for that decision and move the next one. Jev vs a fine-tuned classifier covers the third option, training your own, and the pillar, Jev and System One models, holds the rest. For the product-side version of this choice, decision models for product teams is written for the person who owns the roadmap rather than the code.

The rule in one line: a decision with known answers at volume goes to Jev, a sentence goes to a language model, and a product that needs both lets Jev decide first.