What Is Jev? TypeSafe's Decision Model, Tested Against LLMs

One of the most talked-about AI models of September can't write a sentence. Jev, from TypeSafe AI, reads your text and returns a decision instead: a yes/no probability, a choice from your options, or a score, each with a confidence number attached. We ran it against Claude Opus 5.5, GPT-6 Sol and three cheaper LLMs (GPT-6 Luna, Gemini 3.5 Flash and DeepSeek V4 Flash) on 900 examples across three tasks. Here's what we found:

• Accuracy. On 77-intent routing, Opus 5.5 and GPT-6 Sol beat Jev by about 7 points, and the cheaper LLMs were statistically tied with it. On offensive-content moderation, Jev had the best F1 of six models. On rating answer quality, it was the weakest.
• Price. Jev was 84–150x cheaper than Opus 5.5 and 17–30x cheaper than GPT-6 Sol. Against the cheaper LLMs the cost was roughly even, and DeepSeek V4 Flash was cheaper on routing.
• Speed. Jev was the fastest model on every task: 6–18x faster than the LLMs on the server, 1.7–3.9x end to end.
• Confidence. On classification, Jev's confidence was well calibrated: at 0.9 or higher it was right 94–96% of the time.
• Jev + LLM. As a first-pass filter in front of Opus 5.5, Jev matched Opus's accuracy on both classification tasks at 38–45% of its cost.

What Is Jev, and Why Does TypeSafe Call It a System One Model?

Jev is a decision model from TypeSafe AI, released in early access on September 15, 2026. You give it a piece of text and a set of typed questions. It returns an answer for each question from options you defined, with a probability attached, and it never writes free-form text.

Most AI features in production don't need a paragraph. They need a label: route the ticket to billing, flag the comment, pass or fail the agent's next step. Jev only does that job.

Who built it

TypeSafe AI is a San Francisco lab founded by Diogo Almeida, Erik Gafni and Sasha Sheng. Almeida is a former OpenAI researcher and a co-author of the InstructGPT paper, the RLHF work that led to ChatGPT.

The company came out of stealth the same day Jev launched, with a $40 million seed round led by DCVC at a $200 million valuation, according to Forbes. AIwire has more on the round.

What "System One" means here

The name borrows from Daniel Kahneman's two systems of thinking: System 1 is fast and intuitive, System 2 is slow and deliberate. TypeSafe defines a System One model as one "built to make fast, structured decisions that software can use directly." LLMs that reason step by step play the System 2 role.

It's TypeSafe's own term, and there are no shared benchmarks for it yet. It caught on anyway. Within two weeks it had an independent directory and at least six open-source models calling themselves System One or "Jev-like."

Specs at a glance

Since output isn't billed, what you pay depends only on input: your text plus every question and option description.

How Does Jev Answer Without Generating Text?

Jev reads your text and your questions in a single pass and returns a probability for every option you defined. An LLM writes its answer token by token; Jev scores all your options at once.

Noul, Choice and Score

Every Jev question has one of three types:

• Noul returns one number: the probability that the answer is yes.
• Choice picks one option from up to 255 that you define, with a probability for each.
• Score places the input on an ordered scale you define and returns a fractional score plus the distribution behind it.

You can ask several questions about the same text in one call. We sent this request through AI/ML API on September 25, 2026: one support message, three questions about it.

{
  "model": "typesafe/jev",
  "state": "I was charged twice for my API subscription this month and support hasn't replied in 4 days. Fix this today or I'm moving our team to another provider.",
  "questions": {
    "is_urgent": {
      "type": "noul",
      "instructions": "Does this message need a reply within the same business day?"
    },
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "billing": "Charges, invoices, refunds",
        "technical": "API errors, outages, integrations",
        "sales": "Plans, upgrades, enterprise deals"
      }
    },
    "churn_risk": {
      "type": "score",
      "instructions": "How likely is this customer to leave?",
      "criteria": ["Low", "Medium", "High"]
    }
  }
}

