# What Is Jev? TypeSafe AI's System One Model, and What the Independent Testing Actually Shows

Canonical: https://trutool.co/guides/what-is-jev-typesafe-ai
Author: Yash
Last modified: 2026-10-13T20:42:18.348Z

Jev is an AI model from TypeSafe AI that returns typed decisions instead of text. You send it state plus typed questions, and it returns structured answers with probabilities in roughly 70 to 500 milliseconds, at $0.042 per million input tokens with output billed at nothing.

## Quick answer

**Jev is an AI model from TypeSafe AI that returns typed decisions instead of text.** You send it a piece of state, such as a support ticket or a retrieved document, along with one or more typed questions about that state. It returns structured answers with probabilities attached, in roughly 70 to 500 milliseconds, at $0.042 per million input tokens with output billed at nothing. It cannot write a sentence, and it is not meant to.

TypeSafe calls this category a "System One model," after the fast, automatic thinking in Daniel Kahneman's *Thinking, Fast and Slow*. The practical claim is that a large share of production LLM calls are not generation tasks at all. They are classification dressed up as conversation: pick a queue, score a risk, decide whether this tool call is safe. Jev does only that part, and does it without generating tokens one at a time.

The launch numbers were dramatic: up to 193.6x faster and 444.6x cheaper than frontier models. Those figures come from TypeSafe's own evaluations on workflows TypeSafe's own team built. Independent testing in the weeks after launch tells a more complicated story, and that story is the most useful thing to understand before adopting it.

## Who built it, and when

TypeSafe AI is a San Francisco company founded in 2024 by Diogo Almeida (CEO), Erik Gafni, and Sasha Sheng. It developed Jev in stealth for roughly two years.

Jev entered limited early access on **15 September 2026**, alongside a **$40 million seed round led by DCVC**. Forbes reported a valuation around $200 million. The stable release listed at launch was jev-1.13.0.

Almeida spent about four years at OpenAI and is a primary author on the InstructGPT paper, the research line that fed into ChatGPT. One point of accuracy worth flagging, since it circulated widely in launch coverage: some write-ups credited him with co-inventing RLHF. That attribution does not hold up. Reinforcement learning from human feedback traces to Christiano et al. (2017). His InstructGPT authorship is real and significant on its own.

The name references **William Stanley Jevons**, the economist behind Jevons paradox, the observation that efficiency gains in using a resource tend to increase total consumption rather than reduce it. Almeida has said the name reflects an expectation that much cheaper machine judgment will mean far more of it, not less.

## How Jev actually works

A request has two parts: a **state** and a set of **questions**.

The state is the thing being judged. It can be a plain string, a JSON object, or an array of text. The questions are typed, and there are three kinds:

**Noul.** A yes/no statement, answered with a probability between 0 and 1. "This email is a phishing attempt." "This passage supports the claim being cited." The returned value is clamped between 0.01 and 0.98.

**Choice.** Pick one option from a predefined set. Returns the selected option plus a probability distribution across all options and a confidence score. Supports up to 255 options. Above that, Jev uses a two-stage process: score options independently, then make an explicit selection.

**Score.** Place the state on an ordered rubric. Returns a level, a distribution, and confidence.

All questions in a single request are evaluated **in parallel against the same state**. This is the architectural core. Adding a fourth question to a request costs the tokens of that question and almost no extra latency, because nothing is being generated sequentially. TypeSafe built a parallel sampler that produces all outputs in one query rather than decoding token by token.

Current limits are 64k tokens for state plus questions combined, and 32k for state plus the longest single question.

### The training method

TypeSafe describes its approach as **Reinforcement Learning for Calibrated Decisions (RLCD)**. Where RLHF optimizes for outputs human raters prefer, RLCD is described as optimizing for probabilities that match real outcomes. If Jev says 0.7 across a thousand decisions, roughly 700 should turn out true.

That is the interesting claim, and it is worth separating from the speed and cost headlines. Calibration, not raw accuracy, is what makes a confidence threshold meaningful. A model that is 85% accurate but wildly overconfident is harder to build on than one that is 78% accurate and honest about which 78%.

**No technical paper, architecture, weights, or model size has been published.** TypeSafe describes Jev as transformer-based and trained only on synthetic data. Outside observers have speculated it may be built on an open-weight base. Several Hacker News commenters asked whether it amounts to a logprobs wrapper on a classifier; Almeida's response was that the calibration training data is the actual bottleneck, not the inference trick.

### What "can't hallucinate" does and does not mean

TypeSafe states that Jev never produces type errors and cannot hallucinate. This is true in a narrow and genuinely useful sense, and misleading in a broader one.

Because answers are drawn from a schema you define in advance, Jev structurally cannot return a value outside that schema. There is no JSON parsing step, no retry loop, no malformed output to handle. That removes an entire category of production failure.

