What is Jev? TypeSafe's decision-making AI model and real benchmarks

Jev is an AI model from TypeSafe AI, built to make decisions. With 70–500ms latency and very low input costs, Jev is drawing attention for tasks like classification, routing, and AI guardrails.

But is Jev really faster and more effective than LLMs across the board? What do TypeSafe's own benchmarks show, and what do independent benchmarks say?

This article explains what Jev is, how it differs from LLMs, how it performs on benchmarks, and when it makes sense to use Jev in an enterprise AI system.

What is the Jev model?

Jev is TypeSafe AI's first model, designed specifically for structured decision-making. Instead of producing a block of text like GPT or Claude, Jev takes input data and returns a choice, a score, or a probability.

TypeSafe AI was founded by Diogo Almeida, who previously worked at OpenAI and contributed to the development of ChatGPT and RLHF. On September 15, 2026, TypeSafe launched Jev alongside a $40 million seed round led by DCVC.

Jev's biggest difference lies in its output. The model is not designed to:

• Write emails or marketing content
• Summarize documents
• Write code or translate text
• Answer open-ended questions

Instead, Jev focuses on decisions such as:

• Which team should this ticket go to?
• Is this email likely phishing?
• Is this request urgent?
• Does this content violate policy?
• Is this user showing a high level of dissatisfaction?

Every decision comes with a probability that shows how confident the model is.

In return, Jev is very fast and very cheap:

• 70–500ms latency, compared with 3–329 seconds for frontier LLMs on comparable tasks (according to TypeSafe)
• $0.042 per million input tokens, with free output
• 0% output formatting errors, since answers always fall within predefined options

Developers picked it up quickly. Within the first 24 hours, 13% of paying teams on Vercel AI Gateway had used Jev, the fastest adoption in the gateway's history. Jev is also available on Cloudflare Workers AI and integrates with LangChain and Pydantic AI.

How is Jev different from traditional LLMs?

TypeSafe calls Jev a "System One model". The name comes from psychologist Daniel Kahneman's System 1 and System 2 framework:

• System 1: fast, intuitive thinking. For example, seeing someone's face and instantly knowing whether they're happy or angry.
• System 2: slow, deliberate thinking. For example, solving a multi-step math problem.

LLMs like GPT or Claude typically generate output token by token. Jev takes a different approach: instead of producing text, the model makes multiple decisions in a single pass. Jev is trained with RLCD (Reinforcement Learning for Calibrated Decisions) to improve how well its probabilities are calibrated.

In short: Jev doesn't replace LLMs. It's a "fast decision" layer that sits alongside them.

Jev vs. LLMs: when to use which?

• If you need to produce content or run multi-step reasoning, an LLM is still the better choice.
• If you need to pick from predefined options, assign a score, or make a yes/no call at high speed, Jev may be a better fit.

This also sets up a notable deployment pattern: use Jev as the first layer and hand the hard cases to an LLM.

What kinds of decisions can Jev handle?

Each time you call Jev, you send a piece of data (state) along with questions of three types:

• Choice: pick one of several options, up to 255. Example: does this ticket belong to billing, technical, or sales?
• Score: rate on a scale of 2 to 10 levels. Example: is the customer calm, frustrated, or very angry?
• Noul: a yes/no question that returns a probability from 0 to 1. Example: is this message urgent?

Below is an example from TypeSafe's official documentation, classifying a customer support ticket.

Request:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated the customer appears",
      "criteria": ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

Response (abridged):

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "choice": "technical",
      "confidence": 0.78,
      "probabilities": { "technical": 0.85, "billing": 0.15, "sales": 0.0 }
    },
    "frustration": { "score": 1.0, "confidence": 1.0 },
    "is_urgent": { "noul": 1.0 }
  }
}

In a single call, Jev answers all three questions: route the ticket to the technical team (confidence 0.78), the customer is frustrated but civil, and the issue is urgent. The result is structured data your code can use right away, with no text parsing or format error handling.

Jev benchmarks: TypeSafe's numbers vs. independent tests

This is the part many articles skip, yet it matters most if you plan to use Jev in practice.

TypeSafe's benchmark: on par with GPT-5.6 Terra, about 75x cheaper

Source: TypeSafe, compiled by DataCamp

One detail deserves attention. The "correct answer" in this benchmark is the average of GPT-6 Astra's and Fable 5.1's answers. In other words, it measures how often Jev agrees with those two models, not absolute accuracy. The test workflows were also built by TypeSafe itself, and the company acknowledges the approach is biased.

Independent benchmark: Jev vs. an LLM on phishing detection

Beri.net had Jev and Claude Haiku 4.5 classify 2,000 emails (half of them phishing) using a single question: "Is this email phishing?"

• Jev: 62.6%
• Claude Haiku 4.5: 81.3%

Another independent benchmark from AY Automate tested three tasks: 8-class banking intent routing, 77-class routing, and prompt injection detection. The results were more neutral: Jev matched small models and trailed the frontier model. On the 77-class task, Jev scored 78.8% versus 84.0% for GPT-5.6 Terra. On prompt injection detection, Jev came out on top at 87.0%.