Jev's answers, trimmed from the full response:

{
  "is_urgent": { "type": "noul", "noul": 0.91 },
  "team": {
    "type": "choice",
    "choice": "billing",
    "confidence": 1,
    "probabilities": { "billing": 1, "technical": 0, "sales": 0 }
  },
  "churn_risk": {
    "type": "score",
    "score": 1.99,
    "confidence": 0.99,
    "legend": { "0": "Low", "1": "Medium", "2": "High" },
    "probabilities": { "0": 0, "1": 0, "2": 1 }
  }
}

Jev processed the request in 131 ms, while the whole call took 0.95 seconds end to end.

Routing came back as billing with confidence 1, and urgency at 0.91. Your code decides what those numbers trigger: you set the threshold above which it acts without a person. Confidence 1 isn't a guarantee, though. In our routing test, 12 of 197 answers at 0.9 or higher were wrong, so automatic routing makes sense only if that error rate is acceptable for the task.

Architecture, sampler and RLCD

TypeSafe has only described Jev in outline. According to its launch post, Jev combines three pieces:

• a new model architecture built for decisions rather than text;
• a parallel sampler that produces all answers at once instead of token by token;
• a training method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD), meant to make the probabilities match how often the model is actually right.

What isn't public: the parameter count, the training data and a paper. Hacker News commenters asked for a paper in the first days, and we couldn't find one as of September 25. RLCD's promise can be checked from the outside: if the probabilities are calibrated, answers at 0.9 confidence should be right about 90% of the time.

Why you only pay for input

Jev doesn't write free-form text or stream an answer token by token, and only input is billed. The response does report output tokens, about 830 per call on our 77-option routing task, but across all 900 of our calls through AI/ML API, every charge equaled input tokens times the input price.

Jev's input includes your questions and every option description, so it counted more input tokens than GPT-6 Sol for the same message, instructions and option list. It still cost far less: its input price is about 45 times lower ($0.0578 vs. $2.60 per 1M tokens), and Sol also bills output at $13 per 1M.

Against GPT-6 Sol, the extra tokens don't change the outcome. Against cheap LLMs they can: on routing, DeepSeek V4 Flash cost $77 per 1M decisions against Jev's $98. To keep Jev's bill down, keep option descriptions short and don't send options that can't apply to the message.

What Problem Does Jev Solve That LLMs Handle Badly?

