What is Jev?

Definition

TypeSafe calls Jev the first System One model: a model built for the fast, intuitive judgments a program needs thousands of times a day — route this, block that, rate this — rather than for conversation or long-form reasoning. It is a discriminative model (it classifies and scores) that, unlike a classic classifier, needs no task-specific training: the options are described in plain language at request time.^[6]

How it works

Every request has three parts: a model, a state and a map of questions.^[3]

• State — the input to judge: a string, a JSON object, or an array of strings (Jev 1.14 also accepts images).^[2] Questions can refer to fields of a JSON state by name in backticks.
• Questions — each has an id you choose, a type, an instructions string and, for most types, criteria that describe the allowed answers. The model never sees the id, so all meaning must live in the instructions and criteria.^[7]
• Answers — one typed answer per question under the same id: the pick, a probability for every option and a confidence value.

state + typed questions
        ↓  one parallel pass (no token-by-token generation)
choice / score / noul  +  probabilities  +  confidence
        ↓  your code
act automatically / ask for confirmation / escalate to a human

All questions in one request are answered in parallel against a single read of the state, so they cannot depend on each other. If question B needs the answer to question A, make two calls.^[6]

The three question types

Jev's core API is built from three primitives. Jev 1.14 adds a fourth, Box, for locating something in an image; it is marked early and Jev 1.13 rejects it.^[7]

1. Choice — pick one option

Use it when the answer is one of a fixed, unordered set: which team, which category, which tool. criteria is a map of option name → description. TypeSafe says Jev supports a cardinality of up to 255 options.^[1] The answer returns the chosen option, a probability per option and a confidence value.

{
  "state": "I was billed twice for the Pro plan this month and I only have one workspace.",
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should own this support ticket?",
      "criteria": {
        "billing": "Charges, invoices, refunds and plan changes",
        "technical": "Bugs, outages and features that do not work",
        "account": "Sign-in, passwords and profile settings"
      }
    }
  }
}

2. Score — place it on an ordered scale

Use it when the answer is a position on a spectrum: severity, urgency, quality. criteria is an ordered list of level descriptions from low to high — at least two levels, and the API accepts up to 10.^[4] The returned score is the probability-weighted average of the level indexes, so it can land between levels (for example 1.2).

{
  "state": "CSV export returns a 500 error for every workspace since this morning. JSON export still works, but finance can only import CSV.",
  "questions": {
    "severity": {
      "type": "score",
      "instructions": "How severe is this bug report?",
      "criteria": [
        "Cosmetic: nothing is functionally broken",
        "Degraded: something is broken but a workaround exists",
        "Blocking: work is stopped and there is no workaround"
      ]
    }
  }
}

3. Noul — yes or no

Use it for a true/false proposition. You only need instructions; the answer is a single probability between 0 and 1 that the answer is yes. There is no separate confidence field — for a binary question, a value near 0.5 already means “unsure”.^[7][8]

{
  "state": "I was billed twice this month. Please send the duplicate charge back to my card.",
  "questions": {
    "wants_refund": {
      "type": "noul",
      "instructions": "Is the customer asking for money back?"
    }
  }
}

Speed and cost

For scale: OpenRouter measured a three-question support-ticket call at 447 input tokens costing about $0.000019.^[7] All of these figures are vendor- or partner-reported; measure on your own traffic.

Key characteristics and limitations

• No free-form text. Jev will not write, summarize, explain or chat. If you need words, use an LLM and let Jev route or check its output.
• No off-schema output. Answers are always one of your options, levels or a 0–1 probability, so there is nothing to parse and no type errors.^[1]
• It can still be confidently wrong. “Cannot hallucinate” is a claim about format, not truth: Jev can pick the wrong valid option with high confidence.^[8] Confidence measures how concentrated the probabilities are, not whether the answer is correct.^[5]
• Calibrated in aggregate. A 0.8 means “right about 80% of the time for answers like this”, averaged across many calls — set thresholds from your own labelled data.^[7]
• Weak spots. Exact arithmetic, counting and date comparison; compute those in code and give Jev the semantic part. English is the strongest language; test other languages before relying on them.^[2]
• No fine-tuning. The same weights serve every account; you adapt Jev through state, instructions and criteria.^[2]

Jev vs LLMs vs text classifiers

In practice they combine: Jev routes and verifies, the LLM writes. See also Jev vs LLM JSON mode and the blog post on Jev vs traditional text classifiers.

Training: RLCD

TypeSafe trains Jev with what it calls Reinforcement Learning for Calibrated Decisions (RLCD). Where RLHF optimizes for answers human raters prefer, RLCD optimizes for decisions with honest probabilities — higher confidence should mean higher accuracy.^[1] TypeSafe has not published the method's details or the architecture beyond describing it as transformer-based; outside descriptions of RLCD as a calibration-penalizing loss are speculation.^[6] Jev is not trained on customer requests.^[2]

Where the name comes from

