TypeSafe's Jev: what a decision model is and how to use it (Noul, Choice and Score)

1. What Jev is#

Jev is the TypeSafe model that Cloudflare's documentation describes as a structured evaluation model: it takes a state (a text or an object) and evaluates it against typed questions, returning calibrated answers with probabilities and confidence. It does not generate free text. It is offered on Workers AI as typesafe/jev and, according to third-party guides, also through other providers.

The questions are of three types, which can be combined in a single call.

The practical use is putting a typed decision in an application's flow: which team a ticket goes to, whether a message is urgent, whether a text attempts a prompt injection. Instead of asking a language model to write a reply and then interpreting the text, you receive numbers you can compare against a threshold.

Documentation: Cloudflare: Jev (typesafe/jev) ↗

2. How the call is made#

The request carries the state and an object of questions, each with its type, instructions and criteria. The code builds exactly the example request from Cloudflare's documentation (on Workers AI it goes to env.AI.run with the typesafe/jev model; over the REST API it goes inside the input field).

import json

request = {
    "state": "Help! My payouts have been failing for 3 days.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Does this convey urgency?",
                      "criteria": {"true": "Explicitly time-sensitive", "false": "No urgency expressed"}},
        "department": {"type": "choice", "instructions": "Which team should handle this?",
                       "criteria": {"billing": "Payments, invoicing, refunds",
                                    "technical": "Bugs, outages, integrations",
                                    "sales": "Pricing, upgrades, new accounts"}},
        "frustration": {"type": "score", "instructions": "How frustrated is the customer?",
                        "criteria": ["Calm", "Frustrated", "Very angry"]},
    },
}

body = json.dumps({"model": "typesafe/jev", "input": request})
print(sorted(request["questions"]), len(body) > 0)

The response carries, for each question, its type and the numbers: a noul of 0.95, a chosen option with confidence 0.8 and a score of 1.04 over the level legend, plus the model used and the tokens consumed.

3. From the answer to a decision#

A probability is not a decision until you set what to do with it. The function applies a confidence threshold: if the chosen option's confidence does not reach it, the case goes to a person. The score is rounded to the nearest level of the legend. It is tested with the documentation's example response.

import json

# Example response from Cloudflare's documentation for typesafe/jev
RESPONSE = json.loads("""
{"model": "jev-1.13.0",
 "answers": {
  "is_urgent": {"type": "noul", "noul": 0.95},
  "department": {"type": "choice", "choice": "billing", "confidence": 0.8,
                 "probabilities": {"billing": 0.87, "sales": 0, "technical": 0.13}},
  "frustration": {"type": "score", "score": 1.04, "confidence": 0.94,
                  "legend": {"0": "Calm", "1": "Frustrated", "2": "Very angry"},
                  "probabilities": {"0": 0, "1": 0.96, "2": 0.04}}},
 "usage": {"input_tokens": 426, "output_tokens": 73}}
""")

def decide(response, threshold=0.7):
    """Turns the calibrated answers into an action; if confidence is low, hands over to a person."""
    a = response["answers"]
    dept = a["department"]
    return {
        "urgent": a["is_urgent"]["noul"] >= 0.5,
        "team": dept["choice"] if dept["confidence"] >= threshold else "human_review",
        "tone": a["frustration"]["legend"][str(round(a["frustration"]["score"]))],
        "model_version": response["model"],
    }

print(decide(RESPONSE))
print(decide(RESPONSE, threshold=0.9)["team"])

4. What it costs against an LLM#

The table summarizes the data on Jev's Cloudflare page. Output is not charged: only input counts.

With the tokens of the example response (426 input and 73 output), a million requests cost about $17.89 with Jev. Doing the same classification with a language model at Gemini 4 Argon's introductory rate ($2 input and $10 output per million) would cost about $1,582 per million requests, 88 times more. In pesos, with the TRM of October 17, 2026: COP 56,801 versus COP 5,022,328.

from decimal import Decimal as D

TOKENS_IN, TOKENS_OUT = 426, 73        # "usage" of the documentation's example response
JEV_INPUT = D("0.042")                       # USD per million input tokens; output costs 0
ARGON = (D("2"), D("10"))                      # Gemini 4 Argon, introductory rate until Nov 30, 2026
TRM = D("3174.67")                             # TRM of Oct 17, 2026

million = D(1_000_000)
jev = D(TOKENS_IN) * JEV_INPUT / million * million                      # USD per million requests
llm = (D(TOKENS_IN) * ARGON[0] + D(TOKENS_OUT) * ARGON[1]) / million * million

print(f"Jev: ${jev:,.2f} | LLM: ${llm:,.2f} per million requests | {llm / jev:.0f} times")
print(f"In pesos: COP {jev * TRM:,.0f} vs COP {llm * TRM:,.0f}")

Go deeperAI API prices in October 2026: what each model costs

Documentation: OpenRouter: What is Jev? ↗ · DataCamp: Jev, the System One model ↗ · LangChain: What is Jev? ↗

5. When to use it and when not#

• It fits classifying, routing, filtering and scoring at high volume and low latency.
• It fits decisions that need a probability you can compare against a threshold and audit.
• It does not fit writing, summarizing or chatting: it generates no text.
• It has a 32,000-token window: a long document has to be trimmed first.
• It is a third party's model: review what data you send and its terms before sending sensitive information.

Third-party guides stress that Jev never hallucinates and is far faster and cheaper than an LLM. These are claims from the company or content close to it: test them on your own data before relying on them.

6. How to adopt it without risk#

• Start in shadow mode: let Jev decide in parallel and compare with your current decision before applying it.
• Measure agreement and, above all, disagreements: that shows whether your options' descriptions are clear.
• Write distinct, specific criteria for each option; routing quality depends on them.
• Set a confidence threshold and a path to a person for what does not reach it.
• Log the model version each response returns, because it can change.
• Check your provider's documentation for the endpoint and model name: third-party guides cite different ones (jev-1.14, jev-latest).

Go deeperDecision models: Jev, Microsoft-Decision-1 and OpenAI's Decisions API