Jev targets classification jobs (routing, moderation, tagging, gating an agent's next step) where an LLM is slower and more expensive than the task needs and gives no measured confidence. A third problem often cited, invalid labels, is already solved for LLMs by structured outputs.

Problem 1: LLMs are slow and expensive for one-word answers

A lot of LLM calls in production go to the same few jobs: routing support tickets, moderating user content, tagging documents, deciding whether an agent's next action is allowed. Each one needs a label from a list you already know. An LLM does these fine, but you pay for a system built to write and reason, and you wait for it. In our tests, the five LLMs spent 0.9 to 2.6 seconds on their own servers to return a one-word label; Jev took about 0.14 seconds.

Problem 2: LLMs don't tell you how sure they are

An LLM that answers "billing" gives you no signal about whether it was a coin flip. You can ask it to rate its own confidence, but that's more generated text with no measured probability behind it. Jev returns a probability with every answer, so your code can hand the uncertain cases to a person or a bigger model.

Problem 3: Invalid labels, which structured outputs already fix

This was the top objection on Hacker News, and a fair one. Structured outputs and constrained decoding already force an LLM to return a valid label, so a type-safe answer on its own is old news. What Jev adds is a lower price, lower latency and a calibrated probability. How much those are worth depends on which LLM you compare against.

How Did Jev Perform Against Claude Opus 5.5 and GPT-6 Sol?

Jev lost to both flagships on 77-class intent routing, had the best F1 of six models on content moderation, and ranked worst when judging answer quality. The three cheaper LLMs (GPT-6 Luna, Gemini 3.5 Flash and DeepSeek V4 Flash) were statistically tied with Jev on routing. On moderation their accuracy was similar to Jev's, but their F1 was lower.

How we tested

• 3 tasks: intent routing (Banking77), offensive-content moderation (TweetEval) and answer-quality rating (HelpSteer2). 300 examples each, the same random sample for every model (seed 42), run on September 25, 2026 through AI/ML API.
• 6 models: Jev 1.13, Claude Opus 5.5, GPT-6 Sol, GPT-6 Luna, Gemini 3.5 Flash and DeepSeek V4 Flash.
• Every LLM ran at the lowest reasoning setting it allows: none for GPT-6 Sol, GPT-6 Luna and DeepSeek V4 Flash, minimal for Gemini 3.5 Flash, low for Claude Opus 5.5, whose thinking can't be turned off. Temperature was 0, except for Opus 5.5, which only accepts 1 when thinking is on.
• Jev and the LLMs got the same instructions and the same option descriptions.
• Cost is what AI/ML API actually billed. Latency is measured from one client and includes the network.
• Code, prompts and every raw answer are on [GitHub link].

Task 1: Routing 77 support intents (Banking77)

Banking77 is a public set of real banking support questions labeled with 77 intents, and a common test for Jev-style models.

Opus 5.5 and GPT-6 Sol were about 7 percentage points more accurate than Jev, a statistically significant difference (p < 0.001). Jev's results were not significantly different from GPT-6 Luna, Gemini 3.5 Flash or DeepSeek V4 Flash.

All six models missed the same 32 of 300 questions (11%), usually with the same wrong answer. For example, "What extra charges are there?" is labeled transfer_fee_charged, and every model said extra_charge_on_statement. We didn't review these 32 examples by hand, so this shows only that the models make the same mistakes, not that the labels are wrong.

Task 2: Flagging offensive tweets (TweetEval)

TweetEval's offensive split is a set of real tweets labeled by humans. In our sample of 300, 28% are offensive.

Accuracy is misleading here: a model that never flags anything scores 72.3%. F1 on the offensive class is the number that matters, and Jev had the best one. It caught 77% of offensive tweets, more than any LLM; the LLMs were more cautious and missed 35 to 59%. The price of that recall is more false alarms: Jev's precision was 0.63, against 0.69 to 0.76 for the LLMs.

Task 3: Judging answer quality (HelpSteer2)

NVIDIA's HelpSteer2 pairs prompts with AI answers that people rated for helpfulness from 0 to 4. We asked each model for the same rating, which is the LLM-as-a-judge job.

Jev ranked answers worst, with a 0.39 correlation to human ratings against 0.48 to 0.49 for Gemini 3.5 Flash and Claude Opus 5.5. Two caveats. First, the models disagreed with the humans on the absolute scale: Opus 5.5 and both GPT-6 models graded much harsher, averaging 1.8 to 2.0 where people averaged 2.8. That's why exact-match accuracy fell below a naive "always answer 4" baseline (38.7%) for five of the six models, and why correlation is the fair metric. Second, Opus 5.5 returned 3 empty answers, which we counted as wrong.

Is Jev Really 100x Cheaper and Faster Than an LLM?

No, not across the board, and price and speed need separate answers:

• Price. Jev was 84–85x cheaper than Claude Opus 5.5 on routing and moderation; the gap passed 100x (150x) only on answer rating. Against GPT-6 Sol it was 17–30x cheaper. Against GPT-6 Luna and DeepSeek V4 Flash the price was roughly even.
• Speed. Jev wasn't 100x faster than any model. On the server it was 6–18x faster than the LLMs; end to end, 1.7–3.9x.

Cost per 1M decisions, task by task

All costs are AI/ML API billing for our exact prompts, with Jev at $0.0578 per 1M input tokens. Your numbers will move with the length of your messages and your option lists.

Long option lists can make Jev cost more than a cheap LLM

Jev bills only input, and input grows with every option you define. On 77-intent routing, that put Jev at $98 per 1M decisions, above DeepSeek V4 Flash at $77. On a single yes/no moderation question, Jev cost $19 per 1M, 85 times less than Opus 5.5 and slightly more than GPT-6 Luna at $16.

Latency: 140 ms on the server, 0.83 s end to end

Jev was the fastest model in every task.

Moderation task. Server-side is the processing time AI/ML API reports in each response's metadata, median of 20 to 30 calls (10 for Opus 5.5). End to end is the median of the 300 benchmark calls.

On the server, Jev returned a decision in about 140 ms, 6 to 18 times faster than the LLMs. From our machine, every call also paid roughly 0.7 to 0.9 seconds of network and gateway time, which shrank Jev's lead to 1.7 to 3.9 times. If latency is why you want Jev, put all your questions into one call and measure your own round trip before you promise anyone 140 ms.

Can You Trust Jev's Confidence Score?

On classification, yes. On rating answer quality, our results say no.

"Can't hallucinate" is not the same as "can't be wrong"

Jev never returned a label outside our schema in 900 calls. It was still wrong, sometimes confidently. On Banking77, 12 of the 197 answers it gave with confidence of 0.9 or higher were incorrect. One of them: "How can I use American Express to add money to my account?" is labeled supported_cards_and_currencies, and Jev answered topping_up_by_card at 0.97, which is a reasonable reading of the question. A high score tells you Jev is sure. It doesn't tell you Jev picked the label you had in mind.

Calibration by task

Calibration error (ECE) is the average gap between how confident Jev said it was and how often it was right. Zero is perfect.

For answer rating, [TODO: describe the method. What counted as a correct answer (for example, the most probable level matching the human rating exactly), and which probability we used as confidence (for example, the probability of that level). Without this, the 0.284 figure can't be interpreted.]

A 0.9 threshold: 94–96% accuracy on half to two thirds of traffic

Say you only accept Jev's answer above a confidence threshold. This is how much traffic it handles on its own, and how accurate that share is:

At 0.9, Jev was right 94 to 96% of the time on both classification tasks. That's higher than any model's overall accuracy on the same data, Claude Opus 5.5 included. The trade-off is coverage: the remaining third to half of the traffic needs somewhere else to go.

How Do You Use Jev as a Filter in Front of an LLM?

Let Jev answer when it's confident and send everything else to an LLM. On both classification tasks, that matched Claude Opus 5.5's accuracy at 38 to 45% of its cost.

The pattern

1. Ask Jev the question and read the confidence.
2. If it's at or above your threshold, use Jev's answer.
3. Otherwise, send the same message and the same options to an LLM.

In code, it's one extra if. This version runs as written against AI/ML API; we tested both paths on September 25, 2026.

import os
import requests

API = "https://api.aimlapi.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['AIMLAPI_API_KEY']}"}

TEAMS = {
    "billing": "Charges, invoices, refunds",
    "technical": "API errors, outages, integrations",
    "sales": "Plans, upgrades, enterprise deals",
}
THRESHOLD = 0.9  # tune on 200-300 of your own labeled examples

def route(message: str) -> tuple[str, str]:
    # Step 1: Jev answers first. Fast, cheap, and it tells you how sure it is.
    decision = requests.post(f"{API}/decisions", headers=HEADERS, timeout=30, json={
        "model": "typesafe/jev",
        "state": message,
        "questions": {"team": {
            "type": "choice",
            "instructions": "Which team should handle this?",
            "criteria": TEAMS,
        }},
    }).json()["answers"]["team"]

    if decision["confidence"] >= THRESHOLD:
        return decision["choice"], "jev"

    # Step 2: Jev isn't sure. Send the same question to an LLM.
    options = "\n".join(f"- {key}: {desc}" for key, desc in TEAMS.items())
    reply = requests.post(f"{API}/chat/completions", headers=HEADERS, timeout=60, json={
        "model": "anthropic/claude-opus-5-5",
        "reasoning_effort": "low",
        "messages": [
            {"role": "system", "content": "Route the message to one team. "
                                          f"Reply with the team key only.\n{options}"},
            {"role": "user", "content": message},
        ],
    }).json()
    return reply["choices"][0]["message"]["content"].strip(), "llm"

print(route("My invoice shows a charge I don't recognize."))  # ('billing', 'jev')

What it saved in our tests

On moderation, the hybrid was slightly more accurate than Opus 5.5 alone, because Jev's confident answers were better than Opus's average. It also means about two thirds of requests get Jev's 0.83-second median response instead of Opus's 3.2 seconds. With GPT-6 Sol as the fallback, routing cost $895 per 1M decisions instead of $2,321.

How to pick the threshold

Label 200 to 300 of your own examples, run Jev on them and check accuracy above each threshold. Pick the lowest threshold where accuracy meets your bar; the share below it is what you'll pay the LLM for. Skip this pattern for fuzzy judgment tasks: on answer rating, Jev's confidence was poorly calibrated in our test, so a threshold is unlikely to separate good answers from bad ones.

When Should You Not Use Jev?

Don't use Jev when the task needs judgment about quality, arithmetic or more than text. And if closed weights are a problem for you, that rules it out too.

Judging quality and nuance

Rating how good an answer is was Jev's weakest task in our test: the lowest correlation with human ratings of six models, and poorly calibrated confidence. For LLM-as-a-judge work, an LLM is still the better tool, and Gemini 3.5 Flash matched Claude Opus 5.5 there at about 5% of its price.

Math, dates and indirect references

Independent reviews found that Jev struggles when the answer depends on arithmetic, comparing dates, reading text literally or resolving indirect references. Do the math in code first, then ask Jev about the result.

Hard limits

• Text input only: no images, audio or PDFs.
• 32K-token context window.
• Up to 255 options per Choice question.
• No free-form text output, so no explanations for its decisions.
• Closed weights and hosted access only. As of September 25, 2026, TypeSafe hasn't announced open weights or fine-tuning.

What Other Decision Models Appeared After Jev?

At least six open-source decision models came out within ten days of Jev's launch, and Together AI released one of its own. Latent Space counted "6 clones of Jev in 2 days."

Why so many clones so fast

The core idea is easy to reproduce. Take an existing encoder or small LLM, attach a head that scores each option against the question, and train it to output probabilities. Most clones build on ModernBERT or Qwen. Together AI published a recipe that trains one for $17.

Closed vs. open: how big is the gap?

We didn't test the open models, so these numbers come from their authors. Zero-shot, they trail Jev: on a 49-task suite reported in the Von repository, Jev scored 96.6% macro accuracy and the best open model 72.0%. After fine-tuning on your own labels, the gap narrows. Published Laya results show it beating Jev after fine-tuning (0.766 vs. 0.727 on a typed-decisions benchmark), while its base checkpoints score below a majority-class baseline out of domain.

Which one to pick

• Jev if you have no labeled data, need many options, or want a hosted API with nothing to run.
• Laya, Von or GLiNER2.5-Decide if you have a few hundred labeled examples to fine-tune on and need to keep data on your own hardware.
• Kev or the Tev1 recipe if you want to train your own and see exactly how it was evaluated.

How Do You Call Jev Through AI/ML API?

Send a POST request to /v1/decisions with the model typesafe/jev, your text as state, and your questions. The same AI/ML API key works for Jev and every LLM in this article.

1. Create an API key in your AI/ML API dashboard.
2. Save it as an environment variable: export AIMLAPI_API_KEY=...
3. Send the request below and read answers from the response.

import os
import requests

response = requests.post(
    "https://api.aimlapi.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['AIMLAPI_API_KEY']}"},
    json={
        "model": "typesafe/jev",
        "state": "I was charged twice this month and support hasn't replied in 4 days.",
        "questions": {
            "is_urgent": {
                "type": "noul",
                "instructions": "Does this message need a reply within the same business day?",
            },
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Charges, invoices, refunds",
                    "technical": "API errors, outages, integrations",
                    "sales": "Plans, upgrades, enterprise deals",
                },
            },
            "churn_risk": {
                "type": "score",
                "instructions": "How likely is this customer to leave?",
                "criteria": ["Low", "Medium", "High"],
            },
        },
    },
    timeout=30,
)