It does not mean the answers are right. As one Hacker News commenter put it, Jev "can't emit an invalid type, but it can still emit a wrong valid value." TypeSafe's own documentation is reasonably candid about this. The guarantee is about the shape of the output, not its truth.

## Pricing and access

|  | Jev |
| --- | --- |
| Input tokens | $0.042 per million |
| Output tokens | Free |
| Latency (reported) | 70 to 500 ms end to end |
| Max state + questions | 64k tokens |
| Max options per Choice | 255 |

For comparison, frontier LLM input pricing generally runs $0.20 to $10 per million tokens, with output typically around 5x the input rate. **Free output is where most of the cost difference comes from.** In one workload examined by independent testers, output accounted for 83% of the previous bill.

TypeSafe has acknowledged it cannot currently demonstrate that pricing is unsubsidized, which is a fair thing to keep in mind for anything you plan to build on long term.

Access opened as a waitlist. Public signups with $5 in credit opened on 20 September and were paused on 22 September. Jev is also reachable through the Vercel AI Gateway as typesafe-ai/jev and through OpenRouter.

## The benchmark picture: vendor claims versus independent evidence

This is where most coverage stops short, and it is the part that should drive your decision.

### What TypeSafe claims

The headline figures are **193.6x faster and 444.6x cheaper**, with a stated general range of 40 to 200x faster and 40 to 400x cheaper. These come from four internal workflow evaluations: invoice review, security incident handling, agent trace review, and customer service.

TypeSafe is reasonably transparent about the method's limits. The workflows were built by its own model capabilities team. Reference answers are the averaged outputs of GPT-6 Astra and Claude Fable 5.1, which means the benchmark measures agreement with other models rather than ground truth. Latency evaluations were run from team laptops on the West Coast.

Notably, TypeSafe's own numbers do not claim accuracy leadership. On its published evaluation, Jev scores 67.8% against GPT-5.6 Sol at 74.1%. On invoice processing specifically, Jev scores 61.8% against Sol's 79.1%.

### What independent testing found

A systematic review published eight days after launch examined 14 arXiv preprints, 104 GitHub evaluation repositories, and 33 blog posts, grading each by evidence quality. Of the 33 posts, only 5 were careful measurements; 17 simply restated vendor claims. That ratio is worth holding in mind when reading anything about Jev, including this.

**On accuracy, Jev is competitive but not leading.**

The largest pre-registered study (Ibrahim and Zaki, arXiv 2609.24574) used 7,977 human-labelled items across 19 LLMs. Jev trailed the best per-task LLM on **14 of 15 tasks**, by a median of 11.6 macro-F1 points. Within its own price band, Gemma 4 31B and Qwen3 235B scored 3 and 2 F1 points above it.

A smaller re-scored comparison across 200 items and four tasks:

| Model | Accuracy | ECE (lower is better) |
| --- | --- | --- |
| Claude Fable 5.1 | 84.0% | 0.064 |
| GPT-6 Astra | 79.0% | 0.119 |
| DeepSeek V4.1 Flash | 76.0% | 0.138 |
| MiniMax M3 | 75.5% | 0.112 |
| Kimi K3 | 74.5% | 0.119 |
| Jev | 72.5% | 0.161 |

The gaps to the two frontier models are statistically meaningful. The gaps to the mid-price models are within noise. The reviewer's summary was blunt: level with mid-price LLMs, behind the frontier.

Against purpose-built baselines, Jev performs about as well as what it would replace, not better. On 18,514 spam emails it scored 98.33% against a trained TF-IDF logistic regression at 98.39%, a statistical tie. On eight retrieval sets it scored 0.692 against a dedicated reranker's 0.691. On one phishing dataset it scored 62.6% where a specialist model scored 97.4% and a plain regex scored 91.6%.

**On speed and cost, the multipliers collapse outside favourable comparisons.**

Averaged across all eight measured setups rather than TypeSafe's four, independent testers calculated **97.8x faster and 149.2x cheaper**, roughly half the headline figures. Individual comparisons varied enormously:

| Comparison | Faster | Cheaper |
| --- | --- | --- |
| Claude Fable 5.1, via OpenRouter | 9.9x | 478x |
| Haiku 4.5, phishing task | 2.9x | 12x |
| Mid-size open model, 47 reviews | 12.1x | 7.4x |
| GPT-5.6 Luna, client clock | 1.04x | 4.3x |
| DeepSeek, Banking77 | Not measured | 1.18x |
| Local Gemma 4 26B on a mini-PC | 0.5 to 0.65x (Jev slower) | Not measured |

