Comparison
Jev vs an LLM
The comparison people reach for first, and the one that misleads fastest. These are not two models competing for the same slot — one produces text and one produces a decision, and the interesting question is which parts of your pipeline are which.
Side by side
| Axis | Jev | A frontier LLM |
|---|---|---|
| Output | A typed decision — option, probabilities, confidence | Tokens. Anything you can describe in words |
| Price per decision | $0.0004 (vendor eval) | $0.0304 – $0.1761 (vendor eval) |
| Latency | 0.4s | 10 – 38s for reasoning-mode frontier models |
| Context | 64k per request, 32k state + longest question | 200k – 1M+ depending on model |
| Answer space | Fixed at request time, up to 255 options | Open — it can invent an option you did not list |
| Calibration | A probability per option, trained for it | Logprobs at best; verbalised confidence is not calibrated |
| Streaming | Nothing to stream — one structured answer | Token by token |
| Self-hosting | None. Closed weights, hosted API only | Open-weight families are self-hostable |
Accuracy: the vendor does not claim the win
This is the part worth reading carefully, because the marketing headline — 193.6x faster and 444.6x cheaper than frontier llms in peak in-house testing. — is about speed and cost, and people hear it as being about quality.
| Model | Accuracy | Cost | Latency |
|---|---|---|---|
| Jev | 67.8% | $0.0004 | 0.4s |
| GPT-5.6 Terra | 67.9% | $0.0304–$0.1761 | 10–38s |
| Opus 5 | 73.1% | $0.0304–$0.1761 | 10–38s |
| GPT-5.6 Sol | 74.1% | $0.0304–$0.1761 | 10–38s |
The arithmetic that usually decides it
Take the vendor's own per-decision figures and run a workload through them. A million decisions a month — a mid-sized support queue, a moderation pipeline, a router in front of a busy agent:
Jev
$400
1,000,000 × $0.0004. Output tokens are free because there are none.
Frontier LLM
$30,400 – $176,100
1,000,000 × $0.0304–$0.1761, before you count retries and the tokens spent on reasoning you throw away.
Latency compounds the same way. At 0.4s against 10–38s, a decision that sits in a user-facing path is the difference between a spinner and no spinner. The honest framing is that Jev does not beat an LLM on the decision — it makes the decision cheap enough to make many of them, which is a different and often more useful property. See the cost page for a calculator on your own volume.
Where the LLM wins outright
Not a matter of taste — TypeSafe documents most of these itself as jagged edges in jev-1.13.
- Anything that ends in words. Summaries, replies, code, explanations. Jev is not trained to generate text and forcing it by chaining choices is slow and bad.
- Open-ended answer spaces. Choice picks from the list you send. If you cannot enumerate the options, there is no encoding of the question.
- Arithmetic, counting and dates. Jev reads dates as text rather than ordered quantities, and counts by recognising the shape of an answer rather than tallying.
- Multi-hop reasoning. A question about a property of a property costs accuracy. That is what “System One” means: fast judgement, not deliberation.
- Tool use and agentic loops. Jev can pick the tool; it cannot run the loop, write the arguments, or read the result back into prose.
Where Jev wins outright
- Decisions per dollar. Two orders of magnitude is not an optimisation, it is a different design space. Questions you would never have asked an LLM because they were not worth three cents become free.
- A probability you can branch on. You get a distribution over your options and a confidence value, so your code can route, defer or escalate. Asking an LLM how sure it is gets you a number that reads like confidence and is not calibrated like one.
- Shape guarantees. The answer is typed. There is no JSON to repair, no “Sure! Here is the classification:” to strip, no schema retry loop.
- Latency inside a request. Sub-second decisions can sit in a synchronous path. A 20-second reasoning call cannot.
- Consistency. Semantically similar inputs get quantitatively similar outputs, which is what makes a threshold hold over time.
The configuration that beats either one alone
The strongest published result on Jev is not Jev winning a head-to-head. It is Jev used as a signal generator. In a 2,000-email phishing study, Jev's single verdict lost clearly to Claude Haiku 4.5 — and then a plain logistic regression over five cheap signal questions asked in the same call reached 95.1% accuracy with AUROC 0.988.
The everyday version of the same idea: Jev classifies and routes, the LLM handles the cases Jev is not confident about and writes whatever the user actually reads. Gate on confidence, keep an LLM-only fallback that you actually exercise, and you get most of the cost saving without betting the product on a 67.8%.
Picking, in one pass
Reach for Jev when
The options are known, the volume is high, the answer feeds an if, and you want a probability rather than a verdict.
Reach for the LLM when
A human reads the output, the answer space is open, the task needs several steps of reasoning, or the volume is low enough that the cost difference is noise.
Worth saying plainly: at low volume this comparison does not matter. Ten thousand decisions a month is $4 against $304 — real, but not a reason to add a second vendor, a second outage surface and a second SDK. The case for Jev gets strong when decisions are many, repetitive, and in the way.
Common questions
Is Jev better than GPT or Claude?
Not at accuracy, on the evidence available. TypeSafe's own evaluation puts Jev at 67.8%, below GPT-5.6 Sol at 74.1% and Opus 5 at 73.1%. The claim is comparable accuracy at roughly 1/100th the cost and 1/50th the latency — not a better model.
Can Jev replace my LLM?
Only the decision steps. Jev emits no text at all, so anything that ends in a sentence still needs an LLM. In practice most systems that adopt Jev end up running both: Jev decides, the LLM writes.
Is Jev cheaper than an LLM?
Dramatically, for decisions. Input is $0.042 per million tokens and output tokens are free because none are generated. TypeSafe's own table puts a decision at $0.0004 against $0.0304–$0.1761 for frontier models.
When should I not use Jev instead of an LLM?
When the answer is text, when you cannot enumerate the options, when the task needs arithmetic or date comparison, or when it needs several hops of reasoning. TypeSafe documents all of these as failure modes for jev-1.13.
Prices and limits here are $0.042 per 1M input tokens on input with free output, verified against the official docs on the date in the footer.