JEV AI: The Fast Judgment Model for Agents and RAG
JEV AI is a judgment model, not a full-fledged chat LLM. It doesn’t write text. Instead, it returns typed decisions that software can use directly.
TypeSafe AI built it as the first model in a new class called System One models. In fact, Jev is also the flagship of that class.
Image source: TypeSafe AI — Introducing System One Models & Jev
The Problem: LLMs Are Overkill for Small Judgments
Most AI workflows depend on small decisions. For example, is this document relevant? Which category fits this ticket? Should this request escalate?
Today, teams answer those questions with a full LLM call. The model generates text, and then code parses and validates it.
That approach has real costs. First, it’s slow, because tokens arrive one at a time. TypeSafe cites end-to-end times of 3 to 329 seconds for frontier models.
Second, it’s expensive. In addition, output tokens typically cost about five times more than input tokens.
Finally, text can fail. A model may return a malformed or hallucinated value. Therefore, the code needs defensive parsing.
In RAG and agentic pipelines, these judgments repeat dozens of times per task. Consequently, small inefficiencies compound quickly.
What Is a System One Model?
The name comes from Daniel Kahneman’s book Thinking, Fast and Slow. In it, System 1 is fast and intuitive, while System 2 is slow and deliberate.
Accordingly, System One models focus on the fast kind of thinking. They make quick, structured decisions that software can consume directly.
Jev evaluates typed questions against a piece of state. It then returns typed answers with probabilities. As a result, there’s no text generation and no parsing step.
In short, TypeSafe likens Jev to a function call with frontier-level intelligence behind it.
How Jev Works
Most LLMs sample sequentially, generating one token at a time. Jev, in contrast, produces all of its outputs in a single parallel pass.
TypeSafe also trained it with Reinforcement Learning for Calibrated Decisions (RLCD). Rather than rewarding text that humans prefer, RLCD rewards honest probabilities.
As a result, Jev reports confidence with every answer. Moreover, higher confidence should mean higher accuracy, and similar inputs should return similar answers.
Type safety is built in, too. Possible outputs are defined in advance. Therefore, the model can’t return a value outside the schema.
Three Data Primitives
Jev exposes three question types, which TypeSafe calls AI primitives. Each one asks a different kind of question.
| Primitive | What it asks | What it returns |
|---|---|---|
| Choice | Which option from a list fits best? | The choice, probabilities, and confidence |
| Score | How does the state rate on a rubric? | A score, probabilities, and confidence |
| Noul | Is this statement true? | A value between 0 and 1 |
You can mix any of these types in a single API call. Jev evaluates every question in parallel, in isolation, against the same state.
Consequently, adding more questions barely changes response time. It also avoids the context rot that long prompts can cause.
TypeSafe recommends keeping each question atomic. If a judgment needs extended reasoning, split it into smaller questions. Then combine the results with ordinary code.
Making RAG and Agentic Pipelines Faster with JEV AI
A typical RAG pipeline retrieves the top-k candidates, then hands them to an LLM. The judging step often becomes a bottleneck.
Jev can take over that step. For example, a team could run one Score question per retrieved chunk. A Noul question could also check whether a passage actually answers the query.
Because Jev runs these questions in parallel, filtering many candidates takes about as long as filtering a few. Moreover, only the relevant chunks move on.
This keeps the expensive LLM focused on a smaller, cleaner context. As a result, teams can cut costs and latency, and the final answer may improve too.
Agents benefit in similar ways. A Choice question can route a user’s intent to the right tool. Meanwhile, confidence values let code act only when Jev is sure, and escalate otherwise.
TypeSafe’s docs describe related patterns, such as Intent Routing and Speculative Fan-Out. RAG pruning is one application, so validate it on your own data.
Speed and Cost
Jev’s pricing is simple. Input costs $0.042 per million tokens, which works out to $42 per billion. Output tokens are free.
| Existing LLMs | Jev | |
|---|---|---|
| Input cost | $0.20 to $10 per million tokens | $0.042 per million tokens |
| Output cost | About 5x the input price | Free |
| Response time | 3 to 329 seconds | 70 to 500 milliseconds |
| Output type | Free-form text | Typed structured values |
| Sampling | Sequential | Parallel |
TypeSafe says this makes Jev 40x to 200x faster on System One-shaped queries. In its own workflow evals, the headline gains reach 193.6x faster and 444.6x cheaper.
However, TypeSafe itself expects those top numbers to sit at the higher end of real-world gains. Treat them as an upper bound.
Image source: TypeSafe AI — Introducing System One Models & Jev
What to Keep in Mind while using JEV AI
Jev is a specialist, so a few trade-offs apply:
- No text generation. Jev can’t chat, write, or explain. Pair it with an LLM when you need language output.
- Early access. TypeSafe is onboarding developers from a waitlist.
- Company-run benchmarks. TypeSafe ran its evals from West Coast laptops. It also used other frontier models as reference answers, and it admits this may introduce bias.
- Pricing sustainability. TypeSafe says it can’t yet prove its prices aren’t subsidized. It expects prices to fall over time.
- Choice limits. Jev supports up to 255 options per choice question. Larger sets use a two-stage score-then-choose approach, which adds latency.
Broader Implications of JEV AI
Jev points toward a few larger shifts in how teams build with AI:
- Smart if-statements. Structured outputs slot into normal code as fuzzy decision rules for classifying, routing, and scoring.
- Real-time AI. Responses in 70 to 500 milliseconds make AI usable where user experience matters.
- Verification at scale. Teams can score, judge, and guardrail LLM outputs cheaply, instead of paying for another LLM call.
Conclusion
JEV AI makes a focused bet. Many automation tasks need fast, calibrated judgments, not paragraphs of generated text.
Jev returns typed answers in parallel at a fraction of LLM prices, making RAG and agent pipelines leaner. Ultimately, test its gains on your own workloads.
Ready to bring intelligent AI capabilities closer to your users? Your journey starts at Webkul.