What Is JEV? The Reflex Layer of AI (TypeSafe's System One Model)

When you touch a hot surface, you do not think. You do not reason your way to "this is roughly 70 degrees, the tissue damage risk is high, I should pull my hand back" — your hand is already gone. The thinking comes afterwards.

That layer was missing from AI systems. Ask an LLM "is this comment spam?" and the model thinks, forms sentences, writes a justification — when all you wanted was one bit. Both the cost and the latency come from that unnecessary thinking.

TypeSafe's JEV fills exactly that gap. In this article I go through what JEV is, what it is not, how it works, and what its price-and-limits table actually means in practice.

What is JEV?

JEV is TypeSafe AI's flagship model and the first member of the family the company calls System One. At the time of writing the current version is jev-1.13.0; the aliases jev-latest and jev-preview both point at it.

The way it works is different from the models you are used to. You give JEV a state and one or more typed questions, and you get back not text but a structured answer your code can use directly:

• Choice — "which of these options?" You get one option, a probability for every option, and a confidence score. A single Choice question can define up to 255 options.
• Score — "where does this fall on the scale I described?" You provide ordered levels (at least 2, at most 10) and get a level, a probability distribution, and confidence.
• Noul — "is this statement true?" You get a single probability between 0 and 1.

That is the whole surface area. JEV does not write replies, does not produce code, does not explain its reasoning. It decides.

System One and System Two

The name comes from Kahneman's two-system model of thinking. System 1 is fast, intuitive, automatic; System 2 is slow, effortful, deliberate.

Today's LLMs live on the System 2 side: they plan, they reason step by step, they generate text. That is exactly why they are powerful. But the vast majority of the decisions a piece of software makes are not System 2 work:

• Is this email an invoice, a sponsorship pitch, or spam?
• Does the agent actually need to read this file?
• Can this request be answered with a database lookup, or does it need a human?

These are reflex decisions. An LLM gives you the right answer, but you pay for it unnecessarily. TypeSafe's documentation draws the line clearly: System One models "make fast, structured decisions for software," and they "do not write replies, produce code, or generate explanations of their reasoning."

It helps to read this alongside the idea of a harness: the model is a function, and you build the system around it. JEV is the extreme case of that sentence — without machinery around it, it does nothing at all.

What JEV does not do

The fastest way to understand a tool is to see its edges. JEV:

• Does not generate text. The documentation is explicit: it is not trained to generate. You can force it by chaining choices, but "this will not work well and will be very slow."
• Does not chat. There is no conversation history, no role, no assistant persona. Every call is an independent evaluation.
• Does not call tools. It cannot read a file, hit an API, or run a command. It can decide which tool should be called; your code does the calling.
• Takes no images, audio, or video. Text only.
• Does not count, compare dates, or do arithmetic. Those belong in your code — I cover the details in the limits and harness article.

That list reads like a set of restrictions, but the value is right there: because the answer space is defined up front, the output does not need parsing. No more expecting JSON and getting broken JSON, or saying "answer only yes or no" and receiving three paragraphs.

Your first call

The simplest possible version with the Python SDK:

from typesafe_sdk import Noul, TypeSafeClient

client = TypeSafeClient()  # reads the TYPESAFE_API_KEY environment variable

response = client.system_one(
    state="My parcel has been in transit for 9 days and nobody replies. I want my money back.",
    questions={
        "refund_requested": Noul(instructions="Is the customer requesting a refund?"),
    },
)

print(response.answers["refund_requested"].noul)  # e.g. 0.97

Installation is pip install typesafe-sdk, and the key is read from TYPESAFE_API_KEY. On the HTTP side there is a single endpoint:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer <API_KEY>
Content-Type: application/json

Note what response.answers["refund_requested"].noul is: not a string, a number. A number you can write an if against. That sentence is the whole point of JEV.

I cover the three question types, the rules for writing criteria, and how to read the confidence score in Choice, Score and Noul.

Dozens of questions in a single call

This is the second thing that separates JEV from the models you know: every question in one request is evaluated in parallel. As the documentation puts it, adding questions barely changes the response time and costs only the tokens for the extra questions.

In one of TypeSafe's published cookbooks, a 13-question regulatory briefing asked in a single call comes out roughly 12x cheaper and 10x faster than 13 separate calls — with no change in the answers.

The practical consequence is that it inverts your instincts: asking the questions you only might need is now the rational move. Your code decides later which answers it uses. The documentation calls this speculative fan-out.

Price, context, and limits

	Value
Model	jev-1.13.0 (jev-latest, jev-preview)
Input price	$0.042 per million tokens
Output price	free
Context	64k tokens total per request
State	32k tokens for state plus the longest question
Rate limits	250,000 tokens/second, 1,200 requests/minute
Input type	text only

The striking row is the price. Roughly four cents per million input tokens, and the output side costs nothing. A workload doing thousands of short classifications, which produces a serious invoice when you route it through an LLM, lands in the cents with JEV.

In a public comparison, the same classification test reportedly cost $176 on a large reasoning model and 39 cents on JEV. Do not take those numbers literally — measure on your own workload — but the order of magnitude is the point: this is not a ten-percent saving, it is a two-to-three-digit difference.

One caveat about language: the documentation states that English is the primary training language and that accuracy is best there. It works on other languages, but if you are building something critical, measure the option of writing the questions in English while leaving the state in its original language.

Where it helps and where it does not

It helps with classification, routing, moderation, prioritisation, filtering, re-ranking, and gate decisions of the "is this step necessary?" kind — anywhere the answer comes from a closed set.

It does not help with writing, code generation, summarisation, translation, or explanation. Those are still LLM work. JEV does not replace an LLM; it sits in front of one. It becomes the cheap layer that decides which model runs, with what context, and when.

The right mental model is your own if statements. Where a rule can be written, an if is already enough. The real problem is everywhere a rule cannot be written — "is this comment abusive", "is this email urgent" — and you end up faking rules with keyword lists. JEV is the intelligent if that fits into that gap.

How to start

1. pip install typesafe-sdk and a TYPESAFE_API_KEY environment variable.
2. Take 50–100 real examples from your own product. Do not test with synthetic ones; JEV's weak spots show up precisely in the messy parts of real data.
3. Label them by hand, ask JEV, compare. Do not ship before you measure.
4. If you work with a coding agent, install TypeSafe's official skill:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

This is an agent skill; it teaches the agent the API, the question types, and the architectural patterns, so you can say "find the places in my project where fragile parsing code could be replaced by intelligent judgement."

Closing thought

What makes JEV interesting is not raw intelligence; it is that it completes the missing layer around models. Until now every decision, from the cheapest to the most critical, went through the same expensive thinking machinery. Separating reflex from reasoning changes the cost, the latency, and the architecture all at once.

But it is not a solution that comes out of the box. JEV hands you a cloud of probabilities; you build the machine that turns it into action. So the real work is not in the model — it is in the system you put around it.

Continue with: Choice, Score and Noul, 10 real use cases, and harness, cost and limits.

The technical values in this article come from TypeSafe's official documentation and can change between versions; verify against current docs before shipping.

Frequently Asked Questions

What is JEV?

JEV is the first member of the model family TypeSafe AI calls "System One". Instead of generating text it returns structured decisions: you give it a state and typed questions, and you get an option, a score level, or a yes/no probability. It is not a chat model but a decision layer you embed inside your code.

Is JEV an LLM?

No. An LLM generates text; JEV does not. Its answers come from a closed set you define in advance (an option, a scale level, or a probability between 0 and 1). That is why JEV does not replace an LLM — it goes in front of one, as the cheap layer deciding which model runs and when.

How much does JEV cost?

According to the documentation, input costs $0.042 per million tokens and output is free. For classification and routing workloads that lands two to three orders of magnitude below doing the same work with a chat model.

Does JEV work in languages other than English?

It does, but the documentation notes English is the primary training language and accuracy is best there. A sensible starting point is to write instructions and criteria in English while leaving the evaluated text in its original language — then measure both setups on your own data before deciding.

Can JEV and an LLM be used together?

That is the intended usage. JEV makes the cheap, fast decision (which agent, which tool, which priority, is this step needed), while the LLM does the work that genuinely requires generation. The expensive model then runs only when needed, and with the right context.

What do I need to use JEV?

An API key, the typesafe-sdk package, and the code you write around it. The last one matters most: JEV is a decision engine, not a product. Unless you write the flow that acts on the decision, all you hold is a list of probabilities.