Jev vs Kev: A $95 Fine-Tune That Beats Jev on Support Tickets

Jared Palmer released Kev on September 20, 2026, five days after TypeSafe AI launched Jev, and the important number is not in the benchmark table. It is in the README: the whole thing cost about $95 in H100 time on Modal, plus three cents of Jev API calls used to generate evaluation data. Kev is Apache-2.0, self-hostable, and comes in three sizes built on the Qwen3.5 base weights — roughly 0.8B, 4B, and 9B — with a rank-16 LoRA adapter and a pointer head bolted onto a frozen base rather than a from-scratch decision model. It mirrors Jev's typed-decision API exactly: Choice, Score, and Noul, close enough to be compatible with TypeSafe's own Python SDK. Jev, for its part, launched September 15, 2026 as TypeSafe AI's closed, hosted System One model, returns typed answers with calibrated confidence and no text at all, and has never published its architecture, parameter count, training compute, or weights. The comparison is therefore not really a model comparison. It is a test of how much of Jev's value survives being reproduced in an afternoon for the price of a used laptop.

What the benchmarks actually say

The headline is that Kev gets close, and on one narrow task it wins. On Kev's locked new-source test set, Kev-9B scored 0.837 against Jev's 0.857. On support-ticket routing across 900 tickets — the scienthoon set — Kev-9B scored 0.952 against Jev's 0.897, which is the one published result where the open reproduction beats the model it reproduces. Kev also edges ahead on some logic-recognition tasks. On SemiF decision sets, a 144-question structured set, Jev takes it 0.965 to Kev-9B's 0.917.

Where Kev loses, it loses badly. Out-of-domain accuracy: Kev-8B at 79.6% against Jev's 85.7%. MMLU: 70% against 90%. MMLU-Pro: 0.515 against 0.840. Date arithmetic at day precision: 60% against 93%. The pattern is consistent — Kev is competitive on narrow routing and classification where the label set is small and the domain is fixed, and it falls apart on anything that needs world knowledge or multi-step arithmetic, because a rank-16 adapter on a frozen small base model is not where world knowledge lives.

Every one of those figures comes from Kev's own harness or from third-party trackers, and Palmer's README says plainly that it is not a controlled comparison — Jev's training data is undisclosed, so there is no way to build one. The README also states that no Jev outputs were used for training. Both disclaimers are the kind that make the numbers more trustworthy, not less: the person publishing the comparison is the one telling you what it cannot prove.

What you get for $95 that you cannot get from Jev at any price

The cost comparison is where the two products stop being comparable at all. Jev is $0.042 per million input tokens with output free, which is cheap in a way that is genuinely hard to beat on a per-call basis — but it is a hosted, early-access API with a waitlist, and TypeSafe has said rate limits may change without notice. Kev is weights you download. The marginal cost of the ten-millionth classification is your own electricity.

Four things follow from that and none of them are about benchmark scores.

• No data leaves your infrastructure. Jev is a hosted endpoint; every state you send it — the support ticket, the log line, the medical record — goes to TypeSafe. Kev runs on your own GPU, which for regulated workloads is not a preference but the deciding factor.

• No rate limits, no waitlist, no deprecation risk. TypeSafe's own documentation notes that rate limits may change without notice. A local checkpoint has no such clause.

• You can fine-tune it. Kev is a base to specialise, and the LoRA recipe that produced it is public. If your routing taxonomy has 40 classes that no general model handles well, you can train on your own labels — which is exactly what Palmer did, at a cost measured in tens of dollars rather than in an ML team.

• The context ceiling is yours to change. Jev's documented request budget is roughly 32,000 tokens and Choice fields cap at 255 options. Kev inherits Qwen3.5's window, which is far larger, and the option cap is an implementation detail of your own serving stack rather than a vendor limit.

What Jev still has that Kev does not

The calibration claim is the one that does not transfer cleanly, and it is the heart of TypeSafe's pitch. Jev is trained with a method TypeSafe calls RLCD — Reinforcement Learning for Calibrated Decisions — which optimises for the confidence value being honest rather than for the answer being preferred. Every Jev answer ships with a probability distribution over the options, so your code can set thresholds: act automatically at the top band, flag in the middle, escalate at the bottom.

Kev produces the same typed shape and the same probability outputs, because the API is deliberately compatible. Whether those probabilities are calibrated is a different question, and the honest answer is that nobody has published a reliability diagram for either model. A separate calibration audit reported Jev scoring 44.7% accuracy with an expected calibration error of 0.325 on a hidden-policy priority task, which suggests calibration on Jev varies sharply by task rather than being a universal property — and TypeSafe itself tells users to test confidence thresholds against their own labelled examples rather than trusting the published behaviour.

The other thing Jev has is that it was not trained on Qwen3.5. A 9B model with a rank-16 adapter has a knowledge ceiling, and the MMLU-Pro gap of 0.515 against 0.840 is that ceiling made visible. If your routing decision occasionally requires knowing what a thing is, Jev's larger undisclosed architecture is doing work that Kev's adapter cannot.

Latency and the deployment shape

Jev's documented end-to-end latency is 70–500ms against 3–329 seconds for frontier LLM calls in TypeSafe's own comparison, and adding questions to a call barely moves it because every question is evaluated in parallel against one shared read of the state. Kev-9B on an H100 will be in the same order of magnitude for a single forward pass, but the comparison is not apples to apples in either direction: a self-hosted 9B on a shared GPU under load is not the same latency as a hosted endpoint, and a hosted endpoint is not the same as a box in your own rack. What can be said without hedging is that both are fast enough for per-turn use in an agent loop, and that Kev's latency is a function of hardware you control rather than a service level you are promised.

The honest read on the reproduction

The fact that Kev exists at all is evidence about Jev, and it is worth naming. A closed model whose behaviour can be approximated in five days for $95, by one person, on public base weights, is telling you something about how much of its advantage is architecture and how much is training data and serving. It does not follow that Jev is easy to build — the API surface is easy to copy, and the calibration is not. But it does mean the moat is not the interface, and anyone evaluating Jev for a production path should price in the possibility that a fine-tune of an open base gets them most of the way for a fraction of the commitment.

Which is also the argument for not betting a production path on either one yet. If you are evaluating Jev, the sensible posture is to try it without committing to it — and OrcaRouter does not serve Jev, because TypeSafe's model is early-access and speaks its own request shape. What we do cover is the generative half of the workflow these decision models sit inside: 200+ models behind one OpenAI-compatible key at provider list price passed through with 0% markup, with automatic failover. A two-model architecture where a cheap decision layer sorts traffic and a generative model handles the remainder is testable on our side without a second vendor contract, and if the decision component turns out to be badly calibrated on your data, the failover path is what stops that from becoming an incident.

The verdict

If your decision task is narrow, fixed-domain, high-volume, and privacy-sensitive, Kev is the more defensible choice today and it is not close — you own the weights, you control the data path, you can fine-tune on your own labels, and on support-ticket routing the 9B checkpoint already beats Jev on its own published numbers. If your decision task needs world knowledge, multi-step arithmetic, or a confidence value you intend to automate against, Jev's larger undisclosed model and its RLCD training are doing real work and Kev's adapter is not a substitute for either.

The one thing neither comparison settles is calibration, because nobody has published a reliability diagram for either model. Test that on your own labelled cases before you automate against either — the confidence value is the part of both products that has to be earned per deployment, and the speed is the part that is already commoditised.