answers = response.json()["answers"]
print(answers["is_urgent"]["noul"])                                  # e.g. 0.91
print(answers["team"]["choice"], answers["team"]["confidence"])      # e.g. billing 1.0
print(answers["churn_risk"]["score"], answers["churn_risk"]["confidence"])

Python's requests and the OpenAI SDK work as-is. If you hand-roll HTTP with Python's built-in urllib, set a User-Agent header: the API's firewall rejects urllib's default one with a 403. The full parameter reference is in the Jev docs.

FAQ

What is Jev AI?
Jev is a decision model from TypeSafe AI, released on September 15, 2026. It takes text plus a typed question and returns a yes/no probability, a choice from your options, or a score, each with a confidence value. It doesn't write free-form text, so it's built for classification, routing and gating rather than chat.

Is Jev better than an LLM?
It depends on the task. In our tests, Claude Opus 5.5 and GPT-6 Sol beat Jev by about 7 points on 77-class intent routing. On offensive-content moderation, Jev had the best F1 of six models (0.696). On rating answer quality, Jev ranked answers worst (Spearman 0.39 vs. 0.48 for Opus 5.5).

How much does Jev cost?
Through AI/ML API, which we used for testing, Jev costs $0.0578 per 1M input tokens; OpenRouter lists it at $0.042. Output isn't billed. In our tests, Jev cost $19 to $98 per 1M decisions: 84–85 times less than Claude Opus 5.5 on classification and 150 times less on answer rating. Against cheap LLMs like GPT-6 Luna and DeepSeek V4 Flash, the cost was roughly the same.