A self-hosted Gemma 4 26B on an EC2 L4 at full utilisation was costed at most $5.43 per million decisions against Jev's $5.54 at 132-token prompts. At sufficient scale with your own hardware, the cost advantage disappears.

**On calibration, the picture is genuinely good but conditional.**

On a public 13-subset suite, Jev's median expected calibration error was 0.071, materially better than raw Gemma 4 readings at 0.114 to 0.180. On social science tasks it beat 16 of 19 LLMs on self-reported confidence.

The caveat: apply a single fitted temperature to those LLMs and 15 of them beat Jev. Fitting on just 50 labels cut Gemma 4 26B's median ECE from 0.180 to 0.080, essentially matching Jev as shipped. Jev's calibration advantage is real out of the box, and largely erasable with a small amount of labelled data.

Calibration also varies by domain. Independent runs found Jev overconfident on some datasets and under-confident on others, with refit temperatures ranging from 0.65 to 4.45. A test on 900 fresh support tickets found noticeably weaker calibration than on established benchmarks.

## Documented failure modes

TypeSafe publishes a "jaggedness" page listing known weaknesses, which is more candid than most vendors manage. Independent testing confirmed and extended it.

**From TypeSafe:** overly literal reading, arithmetic and counting, date comparison, multi-hop indirection, distraction when the state is large, adversarial content, and text generation of any kind.

**Found independently:**

*Option naming has outsized influence.* Swapping "yes" and "no" rubric labels changed 32.5% of answers in a 1,200-item study, against roughly 2% with neutrally named options. AUROC fell from 0.81 to 0.58. Bare labels with no descriptions performed badly in routing: one test sent all 40 hard tasks to the cheap model, and adding one-line option descriptions fixed 37 of them.

*Run-to-run variance is real.* Twenty identical runs on the same invoice ticket produced scores from 0.67 to 0.76. Reversing option order shifted results by around 0.1.

*Non-English performance drops.* Russian XNLI fell from 88.3% to 77.3%. Spanish lost 3 to 6 points. One German consultancy found the same ticket scored 0.67 to 0.76 in German and only 0.5 to 0.6 in English translation.

*Questions cannot see each other.* Because questions in a request are evaluated independently and in parallel, related answers can contradict each other. In one test scenario, each individual answer was defensible while the combination described a situation that could not exist.

*It does not reason about stated probabilities.* Given a scenario explicitly specifying a 45% likelihood, Jev returned 0.96 to 0.98. On a fair die, a Choice question averaged 83% confidence against a true 17%.

*No explanations.* Jev returns a category and a number. There is no reasoning trace, which removes the diagnostic signal an LLM judge provides when you are trying to improve the system around it.

## Where Jev genuinely fits

The honest shape of the fit, drawn from both vendor documentation and independent testing:

**Good fit.** High-volume binary or few-class decisions in English, where you have no labelled data yet and need something working immediately. Pre-filtering and reranking retrieved documents before an expensive model reads them. Risk-screening agent tool calls before execution. Prompt injection screening on fetched content. Routing by difficulty or intent. Citation verification. Exhaustive monitoring of traces, where checking everything was previously too expensive and you sampled instead.

That last one may be the most underrated. When a check costs a fraction of a cent and 300 milliseconds, you can run it on every trace rather than a sample. Several analysts have argued this changes evaluation pipelines before it changes production architecture.

**Poor fit.** Anything requiring generated text. Arithmetic, counting, or date logic. Multi-step reasoning. Rules that ordinary code already enforces, such as a fixed invoice threshold. Non-English work at scale. Decisions where you need to explain the reasoning to a human or a regulator. High-stakes calls without human review.

**Think carefully.** If you already have labelled data, a trained classifier will likely match or beat Jev at lower cost. If you run meaningful volume on your own hardware, an open model read by label-token scores gives a comparable typed interface with no per-call fee. If data cannot leave your infrastructure, Jev is a US-hosted service with no documented EU operation.

## Alternatives worth evaluating

The category Jev named is not one it occupies alone, and the open-source response has been quick.

