TypeSafe Jev: 444x Claimed, 8.6x to 580x Measured
Jev lists $0.042 per million input tokens, output free. Five outside tests and our own run measured 8.6x to 580x cheaper, not the advertised 444.6x.
TypeSafe AI advertises that its new model Jev is 444.6x cheaper than a frontier LLM. In the five days after the September 15, 2026 launch, five outside parties ran their own tests and published the numbers. They measured 8.6x, 45x, 58x, 274x and about 580x. This site then ran 483 real decisions through Jev and measured a sixth figure. None of them is 444.6x, and the reason the spread is two orders of magnitude wide turns out to be more useful than any single number in it.
Jev is the first of what TypeSafe calls System One models. As founder Diogo Almeida put it in the 2026 TypeSafe launch post Introducing System One Models and Jev, it is a frontier-intelligence function call where unstructured state goes in and typed probabilistic decisions come out. No essays, no code, no small talk.
What Jev actually is
Jev is a decision model for software. A developer sends it a block of context called the state (a ticket thread, a claim form, an alert record) plus a set of questions with fixed answer shapes, and Jev returns the answers as typed values with probabilities and a confidence score. The 2026 TypeSafe documentation in System One concepts frames it the same way: like a language model it reads natural language, but instead of writing text it fills in the blanks the program defined in advance. If the code asked which team owns a ticket, the answer is a value like billing plus a distribution over the options, something the surrounding code can branch on directly.
Think of the difference as an essay writer versus a thermostat. A chatbot is the essay writer: flexible, eloquent, and in need of proofreading before the result touches anything important. Jev is the thermostat dial: narrow, boring, and safe to wire into other machinery. The dial cannot write a poem, which is exactly why a program can trust it with a yes-or-no call at 3 a.m. without a human in the loop.
What are Choice, Score and Noul?
TypeSafe exposes three primitives, described in the 2026 TypeSafe introduction to Jev. Each asks one small, well-scoped question:
| Primitive | Plain English | Example | What comes back |
|---|---|---|---|
| Choice | Pick one from a list | Which team owns this ticket: billing, technical, or account? | The pick, a probability per option, and confidence |
| Score | Rate on a fixed scale | How frustrated is this customer on a 0 to 2 scale? | A score like 1.4, the distribution across levels, and confidence |
| Noul | Yes or no, with a number | Does this message request a refund? | A probability between 0 and 1 |
Three properties make this setup different from asking a chatbot the same things. First, every question in one request is evaluated in parallel against the same state, so bundling twelve questions costs little more than asking one. Second, the outputs are constrained to the shapes declared up front, so there is nothing to parse and no JSON repair step. Third, each answer carries calibrated confidence, which is the load-bearing idea: the model is trained to say how sure it is, and higher confidence is supposed to mean higher accuracy. Code can then auto-act above a threshold and escalate the rest to a person or a bigger model. TypeSafe calls that pattern confidence-gated routing in its 2026 patterns documentation.
The training method behind the calibration claim is new. TypeSafe calls it Reinforcement Learning for Calibrated Decisions (RLCD), positioned against RLHF (which optimizes for answers human raters prefer) and RLVR (which optimizes for answers a checker can verify). RLCD optimizes for honest probabilities on decision tasks. Whether the calibration holds outside TypeSafe’s own tests is still an open question, and the post below treats it as a vendor claim with supporting evidence rather than settled fact.
What it costs
The sticker is simple. According to the 2026 TypeSafe models page, the current model jev-1.13.0 (reached through the jev-latest alias) charges $0.042 per million input tokens, which is $42 per billion, and output tokens are free. Context budget is 64k tokens per request, with the state plus the longest single question capped at 32k. Rate limits are listed at 250,000 tokens per second and 1,200 requests per minute, with a warning that limits move around while demand is high.
Placed next to chat-model input stickers, the gap is stark:
| Tool | Cost per task | Multiple of baseline |
|---|---|---|
| Jev | $0.042 | 1.0x |
| GPT-5.6 Luna | $0.200 | 4.8x |
| GPT-5.6 Terra | $2.00 | 47.6x |
| GPT-5.6 Sol (promo) | $4.00 | 95.2x |
| Claude Fable 5.1 | $10.00 | 238.1x |
By this site’s arithmetic on those stickers, Jev input is about 48x below Terra input ($2.00 divided by $0.042) and about 238x below Fable 5.1 input ($10.00 divided by $0.042). TypeSafe’s own homepage makes the second comparison explicitly, advertising 238x lower input price than Claude Fable 5.1. For full tier history on the OpenAI side, see the GPT-5.6 pricing breakdown and the Sol, Terra and Luna launch post.
Sticker math understates the real gap because output billing disappears. A chat model charges several times more for the tokens it writes than for the tokens it reads, and decision workloads force it to write reasoning, probabilities, and JSON scaffolding around every answer. Jev writes nothing, so there is no output meter at all. TypeSafe’s headline numbers come from that full per-case comparison: 193.6x faster and 444.6x cheaper, averaged over four automation workflows and shown on the TypeSafe workflow evals site. TypeSafe itself cautions that those sit at the higher end of real-world gains.
A concrete toy bill helps. The launch post describes an engineer worrying about a Doom demo making 10 Jev queries per second, which penciled out to about $7 per hour. That is a real-time game bot calling an AI model ten times a second for less than a fast-food combo. A chatbot API doing the same cadence would be unusable on latency alone, let alone cost. For background on why chat-model bills balloon even at modest volumes, see why AI API bills run so high.
What five outside tests actually measured
Everything above this line is TypeSafe describing TypeSafe. Between September 15 and September 19, 2026, five parties with no disclosed connection to the company ran Jev on their own tasks, against their own comparators, and published the numbers. That is the evidence worth reading, because each tester chose the task, the comparator and the answer key.
| Who ran it | Task and scale | Comparator | Measured |
|---|---|---|---|
| Mike Taylor, Every | 777 judgments over 37 documents; 1,709 in total | Claude Fable 5.1 | About 25x faster, about 580x cheaper. Caught 6 of 7 planted defects against Fable’s 7 of 7 |
| Near Here | Event-listing moderation, 50 cases | Mistral Small 4, Gemini 3.5 Flash-Lite | 8.6x and 58x cheaper. Jev 48 of 50 correct against 42 and 43 |
| gemanor benchmark | Python code review, 1,080 calls over three rounds | Gemini 3.8-Flash, Claude Fable 5.1 | 45x and 274x cheaper. Correctness 98.0 percent against 100 percent for both |
| Paddy Alton, paddo.dev | 9,081 real product-match adjudications | None | $0.32 for the whole queue. Abstained on 30 percent of it |
| Laurie Voss, Arize AI | Spam classification, 18,514 emails | A trained TF-IDF classifier | 98.3 percent against 98.4 percent, with real labels rather than model agreement |
Three of those testers report a per-decision cost, and the three agree with each other far more closely than any of them agrees with TypeSafe. Near Here and the gemanor code-review benchmark both landed on $0.043 per 1,000 decisions, and Alton’s thirty-cent judge run works out to $0.035 per 1,000. TypeSafe’s own eval table implies $0.40 per 1,000. Three unconnected testers landing within 23 percent of each other at roughly a ninth of the vendor’s own figure says something the marketing does not: per-decision cost is driven by how much state you send, not by the sticker, and TypeSafe’s own evals run on unusually fat contexts.
How much cheaper is Jev than an LLM in practice?
Between 8.6x and about 580x, and which end you land on depends almost entirely on what you were using before. Against Mistral Small 4, a cheap open-weight model, Jev is 8.6x cheaper. Against Claude Fable 5.1, a frontier model, it is 274x to 580x cheaper. The advertised 444.6x is not wrong so much as it is one point on that line, chosen from the dear end.
| Test and who ran it | Cheapest comparator | Dearest comparator |
|---|---|---|
| Near Here (event moderation, 50 cases) | 8.6x | 58x |
| gemanor benchmark (code review, 1,080 calls) | 45x | 274x |
| Every (document QA, 1,709 calls) | 580x | 580x |
| TypeSafe eval table (worked out here) | 76x | 440x |
| TypeSafe onboarding (early access, not public) | 40x | 1,000x |
Read the chart as a buying guide rather than a scoreboard. The question it answers is not “how good is Jev” but “how much were you spending before”, and the honest planning figure is the span that matches your current comparator, not the widest number on the page.
Where does the 444.6x figure come from?
The Opus 5 row, on its own. Per case, Jev at $0.0004 is about 76x below GPT-5.6 Terra at $0.0304, about 209x below Sol at $0.0836, about 294x below Sonnet 5 at $0.1174 and about 440x below Opus 5 at $0.1761. That last figure is within a rounding error of the advertised 444.6x, so the headline is the comparison against the most expensive model on the board rather than an average across the field.
TypeSafe publishes the advantage in at least three places and the three do not agree. The widest and most candid version is not on the marketing site at all: it is on the onboarding page a new user sees after signing in to early access.
| Where the number appears | Faster than an LLM | Cheaper than an LLM |
|---|---|---|
| typesafe.ai homepage | 193.6x | 444.6x |
| Launch post, Evidence section | 40x to 200x | no range published |
| Early-access onboarding page (not public) | 20x to 200x | 40x to 1,000x |
| This site, from the published eval table | about 25x to 95x | 76x to 440x |
Two things stand out. First, the onboarding page sets its speed floor at 20x, half the 40x floor stated in the public launch post, which describes a range of “40x-200x faster for the same levels of frontier intelligence for System One shaped queries.” Second, it is the only surface that publishes a cost range at all, and that range runs from 40x to 1,000x.
The lower onboarding floor is the one that matches TypeSafe’s own published numbers. Dividing each comparator row on the workflow evals site by the Jev row gives, by this site’s arithmetic, about 25x faster than GPT-5.6 Terra (10.1 seconds against 0.4), about 58x faster than Sol (23.3 seconds), and about 95x faster than Opus 5 (37.8 seconds). Not one of those reaches the 40x floor for the cheapest comparator, and none comes close to the 193.6x on the homepage. TypeSafe does not show its working for that figure, so the most likely explanation is that it is computed per workflow and then combined, rather than taken from the published averages. Worth flagging rather than assuming bad faith, but it means the homepage number cannot be reproduced from the homepage evidence.
None of this makes Jev a bad deal. A floor of 76x cheaper against the mid-tier model it actually matches on accuracy is a serious number, and it holds up without any of the marketing. The point is narrower: the headline multiple is a best case built against the dearest comparator, the honest planning figure is the bottom of the range, and TypeSafe knows this, because the wider range is what it tells users once they are inside the product.
What does a 30 percent abstain rate cost?
Most of it. This is the part none of the coverage has worked out, and it matters more than any multiple above.
Alton’s run is the only published test on a real production queue, and its most interesting number is not the $0.32. It is the outcome split: Refute 4,443, Confirm 1,952, and Abstain 2,686. Thirty percent of the queue came back undecided. An abstention is not a decision. It is a case handed back, and under the confidence-gated routing pattern TypeSafe itself recommends, a handed-back case escalates to the model the decision layer was supposed to replace. So the Jev bill is not the cost of the decision layer.
The sum below runs entirely on TypeSafe’s own published eval table, so the units are consistent, and imports exactly one figure from outside it: Alton’s measured 30 percent abstain rate.
Jev cost per case $0.0004
GPT-5.6 Terra cost per case $0.0304
Headline multiple, Jev alone 76x
Abstain rate, measured on a real queue 30%
Escalation cost 0.30 x $0.0304 = $0.00912
Blended cost $0.0004 + $0.00912 = $0.00952
Effective multiple $0.0304 / $0.00952 = 3.2xThe 76x becomes 3.2x. Run the same six lines against Opus 5 and the 440x becomes 3.3x. Both collapse to roughly the same place, which is the clue to the general result:
Blended multiple = M / (1 + a x M), where M is the multiple on the cases the model answers and a is the abstain rate. As M grows, the expression converges on 1 / a.
At a 30 percent abstain rate that ceiling is 3.33x, and it does not matter whether the decision model is 76x, 440x or 580x cheaper per answered case. All three land between 3.2x and 3.3x. A 30 percent abstain rate caps the achievable saving at about two thirds off, however close to free the decision model gets.
| Abstain rate | Blended cost per decision | Effective multiple vs Terra | Ceiling at any Jev price |
|---|---|---|---|
| 0 percent | $0.00040 | 76x | no ceiling |
| 1 percent | $0.00070 | 43x | 100x |
| 5 percent | $0.00192 | 16x | 20x |
| 10 percent | $0.00344 | 8.8x | 10x |
| 30 percent (measured) | $0.00952 | 3.2x | 3.3x |
The break-evens are worth memorising if you are sizing a migration: the 76x advantage against Terra falls below 20x once the abstain rate passes about 3.7 percent, and below 10x at about 8.7 percent.
Three caveats ship with that arithmetic, or it is dishonest. It assumes every abstention escalates and is resolved in a single LLM call. Abstentions are, by selection, the hard cases, so they plausibly cost more than the average case, which makes 3.33x a ceiling rather than a floor. And 30 percent is one workload’s rate on a queue that had already been filtered down to “a human should look at this”; a cleaner input stream will abstain less. The formula is the transferable part. The 30 percent is not.
This is the same trap in a new place: a sticker price that is genuinely low, and a total cost that is set by something the price list does not mention. The site has covered why cheaper AI models often cost more in the token-billing case, and the abstain rate is that phenomenon for decision models.
How accurate is Jev when the answer key is not another LLM?
About as accurate, on the one test that checked. This is the gap in all the other evidence, including TypeSafe’s own: the workflow evals define the right answer as the average of what GPT-6 Astra and Claude Fable 5.1 said, which measures agreement with two chat models rather than correctness.
The exception is Arize AI’s test. Laurie Voss ran Jev over 18,514 emails on a spam-classification task with real labels, and reported 98.3 percent for Jev zero-shot against 98.4 percent for a TF-IDF classifier trained on roughly 14,800 labelled examples, calling the difference not statistically meaningful. Matching a purpose-trained classifier with no training data at all is the strongest evidence published so far that the calibration claim is doing real work, and it is worth more than any of the cost multiples. Arize notes it has not yet run its own full benchmark suite.
The rest of the accuracy evidence is narrower but points the same way: Near Here’s 48 of 50 beat both chat models it was tested against, while Every’s 6 of 7 and the code-review benchmark’s 98.0 percent both sat just below a frontier model that got everything right. The pattern across all four is that Jev gives up a small, consistent slice of accuracy, and the size of that slice is a couple of points rather than a couple of tiers. For a broader framing of why the answer key is the hard part of any evaluation, see the site’s guide to LLM evaluation metrics.
What Jev cost us on 483 real decisions
Every figure in this section was produced by running Jev, not by reading about it. The script is committed at scripts/jev/benchmark.mjs and its output at docs/jev/benchmark-2026-09-20.json, so the numbers can be re-derived rather than trusted.
The task is a real one this site runs: given a search query, decide whether the thing the searcher wants is a single short fact that a results page could show in full, and classify the intent into one of eight buckets. That decision drives which pages get their titles rewritten. The corpus was 483 real Search Console queries from the previous 90 days, with operator strings and monitoring noise stripped by regex first.
Speed held up. Median service time was 314ms and the 95th percentile was 399ms, which sits inside the 70ms to 500ms band TypeSafe advertises. The whole run of 483 decisions finished in 20.2 seconds at a concurrency of 8. Of all the vendor claims on this page, the latency band is the one that reproduced exactly as published.
Cost came in below every published figure. The run billed $0.0115 for 483 decisions, which is $0.0238 per 1,000. That is cheaper than the $0.035 to $0.043 the three outside testers measured, and about one seventeenth of the $0.40 per 1,000 implied by TypeSafe’s own eval table. The reason is state size: a search query is a handful of words, so there is almost nothing to bill for. Priced against the same token counts, GPT-5.6 Luna would have cost $0.1277 per 1,000 and Claude Haiku 4.5 $0.6267, making Jev 5.4x and 26.3x cheaper respectively.
Then the abstain rate ate the saving. On the binary decision, 57.8 percent of answers fell below a confidence of 0.5, and 94.4 percent below 0.8. Put our own 5.4x against Luna through the formula above at a 57.8 percent abstain rate and the blended multiple is 1.3x. The ceiling at that rate is 1.7x. On this task, at this state size, the cost advantage essentially disappears.
That looked like a finding about Jev until we tested the cheaper explanation. TypeSafe’s documentation says Jev carries no deep domain knowledge and that the fix is to put the missing context into the state. Every outside tester handed it a whole document, a product listing or a diff. We were handing it three words. So we re-ran the same 120 queries with a fatter state, adding the page that ranks for the query, its average position and its impression count:
| State handed to Jev | Mean confidence | Abstained at 0.5 | Abstained at 0.8 |
|---|---|---|---|
| The search query alone | 0.412 | 65.0 percent | 95.8 percent |
| Query plus ranking page, position and impressions | 0.505 | 40.0 percent | 95.8 percent |
Quadrupling the state cut the abstain rate at a 0.5 gate by 25 percentage points and lifted mean confidence by 23 percent, while changing nothing at the strict 0.8 gate. So the hedging was substantially ours, not the model’s: Jev’s confidence is a function of how much context you give it, and a thin state is a self-inflicted abstain rate. It is also the most likely reason our 58 percent sits so far above the 30 percent Alton measured, since his states were whole product listings rather than three words. That is one comparison against one published abstain rate, so treat it as the direction of the effect rather than a calibrated conversion.
On the 18 hand-labelled queries, where the answer key is a human judgment rather than another model, Jev got 17 of 18 right on the binary question and 17 of 18 on the eight-way intent classification. That is a small sample and should be read as a sanity check, not a benchmark.
The practical lesson is the one the pricing page cannot tell you. Before estimating savings from a decision model, measure your abstain rate on your own data, then budget the escalations. If the state you can supply is thin, the number to fix first is the state, not the vendor.
I later put this same kind of decision to work on one of my own sites, with a fatter state (query, ranking page, title, description, position and impressions) and five yes or no questions per pair. That triage, plus the Claude Code fixes it drove, moved the site’s average Google position from 12.7 to 6.2. The workflow and results are in Jev for SEO: Search Console API triage with Claude Code.
Where Jev beats a chatbot (use cases in plain English)
The pattern across every good use case is the same: the possible answers are known up front, the same judgment repeats thousands of times, and a wrong answer is cheap if it gets flagged but expensive if it acts silently. Confidence scoring is what makes the pattern work, because the program can sort the sure calls from the doubtful ones. For the builds themselves, the site’s breakdown of 562 Jev use cases from launch week sorts community demos by domain and shows which ones became products.
1. Smart if-statements inside ordinary software. This is the core pitch. Support ticket routing (billing vs technical vs account), refund triage (was a refund requested, is there a duplicate charge, does the policy allow it), resume screening against fixed criteria, lead scoring against an ideal customer profile. Each check is one narrow question, and code combines the answers with deterministic rules. TypeSafe’s invoice-processing workflow demo follows exactly this shape: read the bill, the order, and the delivery record, then pay, hold, or send back.
2. Scanning huge piles of data. When the unit price falls by two orders of magnitude, jobs that were uneconomical become routine. Examples from the 2026 TypeSafe use-case map include classifying large agent-trace logs, scoring query-to-document relevance across a corpus, extracting product attributes from messy seller listings, and turning customer messages into features for a forecasting model. The model reads each item once and returns numbers a database can store.
3. Real-time paths where waiting is failure. TypeSafe reports end-to-end responses of 70ms to 500ms, against a cited 3 to 329 second span for frontier chat models on comparable decision queries. At that speed the model can sit directly in a user-facing path: moderating a chat message before it renders, scoring a transaction before approval, picking the next game action. The Doom bot and the Wikipedia racing demo (picking among hundreds of links per step, with choice cardinality up to 255) exist to prove this point, not to sell game bots.
4. Checking other AIs. One of the most practical near-term roles is watchdog, not worker. A cheap decision model can screen every prompt going into an expensive model and every answer coming out: is this a jailbreak, does this citation support the claim, did that tool call pick valid arguments, how severe is the policy risk. TypeSafe’s docs include full LLM guardrail and citation-check recipes for this. Because the checker costs a fraction of the model it guards, full coverage stops being a luxury.
5. Making agent harnesses cheaper and faster. Agent loops today call a big model for every micro-decision: which tool next, is this context relevant, did that step fail. LangChain’s September 2026 writeup on building a harness with Jev walks through moving those micro-decisions to Jev while reserving the chat model for steps that need prose or deep reasoning. That matches the broader harness pattern of keeping code in control and spending intelligence only where prose understanding is needed, described in the site’s harness engineering guide.
The four published workflow evals give a sense of scale. Averaged across security-incident triage, agent-trace review, invoice processing, and customer-service routing, the TypeSafe workflow evals put Jev at 67.8 percent agreement with the reference answer at about $0.0004 per case in 0.4 seconds. The comparable workflow-mode LLM rows on the same chart read: GPT-5.6 Terra 67.9 percent at $0.0304 in 10.1 seconds, GPT-5.6 Sol 74.1 percent at $0.0836 in 23.3 seconds, and Anthropic Opus 5 at 73.1 percent at $0.1761 in 37.8 seconds. By this site’s arithmetic that is roughly 76x cheaper per case than Terra and 440x cheaper than Opus 5 on these tasks, with Sol and Opus holding a 5 to 6 point accuracy edge.
What Jev is bad at (and the honest caveats)
A decision box fails wherever the answers cannot be listed in advance. Chat, brainstorming, code writing, math proofs, open-ended research, and anything that must explain itself in sentences are all wrong for Jev. It accepts text only (no images, audio, or video; images must be converted to text descriptions first), English works best with other languages explicitly uneven, and choices top out at 255 options with a slower two-stage path at the high end.
The early-access onboarding page is blunter about the ceiling than the public material is, and names two limits that appear nowhere on the marketing site or in the docs. The first is reasoning depth: TypeSafe states that Jev is weaker than large reasoning models on System 2 tasks that involve high reasoning, giving mathematical reasoning and games such as chess as its own examples. That is a sharper admission than the general “not a reasoning model” framing elsewhere, and it draws the line in a useful place. Anything that needs a chain of inference rather than a judgment call belongs with the expensive model.
The second is domain knowledge. TypeSafe says Jev does not have deep knowledge of niche domains, and that the workaround is to supply the missing context in the state rather than to expect the model to know it. In practice that shifts the burden onto whoever builds the prompt: a specialist decision needs the specialist material handed to it every call, which eats into the 32k state budget. The same page invites users to get in touch if they want Jev trained on their use cases. That invitation sits oddly against the models documentation, which states that Jev is not fine-tuned or adapted per customer and that all accounts run the same weights. Read it as a design-partner opening rather than a shipped feature.
TypeSafe is also candid, in private, about which of its claims it cannot support. On frontier-level intelligence for System 1 tasks, the onboarding page says plainly that this is the hardest claim to defend and that nobody in the field has found a good way to prove it, inviting users to experiment and judge for themselves. Set that against the home-field problems in the published evals below and the honest position is clear: the speed and price are verifiable today, the intelligence claim is not.
The benchmark evidence needs discounting in four ways, all disclosed by TypeSafe in the launch post’s own nuance sections. First, accuracy means agreement with a reference answer defined as the average of GPT-6 Astra and Claude Fable 5.1, which bakes OpenAI and Anthropic house styles into the answer key. Second, the four workflows were built by TypeSafe’s own capabilities team and are not in the training data but were not independently audited either. Third, latency figures were measured from laptops on the US West Coast near TypeSafe’s serving region, so readers elsewhere should expect worse. Fourth, the competing LLMs were run through TypeSafe’s own structured-decision wrapper, which the company says is the most accurate way to extract decisions from chat models but also slower and pricier than free-form prompting. None of this makes the results fake, but it makes them home-field results.
There is one more limit that only shows up once you run it, and it is the one that costs money. Jev’s confidence tracks how much state you hand it, so a thin state produces a high abstain rate, and a high abstain rate is what actually destroys the cost advantage (see the arithmetic above). Our own run measured a 25 point drop in the abstain rate from nothing more than adding three fields to the state. Budget for the escalations before budgeting the savings, and treat “how much context can I actually supply per call” as the first design question rather than the last.
Two more cautions. Early access means rate limits shift without notice and enterprise terms are still forming, so capacity planning on today’s limits is premature. And “cannot hallucinate” is a claim about format, not correctness: as outside coverage from NYU’s AI researchers noted in September 2026, a well-typed answer can still be the wrong answer. The safety story is confidence plus code review thresholds, not infallibility.
Bottom line
Jev matters because it attacks the actual blocker on automation. Chat models have been brilliant conversationalists that businesses cannot leave unsupervised, since free text can always wander off script. A model that only returns pre-declared values with a stated confidence level slots into software the way a database query does: inspectable, sortable, branchable, and cheap enough to run millions of times. On that, the evidence is unanimous: the speed is real, the price is real, and five outside testers plus our own run all confirmed both.
The number to stop repeating is 444.6x. It is the Opus 5 row on its own, and the measured range runs from 8.6x against a cheap open-weight model to about 580x against a frontier one. Which end you land on is a fact about what you were paying before, not about Jev.
And the multiple is the wrong thing to plan against anyway. The abstain rate sets the ceiling, at 1 divided by that rate, and it does so no matter how close to free the decision model gets. Thirty percent abstention caps the saving at 3.3x; the 57.8 percent we measured on a thin state caps it at 1.7x. Before estimating savings, run a few hundred of your own decisions, measure what comes back undecided, and price the escalations. If the workload is repeated judgments with known answers and you can hand over real context with each one, Jev is a serious tool. If the workload needs words, keep the chatbot.
Jev is deliberately absent from this site’s AI model tracker. That registry prices text models per token in and per token out, and Jev bills only on input, with no output meter and no prompt cache. Listing it there would put a model that cannot emit output tokens into calculators that assume it can.
Frequently asked questions
- What is a System One model?
- A model class built for decisions inside software. It reads natural language context and returns typed values with probabilities instead of generated text. Jev is the first public System One model from TypeSafe.
- How much does Jev cost?
- The listed price is $0.042 per million input tokens ($42 per billion) with output tokens free. There is no per-seat fee published; usage is metered on input through the System One API.
- How fast is Jev?
- TypeSafe reports 70ms to 500ms end to end per call, with all questions in one request evaluated in parallel. Published workflow averages put it near 0.4 seconds per case versus 10 to 38 seconds for comparable LLM rows.
- Why do TypeSafe speed and cost claims range from 20x to 444x?
- Because the figure depends on which TypeSafe surface publishes it and which model it is measured against. The homepage advertises 193.6x faster and 444.6x cheaper, the public launch post gives 40x to 200x faster, and the early-access onboarding page gives 20x to 200x faster and 40x to 1,000x cheaper. Working the published eval table by hand gives about 25x to 95x faster and 76x to 440x cheaper, with the 440x figure coming only from the comparison against Claude Opus 5, the most expensive comparator.
- Has anyone tested Jev independently?
- Yes. Five outside tests were published between September 15 and 19, 2026. Every measured about 25x faster and 580x cheaper than Claude Fable 5.1 on document judgments. Near Here measured 8.6x cheaper than Mistral Small 4 on 50 moderation cases, with Jev correct on 48 of 50. The gemanor code-review benchmark measured 45x and 274x cheaper over 1,080 calls at 98.0 percent correctness. Paddy Alton ran 9,081 real product matches for $0.32. Arize AI reported 98.3 percent on 18,514 spam emails against a trained classifier at 98.4 percent, the only test so far using real labels rather than agreement with another model.
- What is an abstain rate and why does it matter more than the price?
- An abstention is a decision the model hands back because its confidence fell below your threshold, and it has to be escalated to a full LLM. That escalation, not the Jev bill, dominates the cost. The blended multiple is M divided by (1 + a times M), where M is the multiple on answered cases and a is the abstain rate, so the saving is capped at 1 divided by the abstain rate no matter how cheap the decision model is. At the 30 percent abstain rate measured on a real production queue, a 76x advantage blends down to 3.2x and the ceiling is 3.3x.
- Can TypeSafe make money at $0.042 per million tokens?
- TypeSafe says yes, but has not shown evidence. Its public launch post says only that it cannot prove the price is unsubsidized and expects prices to fall rather than rise. Its early-access onboarding page states directly that it can serve these models profitably. Both are company statements, so treat the price as an early-access sticker until a longer track record exists.
- Can Jev hallucinate?
- It cannot produce a type error or an out-of-schema value by construction, but it can still return the wrong allowed value. The mitigation from TypeSafe is calibrated confidence plus code-level review thresholds, not perfection.
- Is Jev a replacement for ChatGPT or Claude?
- No. It cannot chat, write, or code. It fits where answers are known up front and repeat at volume: routing, scoring, screening, extraction, and guardrail checks around other models.
- How do developers try it?
- Through early access on typesafe.ai via the System One API or the Python and JavaScript SDKs, sending a state plus Choice, Score, or Noul questions. Vercel added Jev to its AI Gateway on September 16, 2026, reachable as `typesafe-ai/jev` through the experimental evaluate API in AI SDK 7.0.105 and later, and Pydantic AI ships a TypeSafeModel class for the same purpose.
Sources
TypeSafe AI (2026). Introducing System One Models and Jev. Company blog. https://typesafe.ai/blog/introducing-system-one-models-and-jev
TypeSafe AI (2026). Welcome inside TypeSafe: Meet Jev. In-product early-access onboarding page, accessed September 19, 2026. Behind authentication, not publicly accessible.
TypeSafe AI (2026). Models: pricing, limits, and context for Jev 1.13. Documentation. https://docs.typesafe.ai/models
TypeSafe AI (2026). System One concepts. Documentation. https://docs.typesafe.ai/concepts/system-one
TypeSafe AI (2026). Introduction: primitives and parallel questions. Documentation. https://docs.typesafe.ai/introduction
TypeSafe AI (2026). Example use cases. Documentation. https://docs.typesafe.ai/concepts/use-case-map
TypeSafe AI (2026). Workflow evals: accuracy, cost and latency across four automation tasks. Evals site. https://evals.typesafe.ai/
TypeSafe AI (2026). TypeSafe AI Emerges From Stealth With $40M in Funding. Business Wire announcement. https://www.businesswire.com/news/home/20260915525333/en/
LangChain (2026). Building a Harness with Jev (Sydney Runkle and Hunter Lovell, September 17). Secondary coverage of harness integration. https://www.langchain.com/blog/building-a-harness-with-jev
DataCamp (2026). Jev: TypeSafe’s System One Model Explained. Secondary explainer with independent reading of the eval numbers. https://www.datacamp.com/blog/system-one-models-jev
Taylor, Mike (2026). Mini-Vibe Check: TypeSafe’s Jev Judged Everything I’ve Written in 0.7 Seconds (September 15). Every. Independent test. https://every.to/also-true-for-humans/mini-vibe-check-typesafe-s-jev-judged-everything-i-ve-written-in-0-7-seconds
Near Here (2026). Testing TypeSafe Jev, Mistral and Gemini for local event validation (September 16). Independent test by a local-events publisher. https://nearhere.events/blog/typesafe-jev-mistral-gemini-event-validation
gemanor (2026). jev-code-review-benchmark (September 17). Independent benchmark with published code and results. GitHub. https://github.com/gemanor/jev-code-review-benchmark
Alton, Paddy (2026). The Thirty-Cent Judge: TypeSafe’s Jev on a Real Product-Matching Queue (September 19). Independent test on a production queue. https://paddo.dev/blog/thirty-cent-judge
Voss, Laurie (2026). TypeSafe Jev: Can Decision Models Replace LLM Judges? (September). Arize AI. Independent test with ground-truth labels. https://arize.com/blog/typesafe-jev-llm-judge/
Vercel (2026). TypeSafe AI’s Jev now available on AI Gateway (September 16). Changelog, documenting availability via AI SDK 7.0.105 and later. https://vercel.com/changelog/typesafe-ai-jev-now-available-on-ai-gateway
Capital & Compute (2026). First-party Jev benchmark: 483 Search Console queries (September 20). Method and raw output committed in this repository at scripts/jev/benchmark.mjs and docs/jev/benchmark-2026-09-20.json.