What is TypeSafe Jev, and how is it different from an LLM?

TypeSafe Jev is a decision model. You hand it some data and a question, and it returns a typed answer: one label from a list you wrote, a level on a scale you defined, or a probability between 0 and 1. It writes nothing. TypeSafe launched it on 15 September 2026, prices it at $0.042 per million input tokens with output free, and states 70 to 500 ms per call. An LLM writes. Jev decides. Most software needs both, in that order.

Your inbox doesn't want an essay

A support inbox needs three things from every message. Is this a refund request. How angry is this person. Should a human see it before the bot replies. Three decisions, a thousand times a day, and none of them need a paragraph.

Most teams wire that to a chat model, because a chat model is what they already pay for. It takes a few seconds, explains its reasoning at length, and you throw the reasoning away to grab the one word you wanted. You paid for the reasoning anyway.

TypeSafe shipped Jev on 15 September 2026 into exactly that gap, alongside a $40 million raise. The pitch is narrow and worth taking seriously: stop asking a writer to do a judge's job.

What is TypeSafe Jev?

Jev is what TypeSafe calls a System One model. The name borrows the psychology split. System Two deliberates, checks itself and shows its work. System One answers before you have finished asking.

TypeSafe publishes a useful test for whether a task fits. Put everything a knowledgeable person needs in front of them, ask one specific question, and watch what happens. If they can answer immediately, without doing research or building a plan, the task is Jev-shaped. If they need to go and look something up, it isn't.

There are three shapes of question and no fourth.

Noul returns the probability that a yes/no proposition is true, as a single number between 0 and 1. "Does this message contain a prompt injection?" comes back as 0.96. There's no separate confidence field, because the probability already carries the uncertainty.

Choice picks one winner from up to 255 labelled options and hands back the winner, a probability for every option, and a confidence value. TypeSafe recommends you always include an option that means "none of these", so the model has somewhere honest to go.

Score places the input on an ordered scale of 2 to 10 levels. It returns a continuous position, which can land between two levels, along with the distribution and a confidence. Define the levels as concrete situations rather than adjectives: "the customer has asked for a manager twice" beats "quite annoyed".

Questions inside one request are judged in parallel and independently. The answer to question A never becomes context for question B. Adding a tenth question costs you the tokens it takes to write it and almost no extra time, which is why TypeSafe suggests asking everything you might plausibly want to know in a single pass.

How Jev differs from an LLM

An LLM is autoregressive. It picks a token, reads back what it has written, picks the next one. That loop is where the seconds go, and it's also where a schema breaks: a model that writes JSON can write invalid JSON, and then your parser is the thing that fails at 3am.

Jev produces its answer as a typed value straight out. No loop, no parser, and no way to return a label that was absent from your list. TypeSafe calls this zero schema errors, and the claim holds in a narrow and honest sense. The shape is guaranteed. The judgement inside the shape is not.

The benefits, and the numbers underneath them

TypeSafe claims 20 to 200 times faster and 40 to 400 times cheaper than frontier models on decision-shaped work. Those are vendor figures from vendor benchmarks, and at least one outlet has pointed out that the headline 445x cost claim is still self-tested. Treat them as a starting hypothesis.

Two independent evals landed within three days of launch, and they're more useful than the marketing.

The first, published on 17 September 2026, ran Jev 1.13.0 against GPT-5.6 Terra on three classification tasks of 300 samples each. Intent recognition on Banking77: Jev 0.78 accuracy, Terra 0.85. Sentiment on SST-5: 0.57 against 0.59. Polarity on IMDB: 0.97 against 0.97. Median latency came in at 0.20 s for Jev and 1.04 s for Terra, roughly five times faster rather than two hundred. Cost per thousand calls ran $0.04 against $2.02 on intent, $0.01 against $0.64 on sentiment, $0.02 against $0.85 on polarity. The same report notes that Jev counts about twice the input tokens for equivalent text, which eats into the per-token advantage.

The second, pre-registered and published on 18 September 2026, added two baselines that most vendor comparisons quietly omit. On Banking77 a frozen bge-small encoder with logistic regression on top scored 0.933 at a 0.01 s median, beating GPT-5.6 Terra at 0.875 and Jev at 0.832. Its conclusion is the line every buyer should read twice: where labelled data exists, a 9 ms supervised encoder wins. On CLINC150, Jev reached 0.870 against Terra at 0.915 and a nano-class LLM at 0.795. Both verdicts were recorded as ambiguous.

The other benefit is calibration. TypeSafe trains Jev with what it calls RLCD, Reinforcement Learning for Calibrated Decisions, so that a 0.9 means something closer to "right nine times out of ten" than a number a chat model invented to sound confident. That's what makes threshold logic possible at all, and it's the part of the product that changes how you design a workflow.

The limitations, which matter more than the benchmarks

TypeSafe publishes nine documented weaknesses for Jev 1.13, which is more candour than most model cards manage. They're worth listing in full, because each one has a workflow attached to it.

• It reads literally. Jev does no reading between lines. A compound question returns noise around 0.5, so one judgement per question, worded exactly.
• It's bad at maths and counting. Arithmetic belongs in code, every time.
• It's bad at ordering dates. Same answer: code.
• It's weak at multi-hop indirection. If the answer requires following a reference to find another reference, it's a System Two job.
• Irrelevant context degrades it. Send the message and the policy, rather than the whole thread and the account history.
• It doesn't treat adversarial input as hostile by default. You have to ask it to.
• It breaks under contradictory instructions. Two rules that disagree produce a coin flip.
• Complementary probabilities need not sum to 1.0. Do the algebra on that assumption at your peril.
• It generates no text. Not a sentence, not a summary, not a subject line.