Is Jev really 193.6x faster than other LLMs?

TypeSafe promotes Jev as "193.6x faster". But when a TypeSafe employee swapped one step of a real pipeline for Jev, the whole system got only 15.9% faster.

The reason is simple: replacing one component with something 400x cheaper doesn't make the whole system 400x cheaper, because the remaining steps still account for most of the time and cost. Before calculating ROI, check how much of your pipeline the step you want to replace actually represents.

How to use Jev effectively: question decomposition and cascades

The benchmarks above show that Jev isn't strong out of the box. It performs well only when used the right way.

Question decomposition

In the same phishing test, instead of asking "Is this phishing?", the tester split the problem into five small, clear questions. For example: do the links use a URL shortener or free hosting? Does the sender claim to represent an organization while using a free email address? The five results were then combined with a logistic regression model trained on 1,000 labeled emails.

Results:

• Jev jumped from 62.6% to 95.0%
• Haiku with the same approach reached 93.2%, a negligible difference
• Jev cost only $0.038 per 1,000 emails, versus $0.462 for Haiku answering one question and $1.02 for Haiku answering five

Notably, decomposition only helped Jev. For Haiku, its best single signal (94.2%) beat its own five-question composite. As Beri concludes: "The accuracy and the calibration aren't in the box." Accuracy doesn't come built into the model; it comes from how you frame the questions.

Because Jev only charges for input, adding more questions costs almost nothing. Decomposition improves accuracy without meaningfully increasing cost.

Cascade: let Jev handle the easy cases, send the hard ones to an LLM

Every Jev answer comes with a confidence score, so you can build a flow like this:

1. Jev handles every request first
2. If confidence ≥ 0.8, use Jev's answer
3. If lower, escalate the request to a larger model such as GPT-5.6 Terra

In AY Automate's benchmark, this cascade matched GPT-5.6 Terra's accuracy at only 26–28% of the cost and about half the latency.

Confidence thresholds should vary with the cost of being wrong. A misrouted ticket can tolerate a lower threshold. Wrongly blocking a transaction calls for a higher one.

The larger model in step 3 doesn't have to be a single fixed choice either. Depending on what gets escalated, you might pick a model strong at reasoning, a cheaper model for simpler tasks, or one optimized for a specific language. Having multiple models available to compare and swap makes building a cascade much easier.

Tip: run a shadow eval before going live

Before putting Jev into production, run it in parallel with your current system on around 1,000–2,000 decisions where you already know the correct answer. The cost is tiny: 5,721 calls cost about $0.18 at list price. In return, you learn exactly how well Jev performs on your own data, rather than relying on the vendor's numbers.

What tasks is Jev not suited for?

• Generating content: writing, summarizing, translating, coding. Jev can't do any of these.
• Calculations: counting, arithmetic, comparing dates. If code can compute it exactly, don't hand it to a model.
• Negations or implied meaning: Jev reads literally and can miss a "not" or unstated conditions.
• Explaining its reasoning: Jev returns only probabilities, with no explanation. This is a major issue in industries that require audits, such as finance or healthcare.
• Long, noisy context: the more irrelevant information, the lower the accuracy. Filter context before asking.
• Open-ended answers: Jev can only choose from the options you define.
• User-controlled input: users can craft input to trick the model, so an extra layer of protection is needed.

There are also criticisms worth weighing. Armin Ronacher, CTO of Earendil, argues that Jev "delegates the hallucination problem… to the user." Jev won't invent new answers, but when confidence sits around 50%, deciding what to do next is still the developer's job.

Frequently asked questions about Jev

Is Jev free?

No. Jev charges $0.042 per million input tokens, with free output. TypeSafe also admits it hasn't yet proven this pricing is sustainable long term.

Can Jev replace ChatGPT or Claude?

No. Jev doesn't generate text. It works best as a classification, routing, or guardrail layer alongside an LLM.

Does Jev really never hallucinate?

Jev can't answer outside predefined options, so it won't "make up" new answers. But it can still pick the wrong one, so you need an appropriate confidence threshold.

How do I get access to Jev?

Jev is currently in early access via console.typesafe.ai. It's also available on Vercel AI Gateway and Cloudflare Workers AI, with SDKs for Python and JavaScript.

Does Jev work well with non-English languages?

So far, no public benchmark has tested Jev on languages such as Vietnamese. If you plan to use it on non-English data, run a shadow eval on real data first.

Jev isn't the only option

Jev highlights a notable approach to building AI systems: you don't need one model for every task.

A single workflow can combine several types of models:

• Fast models for classification and routing
• Large models for complex reasoning
• Specialized models for embeddings
• Image or audio generation models for multimodal tasks
• Code or rule-based systems for logic that can be determined exactly

That's why model selection and model routing are becoming increasingly important when building AI applications.

Instead of searching for one "best" model for every use case, businesses can choose models based on accuracy, latency, cost, language, and workload characteristics.

If you're looking for multiple models to test and compare within the same workflow, GreenNode Model as a Service gives you access to models from multiple providers through a single API. You can pick models based on your needs, try them directly in the Playground, and evaluate them before integrating into your system.

Explore new latest models on GreenNode MaaS →