“System One” comes from Daniel Kahneman's Thinking, Fast and Slow: fast, intuitive System 1 versus slow, deliberate System 2. “Jev” honours the 19th-century economist William Stanley Jevons, whose Jevons paradox observed that more efficient coal use increased total demand. TypeSafe's bet is the same for intelligence: every big drop in the cost of a decision unlocks many more uses.^[1]

Versions and where to run it

• Flatkey — POST https://router.flatkey.ai/api/alpha/decisions with model typesafe/jev-1.13. This is what our code samples and use-case demos call. Open Jev 1.13 on Flatkey →
• OpenRouter — the same Decisions request shape at https://openrouter.ai/api/alpha/decisions with typesafe/jev-1.14 or typesafe/jev-1.13; OpenRouter also lists typesafe/jev-router.^[7]
• TypeSafe API — POST https://api.typesafe.ai/v1/systemone, plus the official Python and TypeScript SDKs.^[2]

What Jev is used for

Anywhere a program would otherwise ask an LLM a question and regex out an enum or boolean. Each page below has a live demo and copyable curl / Node.js / Python code.

Copy the code

One call that asks a Choice, a Score and a Noul about the same ticket. Set FLATKEY_API_KEY and run any tab.

curl -sS https://router.flatkey.ai/api/alpha/decisions \
  -H "Authorization: Bearer $FLATKEY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "typesafe/jev-1.13",
  "state": {
    "ticket": "Hi, I was charged twice for Pro this month. Please fix it before our payroll run on Friday."
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should own this support ticket?",
      "criteria": {
        "billing": "Charges, invoices, refunds and plan changes",
        "technical": "Bugs, outages and features that do not work",
        "account": "Sign-in, passwords and profile settings"
      }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is `ticket`?",
      "criteria": [
        "Routine: no deadline mentioned",
        "Soon: the customer wants a fix but nothing is blocked",
        "Now: a deadline is named or work is blocked"
      ]
    },
    "wants_refund": {
      "type": "noul",
      "instructions": "Is the customer in `ticket` asking for money back?"
    }
  }
}'

// Node.js 18+ (built-in fetch). Run: FLATKEY_API_KEY=... node jev.mjs
const body = {
  "model": "typesafe/jev-1.13",
  "state": {
    "ticket": "Hi, I was charged twice for Pro this month. Please fix it before our payroll run on Friday."
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should own this support ticket?",
      "criteria": {
        "billing": "Charges, invoices, refunds and plan changes",
        "technical": "Bugs, outages and features that do not work",
        "account": "Sign-in, passwords and profile settings"
      }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is `ticket`?",
      "criteria": [
        "Routine: no deadline mentioned",
        "Soon: the customer wants a fix but nothing is blocked",
        "Now: a deadline is named or work is blocked"
      ]
    },
    "wants_refund": {
      "type": "noul",
      "instructions": "Is the customer in `ticket` asking for money back?"
    }
  }
};

const res = await fetch("https://router.flatkey.ai/api/alpha/decisions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.FLATKEY_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});
if (!res.ok) throw new Error(`Jev request failed: ${res.status} ${await res.text()}`);
const { answers, usage } = await res.json();
console.log(JSON.stringify(answers, null, 2), usage);

# Python 3.8+ (pip install requests). Run: FLATKEY_API_KEY=... python jev.py
import json, os, requests

body = json.loads(r"""{
  "model": "typesafe/jev-1.13",
  "state": {
    "ticket": "Hi, I was charged twice for Pro this month. Please fix it before our payroll run on Friday."
  },
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should own this support ticket?",
      "criteria": {
        "billing": "Charges, invoices, refunds and plan changes",
        "technical": "Bugs, outages and features that do not work",
        "account": "Sign-in, passwords and profile settings"
      }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is `ticket`?",
      "criteria": [
        "Routine: no deadline mentioned",
        "Soon: the customer wants a fix but nothing is blocked",
        "Now: a deadline is named or work is blocked"
      ]
    },
    "wants_refund": {
      "type": "noul",
      "instructions": "Is the customer in `ticket` asking for money back?"
    }
  }
}""")

res = requests.post(
    "https://router.flatkey.ai/api/alpha/decisions",
    headers={"Authorization": f"Bearer {os.environ['FLATKEY_API_KEY']}"},
    json=body,
    timeout=60,
)
res.raise_for_status()
data = res.json()
print(json.dumps(data["answers"], indent=2), data.get("usage"))

FAQ

Sources

1. TypeSafe AI — Introducing System One Models & Jev (Sep 15, 2026)
2. TypeSafe docs — Models (Jev 1.14 / 1.13, pricing, context, aliases)
3. TypeSafe docs — Primitives (Choice, Score, Noul)
4. TypeSafe docs — Score
5. TypeSafe docs — Confidence
6. Wikipedia — Jev (AI model)
7. OpenRouter — What Is Jev? TypeSafe's Decision Model Explained
8. Sanity glossary — Jev (TypeSafe AI model)

Last reviewed 2026-10-22. Prices, versions and limits change; check the provider before you budget. jev-llm.com is independent and not affiliated with TypeSafe AI.