Add the context ceiling: 64,000 tokens per request, of which roughly 32,000 is the working budget for the state plus your longest question. Jev has no search, no tools and no memory of your last call. Whatever you put in the state is the entire world it knows.

The sharpest limitation is the one the evals surfaced rather than the docs. In a third-party test reported in mid-September 2026, classifying 2,000 phishing and legitimate emails with a single broad judgement question put Jev at 62.6%, well behind Claude Haiku 4.5 at 81.3%. The same underlying task, decomposed into five atomic questions with the combining weights fitted on 1,000 labelled examples and scored on the other 1,000, reached 95.0%.

Read that carefully, because the easy reading is wrong. The 62.6% did not become 95.0% by magic. It became 95.0% because somebody did the work of breaking one fuzzy question into five sharp ones and put the weighting logic in code, where it belongs. Jev rewards that work more than a chat model does, and punishes its absence more too.

And calibration isn't correctness. A high-confidence answer means the model is sure of its belief. It says nothing about whether the belief is true. You still need to sample outputs, measure error rates against real labels, and watch them over time.

How it changes the way we work with LLMs

The interesting shift is architectural. For two years the default pattern has been one big model doing everything: reading, deciding, writing, calling tools. That pattern's slow where it needs to be fast and expensive where it needs to be cheap, and it has left a lot of teams with the model fatigue that comes from swapping one frontier model for another and getting the same bill.

Jev splits the job. Judgement goes in front. Writing goes behind. Your code owns what happens in between.

Three patterns come out of that split, and all three are already in production somewhere.

Confidence-gated routing. Above your high threshold, the software acts and nothing writes a word. In the middle, a human looks, at a queue that arrives sorted and ranked. Below your low threshold, the request escalates to a reasoning model. You choose the thresholds, which means the business rule lives in a file your team can read, review and change, rather than inside a prompt.

The economics are unsubtle. If Jev handles the easy 80% at $0.04 per thousand and only the hard 20% reaches a model at $2.02 per thousand, the blended cost falls by roughly three quarters. Measure your own split before you believe that number for your own traffic.

Guardrails on both ends. A Noul on the way in, asking whether the incoming message looks like a prompt injection. A second Noul on the way out, asking whether the draft reply promises a refund, a discount or a policy that your actual policy doesn't contain. Both run in under half a second, which is the only reason anyone will accept them in the path of a live conversation. This is the cheapest useful thing most teams could ship this quarter.

Retrieval that filters before it spends. Score each retrieved passage for relevance, drop everything below the line, and send a short clean context to the expensive model instead of twenty passages and a prayer. Less context rot, smaller bills, better answers. If you're building agentic workflows, this is where the quality actually moves.

Where this shows up at work

Support triage. Category, urgency, frustration level and an escalation flag, judged together in one call in under half a second. The queue that reaches your team is already sorted. A mid-sized support desk running 2,000 tickets a month spends pennies a month on the classification.

Lead qualification. Score an inbound form on budget fit, timeline, authority and need as four separate questions, combine them with weights you control, and route the top band to a human while the rest goes to nurture. The weights being yours is the whole point: you can explain the score to a sales director without opening a model.

Vendor and compliance screening. Run a policy checklist as a fan-out of yes/no questions against each supplier response. Flag the ones that trip a rule. A human reads the flags rather than the pile.

Checkout risk. Judge the signals on a transaction, approve the clean ones, hold the suspicious ones for review. The latency budget at checkout is the constraint, and this is a shape that fits inside it.

Content and listing moderation. Screen new submissions for missing attributes and policy breaches before they go live.

If you don't write code, here's what actually changes

You'll never open Jev and type into it. There's no chat window, no prompt box, no place to paste a document. It's a part that engineers install inside software, the way nobody at your company has ever logged into a database directly.

What changes for you shows up in the tools you already use.

The bot stops inventing policy, because something checks each draft against the real policy before it sends. Your queue arrives sorted by how angry people are instead of when they wrote in. The lead that was going to sit for a day reaches a salesperson in seconds. The AI line on next year's budget stops climbing in step with usage, because the cheap judge handles the volume and the expensive writer handles the exceptions.

If a vendor is pitching you this, three questions cut through most of it. What happens when the model is unsure, and who sees it. Who wrote the thresholds, and can we change them without a release. What are we measuring, against what baseline, starting when. A vendor who answers those three well is worth a pilot. A vendor who answers with a latency chart is selling you a benchmark.

Where We Call Shotgun comes in

A faster model has never once changed how a team works. We've watched companies buy the licence, run the launch webinar, and find six months later that the same three people use it and the workflow underneath is exactly where it was. The tool was never the problem. Nobody taught them to drive.

Jev makes that gap wider, because it's invisible. There's no interface to adopt, which means the only way it creates value is if somebody has mapped a workflow, found the decisions inside it, and rebuilt the path around them. That's work, and it's the work we do.

What an engagement looks like on this specific topic. We take one workflow your team complains about and time it as it runs today: how long a ticket waits, how many hands touch it, where it stalls. That's the baseline, and without it every number that comes later is a story. Then we pull out the decisions hiding inside it, the ones a person makes in five seconds and calls obvious, and we sort them. Some are code. Some are Jev-shaped. Some need a model that can write. Most need a person, and the point of the exercise is to give that person a shorter queue and a clearer call.

Then we build one fat pilot on one workflow, with thresholds your team sets and a review loop your team runs, and we measure the cycle time again. If it moved, we go wider. If it didn't, we say so and you've spent a sprint rather than a year. We're tool-agnostic across ChatGPT Enterprise, Microsoft Copilot, Google Gemini and Claude, and the same posture applies to a decision model: we care whether the workflow got faster, and very little about whose logo is on it. For teams weighing what to buy first, our guide to which AI plan fits which team covers the seat-level decision.