**Open and community models:** Nimble-9B (75.9% against Jev's 77.3% on 13 public sets, seller-run), Kev (0.852 against 0.857 on dev), Luce, Laya, and openjev, a community reproduction that reached 0.845 agreement against TypeSafe's published 0.883 on 102 cases.

**Established approaches that still work:** BERT-style fine-tuned classifiers, zero-shot encoder models in the GLiNER family, constrained decoding against a self-hosted LLM, and plain logistic regression on good features. The spam and reranking results above are a reminder that a well-tuned classical baseline is hard to beat on a narrow task.

**Framework support:** LangChain ships langchain-typesafe with a TypeSafeClassifier, plus experimental ModelRouterMiddleware for difficulty-based routing and AutoModeMiddleware for blocking risky tool calls before execution. LangChain's own framing is worth quoting: "Jev isn't a drop-in replacement for an LLM." Community integrations include an MCP connector, a Ruby client, and a DSPy fork.

**Adjacent enterprise tooling:** SAP has positioned its SAP-RPT-1.5 tabular foundation model, which works on structured business data, as complementary rather than competing, with Jev handling the judgment boundary and RPT handling structured prediction.

## How to evaluate it for your own use

A practical sequence, synthesised from what the more rigorous testers actually did:

1. **Label 50 to a few hundred real examples from your own traffic.** Not synthetic ones. This is the single highest-value step and it gates everything below.
2. **Measure calibration on that set, not just accuracy.** Expected calibration error is the number that tells you whether a threshold will hold.
3. **Write descriptive option names.** Not "yes" and "no." The 32.5% answer-flip finding makes this a correctness issue, not a style preference.
4. **Test option-order sensitivity.** Run the same items with options reversed and compare.
5. **Benchmark against a boring baseline.** A trained classifier, or a small open model read by label scores. If Jev does not clearly beat it, the simpler thing wins.
6. **Re-measure on new traffic periodically.** Calibration drifts as inputs change, and the support-ticket finding suggests benchmark performance overstates fresh-data performance.
7. **Keep a human in the loop above a confidence threshold** until you have evidence on the failures that actually matter to you.

## Frequently asked questions

### What is Jev in simple terms?

Jev is an AI model that makes fast structured decisions instead of writing text. You give it some information and a set of predefined questions, and it returns answers chosen from options you specified, each with a probability. It is built to be called by software rather than read by people.

### Is Jev a large language model?

Not in the usual sense. TypeSafe describes it as transformer-based, but it does not generate text token by token and cannot produce free-form output. It returns typed values from a schema in a single parallel pass. TypeSafe calls the category "System One models." The architecture and model size are unpublished.

### Can Jev hallucinate?

It cannot return a value outside the schema you define, which eliminates malformed output and type errors. It can still select the wrong valid option. The guarantee is structural, not semantic.

### How much does Jev cost?

$0.042 per million input tokens, with output tokens free. Most of the cost advantage over LLMs comes from the free output, which in some workloads represented over 80% of the previous bill.

### Is Jev more accurate than GPT or Claude?

No, based on current independent evidence. The largest pre-registered study found Jev trailing the best per-task LLM on 14 of 15 tasks by a median 11.6 macro-F1 points. It performs roughly level with mid-price models and behind frontier models. Its advantages are speed, cost, output reliability, and out-of-the-box calibration.

### Are the 200x and 400x claims accurate?

They are accurate for specific favourable comparisons and not representative generally. Averaged across eight independently measured setups, the figures were 97.8x faster and 149.2x cheaper. Against some models the speed advantage nearly vanishes, and against a well-utilised self-hosted open model Jev can be slower and no cheaper.

### What is Jev bad at?

Arithmetic, counting, date comparison, multi-step reasoning, non-English input, reasoning about stated probabilities, and anything requiring generated text or an explanation. It is also sensitive to how options are named and ordered.

### Should I replace my existing classifier with Jev?

Probably not if your classifier is trained and working. Independent tests found Jev roughly tied with a TF-IDF logistic regression on spam and with a dedicated reranker on retrieval. Jev's advantage is strongest when you have no labelled data and want something working today.

### Is Jev open source?

No. Weights, architecture, model size, and training data are undisclosed, and it is available only as a hosted US service. Community alternatives including openjev, Kev, and Nimble-9B offer similar typed interfaces with open weights.

## The honest summary

Jev is a real and interesting architectural idea that arrived wrapped in numbers it does not quite support.

The idea is sound: a large share of LLM calls in production are decisions, not generation, and paying generation prices and latency for them is wasteful. A typed, calibrated, parallel decision layer that structurally cannot produce malformed output is a genuinely useful component, and the pricing makes exhaustive checking affordable where sampling was previously the only option.

The evidence is more modest than the launch suggested. Jev sits level with mid-price models on accuracy and behind the frontier. Its headline speed and cost multipliers roughly halve under neutral measurement and can disappear entirely against a self-hosted open model. Its calibration advantage is real out of the box and largely replicable with fifty labelled examples. It is sensitive to option naming in ways that will surprise teams who do not test for it.

None of that makes it a bad tool. It makes it a specific one. The German consultancy that tested it most carefully landed on a formulation worth keeping: Jev **should prepare decisions, not be responsible for them**.

If you are building something where a cheap, fast, structurally valid judgment in front of an expensive model would help, it is worth the afternoon it takes to evaluate properly. Just evaluate it on your own data, against a boring baseline, before you build anything load-bearing on top of it.