Can Jev hallucinate?
Jev can't return a value outside your schema, which is what TypeSafe means by "can't hallucinate." It can still be confidently wrong. On our 77-class routing test, 12 of 197 answers with confidence of 0.9 or higher were incorrect. Use confidence to decide what to double-check.

Is Jev's confidence score reliable?
On classification, yes. Jev's calibration error was 0.032 on moderation and 0.096 on intent routing, and at confidence of 0.9 or higher it was right 94 to 96% of the time. On rating answer quality, calibration was poor (0.284), so thresholds don't help there.

Can Jev replace an LLM as a judge?
Not yet, based on our test. On NVIDIA's HelpSteer2, Jev's ratings correlated with human ratings at 0.39, the lowest of six models. Gemini 3.5 Flash and Claude Opus 5.5 reached 0.48 to 0.49. Jev was the cheapest judge, but for grading answer quality an LLM is still more accurate.

Is there an open-source alternative to Jev?
Yes. Within ten days of Jev's launch, open decision models appeared: Laya (Convai Innovations), Kev (Jared Palmer), Von, Tev1-4B (Together AI) and GLiNER2.5-Decide (Fastino Labs), mostly under Apache 2.0. Their authors report that they trail Jev zero-shot and become competitive after fine-tuning.

So, Where Does Jev Fit in Your Stack?

Jev works best as a fast classifier that knows when it's unsure. In our tests, it earned its place in front of an LLM rather than as a replacement for one.

• Put Jev first on high-volume classification, such as routing, moderation and tagging, with a confidence threshold of 0.8 to 0.9, and send the rest to an LLM.
• Keep an LLM for judging quality and anything that needs reasoning.
• On a tight budget, GPT-6 Luna and DeepSeek V4 Flash matched Jev's accuracy for similar money, just without a probability you can act on.

Want to try the Jev-plus-LLM setup on your own data? Jev, Claude Opus 5.5 and GPT-6 Sol all run on AI/ML API with one key, so the whole pipeline is two endpoints and one threshold. Get your API key.