What is Jev? A plain-English guide for testers

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.

Who makes Jev?

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.

What does "System One" mean?

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.

How is Jev different from an LLM?

How does Jev work?

Every request has two parts:

• State: what Jev should look at. A string, a JSON object, or an array of text. For example, a structured snapshot of a page, a test failure message, or a bug report.
• Questions: one or more typed questions about that state. Jev evaluates them all in parallel against the same state ^[4][5].

There are three question types, which TypeSafe calls primitives.

Choice: pick one from a list

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].

Score: place it on a scale

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:

1. Cosmetic; no impact to functionality
2. Broken or degraded feature, but workaround exists
3. Blocking issue; no workaround exists

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.

Noul: yes or no

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.

What comes back

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.

What does a Jev API call look like?

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:

# pip install typesafe-sdk
# export TYPESAFE_API_KEY=...
from typesafe_sdk import Choice, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        model="jev-1.13.0",  # pin a version, don't use jev-latest in tests
        state={
            "test": "checkout_applies_coupon",
            "error": "TimeoutError: waiting for selector '#coupon-apply' exceeded 30000ms",
            "passed_on_retry": False,
        },
        questions={
            "failure_type": Choice(
                instructions="What most likely caused this test failure?",
                criteria={
                    "regression": None,
                    "flaky": None,
                    "environment": None,
                    "test_data": None,
                },
            ),
        },
    )

print(response.answers["failure_type"].choice)

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.

Why is Jev so fast and cheap?

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.

• Latency: TypeSafe reports 70 to 500 ms end to end. Arbon measured a 131 ms median round trip in a Playwright loop.
• Price: $0.042 per million input tokens. Output is not billed.
• Rate limits: 1,200 requests per minute and 250,000 tokens per second.

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."

What can't Jev do?

This is the part that matters most for testers.

• It doesn't write text. No test generation, no failure explanations, no run summaries ^[1][12].
• It doesn't read images. Input is text only. For UI testing, that means working from the DOM or accessibility tree, not screenshots ^[5][7].
• It doesn't show its reasoning. You get an answer and probabilities, not the why ^[13].
• It has a context limit. 64k tokens per request, with 32k for the state plus the longest single question ^[5]. Full-page DOM dumps will need trimming.
• It has known blind spots. TypeSafe lists math and counting, date comparison, hex and RGB values, double negatives, and injected instructions among Jev 1.13's weak spots. Several of those (totals, dates, colors) are everyday test checks. Keep them in code.
• It works best in English. Other languages are supported but less accurate ^[5].

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."

Does Jev work with Katalon Studio?

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.

Is Jev accurate?

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.

How do you get access to Jev?

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.

Jev glossary: key terms

• State: the input Jev evaluates. Text or JSON.
• Primitive: a question type. Choice, Score, or Noul.
• Confidence: a 0 to 1 summary of how concentrated the answer's probabilities are. Returned for Choice and Score.
• Calibration: whether a model's probabilities match how often it's right. A calibrated 0.8 should be right about 80% of the time across many answers.
• RLCD: Reinforcement Learning for Calibrated Decisions, TypeSafe's training method for Jev ^[1].
• Model alias: a name like jev-latest that points to whichever version is current. Pin a version in tests.

Sources

1. TypeSafe AI, Introducing System One Models & Jev, September 15, 2026
2. Wikipedia, Jev (AI model)
3. Adrian Bridgwater, The New Stack, TypeSafe launched Jev because sequential LLMs are "totally useless for computers", September 21, 2026
4. TypeSafe docs, Primitives
5. TypeSafe docs, Models
6. Jason Arbon, I Put Jev in a Playwright Browser Testing Loop. It's fast, but…, September 2026
7. Mike Grabowski, Callstack, Exploring Jev for AI-Driven QA with agent-device, September 17, 2026
8. TypeSafe docs, Score
9. TypeSafe docs, Noul
10. TypeSafe docs, Confidence
11. TypeSafe docs, Python SDK
12. TypeSafe docs, Jev 1.13 jaggedness
13. Luis Chavez-Mattos, MindStudio, 12 Jev Use Cases Tested: Where This Decision-Only AI Actually Fits, September 20, 2026
14. Anthony Maio, Jev: The Language Model That Won't Talk, September 16, 2026
15. Layer3 Labs, Jev Benchmarks: How Accurate Is TypeSafe AI's Model?, September 22, 2026
16. Ves Stoyanov, Lightfield, Testing TypeSafe Jev on Text Understanding, September 20, 2026
17. Katalon Docs, AI failure analysis