Last updated: September 30, 2026. Jev is in early access. We review this page monthly.
Jev is a decision model from TypeSafe AI that answers questions with a choice, a score, or a yes/no probability, instead of writing text. You give it the state of something (a page, a log, a bug report) and a question with defined answers. It gives you back one of those answers and how sure it is, usually in well under a second, according to TypeSafe's launch post.
If you've used an LLM in a test framework, you've probably written code to parse its reply into something your test can branch on. Jev skips that step. This guide explains how it works, in testing terms.
For benefits, risks, and where Jev fits in a test stack, read Jev for QA: benefits, risks and where it fits in test automation.
THE SHORT ANSWER
Jev comes from TypeSafe AI, founded in 2024 by Diogo Almeida, Erik Gafni, and Sasha Sheng, according to Wikipedia's entry on Jev. The company launched Jev in early access on September 15, 2026, alongside a $40 million seed round led by DCVC [2][3]. Almeida previously worked at OpenAI on RLHF and InstructGPT, as The New Stack reports.
His framing of the problem is blunt: sequential LLM generation is "great for natural conversation, but totally useless for computers" [3]. Software needs a decision it can act on, not a paragraph.
TypeSafe calls Jev a "System One" model, borrowing from Daniel Kahneman's split between fast, instinctive thinking (System 1) and slow, deliberate reasoning (System 2).
In a test run, most AI decisions are System 1 decisions. Which button is "Continue"? Did the page load the next step? Is this error an infrastructure problem? A good tester answers those in a glance. Jev is built for that kind of call. Planning a test strategy or explaining a failure is System 2 work, and that's still a job for an LLM or a person. Alex Martins makes the case for why that split matters in what Jev means for software testing.
| Jev | Large language model | |
|---|---|---|
| Output | One answer from options you define, with probabilities | Free text |
| Best for | Bounded decisions: choose, classify, verify | Writing, reasoning, explaining |
| Explains its answer | No | Yes |
| Input | Text or JSON only, up to 64k tokens per request | Varies by model; many also read images |
| Pricing | $0.042 per million input tokens, output not billed [5] | Varies by model and provider |
Every request has two parts:
There are three question types, which TypeSafe calls primitives.
You define the options, Jev picks one and returns a probability for each option.
Testing example: "Which of these actions advances checkout?" with options like click_continue, click_back, enter_zip_code. This is how Arbon's Playwright demo and Callstack's mobile demo let Jev drive the next step.
A single question can have up to 255 options [1].
You describe ordered levels from low to high. Jev returns a probability for each level, plus a score that blends them. TypeSafe's own documentation example is a bug severity scale:
For a Safari-only crash on a settings page, Jev split its answer between the second and third levels (57% and 43%) with low confidence (0.35) [8]. That's a useful signal in itself: this one needs a human.
A Noul asks a yes/no question and returns a single number between 0 and 1, the probability that the answer is yes.
Testing example: "Does this error message tell the user how to fix the problem?" You decide what threshold counts as a pass.
Choice and Score answers include the probability of every option and a confidence value from 0 to 1, which summarizes how concentrated those probabilities are. A Noul's single number already describes both outcomes, so it has no separate confidence value [9].
TypeSafe's guidance is to set thresholds by consequence, not one number for everything. Act automatically only on high confidence for risky actions (above 0.9 in its example), and route low confidence (below 0.5) to a human or a fallback.
TypeSafe ships Python and JavaScript SDKs, and a REST API (POST /v1/systemone) for everything else [5]. Here is a Choice question on a failed test, adapted from the SDK documentation:
Two habits worth building from day one. Pin the model version, because the jev-latest alias moves when a new release ships and "the answers behind it can change without a change on your side" [5]. And send only the fields the question needs, because irrelevant context lowers accuracy.
An LLM writes its answer one token at a time. Jev generates all of its outputs in a single query. According to TypeSafe, that is where the speed comes from. The figures below come from TypeSafe's model documentation, except where noted.
TypeSafe also claims Jev is 40 to 200 times faster than LLMs on System One tasks. Treat that as a vendor figure. TypeSafe itself says of its headline figures: "we expect that these are on the higher end of real world gains."
This is the part that matters most for testers.
And one point that's easy to miss: "can't hallucinate" means Jev can't return an answer outside the options you defined [1]. It can still pick the wrong option. As one reviewer put it, the schema "does nothing to stop the model from picking the wrong option."
Not natively, and it doesn't need to. Jev doesn't replace anything in your Studio project. Your test cases, assertions, and Katalon Runtime Engine (KRE) runs stay exactly as they are. Jev is an optional extra for judgment calls your assertions can't make, called from a pipeline step or a custom keyword, not a new test engine. Writing and explaining tests stays with the Katalon AI Assistant (Kai), since Jev doesn't generate text. And if you want failed tests categorized today, AI failure analysis in Katalon Studio Enterprise already tags each failure with a likely cause.
Too early to say with confidence. TypeSafe's benchmarks are its own, and there is no independent benchmark of Jev's decision quality yet. The first independent comparison, from Lightfield, found Jev scored 91%, 80%, and 95% on three 100-item text benchmarks without reasoning, matching or beating the Claude models tested. Those are general text tasks, not test failures or UI decisions.
The honest answer for a QA team: measure it on your own labeled data before you trust it. Take a few dozen past test failures your team has already categorized, run them through Jev with a pinned model version, and compare its answers with yours.
Jev is in early access. You create an account and an API key in the TypeSafe console. Enterprise customers can ask for zero data retention, and TypeSafe says it doesn't train on customer requests.