.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
Jev is a hosted model from TypeSafe AI that returns a typed decision with calibrated probabilities instead of generating text - yeah.
You send it a piece of state (a support ticket, a signup record, a log line, a chunk of a document) and a question with a fixed set of possible answers. It sends back one of those answers, a probability for each option and a confidence score for the whole decision, in 70 to 500 milliseconds, for $0.042 per million input tokens. No prose, no chain of thought, no JSON that comes back malformed. If your agent or workflow calls a frontier model a thousand times a day to decide which queue a ticket goes to, that's the call Jev is built to replace.
And yes, they made it play the videogame Doom just as a fun demo:
Source: Typesafe AI
TypeSafe calls this a System One model, after the fast, intuitive mode in Kahneman's Thinking, Fast and Slow. Jev is API only: a waitlist, a playground on console.typesafe.ai, Python and JavaScript SDKs and one HTTP endpoint, POST /v1/systemone. There are no weights to download and nothing to host.
What a System One model returns
Three question types make up the whole API surface.
Choice picks one option from a list you define (up to 255 of them) and returns the pick, a probability for every option and a confidence number.
Score rates the input against ordered levels you describe, say "spam", "borderline", "legitimate", and returns the level, the distribution and confidence.
Noul, their name for a yes/no question, returns the probability that the answer is yes. Several questions can go in one request and they're evaluated in parallel, which is where much of the speed comes from.
The distinction TypeSafe leans on is probability vs confidence. Probability tells you which answer the model favours while confidence tells you if the model thinks it should be trusted on this input at all. A ticket that's 85% "technical" at 0.82 confidence gets routed; the same split at 0.31 confidence goes to a human.
The training method behind this is what they call RLCD, Reinforcement Learning for Calibrated Decisions, and calibration is the claim: that a 0.7 means 70% over a large enough sample. It's a claim about honesty, and an honest model can still be wrong.
Source: Typesafe AI
True, and less impressive than it sounds, since constrained decoding on any open model gives you the same guarantee. The part you can't get elsewhere is the calibration.
Who is behind TypeSafe AI
TypeSafe AI is a San Francisco company with three co-founders that spent two years in stealth and announced Jev on September 15, 2026 alongside a $40 million seed round led by DCVC.
The CEO, Diogo Almeida, worked at OpenAI on instruction following, which in his own words in the launch post "ended up as the research behind ChatGPT". The post sat on the Hacker News front page for a day with over 1,300 points and close to 400 comments, most of them arguing about the benchmark claims below :)
What Jev costs and how fast it is
Input tokens cost $0.042 per million and output tokens are free, which makes sense once you notice the output is a few numbers. Latency is quoted at 70 to 500 milliseconds end to end. Basically those 2 numbers are the product.
The headline multipliers need more care. The launch post claims 193.6 times faster and 444.6 times cheaper than frontier LLMs on TypeSafe's own workflow evaluations, and the authors add their own caveat in the same sentence:
This is where the claims of 193.6x faster, 444.6x cheaper on our home page comes from, and we expect that these are on the higher end of real world gains.
The HN thread spent a good part of its 390 comments on the fact that the comparison pits a classifier-shaped call against LLMs doing full chain-of-thought. Fair criticism, and a bit beside the point, because the LLM with chain-of-thought is what most teams run today for exactly these decisions.
Source: Typesafe AI
So Jev matches a mid-tier LLM and trails the top ones, at roughly 75 times lower cost than the model it ties with. The security incidents workflow is the row for anyone running servers: Jev 61.7% at $0.0001 per case and 0.3 seconds, Sol 62.5% at $0.0295 and 8.5 seconds. Same call, 300 times cheaper.
The Doom demo in the launch post is the same idea made visible: game state in, action out, 0.114 seconds per decision against 8.566 seconds for GPT-5.6 Terra on the same frames. It's a stunt, and it's the right stunt, because it shows what a model gets used for once a decision costs nothing.
What Jev doesn't do
It doesn't write. Yes, that's a bit sad. If the answer to your question is a sentence, Jev is the wrong tool and TypeSafe says so. It doesn't explain a decision either, so when a classification is wrong you get a probability and no reasoning to debug.
The sharper limit is the one Anthony Maio's write-up lands on: Jev constrains the shape of the output, and the judgment inside it is as fallible as any model's. If the right answer isn't among the options you declared, the probability mass still has to land somewhere, and it lands on the least wrong option with a confidence score that may or may not warn you. Calibration was measured on TypeSafe's distribution, and your signup data or your abuse reports are not that distribution.
Then, there are the practical constraints.... Closed weights, with no statement about ever opening them. No published data residency, which for a European company sending customer records through it is a question to settle before production. Early access behind a waitlist.
Oh, and one thing from reading the docs: the API takes a jev-latest alias, and the pricing line in the docs still referred to a July build, jev-1.12, at a different price than the launch post. The model has been iterating behind closed doors for a while; the docs are catching up.
Jev use cases for agents, guardrails and batch jobs
TypeSafe's own list is four items: smart if-statements inside AI workflows, map-reduce over large datasets, real-time applications and verifying or guardrailing LLM output. The evals site adds the concrete versions it tested on, security incidents, agent trace observability, invoice processing and customer service. Between the two lists the shape of a good Jev task is clear enough: a fixed set of answers, lots of calls, and a downstream that can act on a probability.
The gate in front of an agent is the lowest-risk place to start. Still calling a frontier model on every incoming message? A Noul question ("does this message need the expensive model") in front of an OpenClaw agent or an n8n workflow is the smart if-statement TypeSafe's post describes. Most of what an agent decides per message is small: is this spam, which queue, does it need a reply at all. Those calls don't need a frontier model, and at 0.4 seconds against 10 the agent gets faster as a side effect.
Guardrails are the second. An LLM writes the reply, Jev checks it: "does this response contain a refund promise", "is this SQL statement destructive", "does this answer contradict the retrieved document", each a yes/no with a probability, each cheap enough to run on every generation. TypeSafe frames this as the pairing the two model types are built for, and it's the case where the calibration matters most, because a guardrail that fires at 0.6 confidence is a different policy from one that fires at 0.95.
Third, batch classification over data that was too big to run through an LLM. Ten million support tickets tagged by root cause, a year of invoices sorted by vendor type, every log line from an incident scored for relevance. At $0.042 per million input tokens the whole archive costs less than a coffee, and the parallel evaluation is what makes the wall-clock time survivable. The invoice-processing eval is this pattern with a rubric: Sol scored 79.1% there and Jev trailed, so on documents with real structure the cheap model gives up some accuracy for the price.
Real-time is the fourth and the one the Doom demo exists for: a decision every frame, or every event, in a loop where 8 seconds is an eternity. Moderation on a live chat, routing on a message bus, the next action for a bot in a game world.
Where Jev doesn't belong is anywhere the wrong answer is expensive and there's no human downstream. Auto-banning an account on an abuse classification, for instance. A 0.94 confidence is still six wrong bans in a hundred, and the person on the wrong end doesn't care that the model was calibrated.
Can you self-host Jev, and what runs on a VPS instead
No. Jev is a hosted API and TypeSafe has said nothing about weights. What you can put on a server is the same pattern built from open parts, and the two projects that hit Hacker News the morning after the launch are exactly that.
The first is GLiClass, posted under the title "open-source JEV". It's a zero-shot text classifier from Knowledgator, Apache 2.0, that takes a text and a list of labels and returns a score per label in a single forward pass, about ten times faster than the cross-encoder approach it replaces. The models are small encoders (the tags are gliclass-small, gliclass-base and gliclass-edge), pip install gliclass gets you running, and they're light enough for a CPU. A Choice-style classifier for ticket routing or log triage doesn't need a GPU; it runs on a 4 GB VPS next to the app it serves. What GLiClass doesn't give you is calibration in the TypeSafe sense. The scores are scores, and a threshold you tune on your own data is your confidence measure.
The 2nd is a thread replicating the Jev pattern with Qwen 2.5, which is the other route: take an open instruct model, constrain its output to your option list and read the probabilities off the logits (the model's raw per-token scores) without letting it generate a word. vLLM and llama.cpp both expose them. A 7B model at 4-bit fits on the 16 GB RTX PRO 2000 Blackwell at the bottom of our GPU VPS lineup, and if you already run Ollama for something else the model is probably on the box already.
So you get the typed output and the per-option probabilities but don't get RLCD-trained calibration, and the latency is whatever your card and prompt length make it, which you'd measure before trusting it in a request path.
| Jev | GLiClass | Qwen 2.5 logprobs | |
|---|---|---|---|
| Where it runs | TypeSafe's API | Your VPS, CPU is enough | Your GPU VPS |
| Calibrated confidence | Yes, RLCD-trained | No, threshold you tune | No, raw probabilities |
| Cost per decision | $0.042 per million input tokens | Server only | Server only |
| Latency | 70 to 500 ms quoted | Milliseconds on CPU for short text | Depends on card and prompt |
| Weights | Closed | Apache 2.0 | Apache 2.0 (Qwen 2.5) |
| Free-form questions | Choice, Score, Noul with any option list | Labels only | Any prompt |
For a team that owns its servers, GLiClass covers anything with a fixed label set today and the Qwen route covers questions that need real reading comprehension. Jev is the one to test the day the waitlist clears, mostly to see if the calibration claim survives contact with real signup data. We haven't got access yet, so that test is still a promise.
