Jev 101

Start here. Jev is TypeSafe AI's System One model: instead of writing text, it turns some state plus a few typed questions into calibrated decisions your code can branch on directly. This is the from-scratch primer — what it is, the three things you can ask it, your first call, and where to go next. No machine-learning background needed.

What Jev is (in one minute)

A chat model answers by generating prose one token at a time, and then you parse that text to get the value you actually wanted. Jev skips both ends. You declare the answer space up front — a set of options, a scale, or a yes/no — and Jev returns the typed value directly in a single non-autoregressive pass. Nothing is generated outside what you asked for, so there is nothing to parse and nothing to hallucinate. That single parallel pass (not a smaller model) is why decisions land in roughly 70–500ms, often 40–200x faster than prompting a frontier LLM for the same thing, with 0% structured-output error.

The three things you can ask

Every Jev question is one of three primitives. That's the whole vocabulary:

• choice — pick one option from a labelled set you define; returns the winning option, a probability for each, and a confidence. Use it to route, classify, or rank.
• score — rate on an ordered scale you define (2–10 levels); returns a (possibly fractional) score with per-level probabilities. Use it to grade or prioritise.
• noul — a calibrated yes/no; returns a single 0–1 probability that the answer is yes. Use it for gates and guardrails.

Your first decision

There is no SDK ceremony to learn first — a decision is one HTTP request. You send a state (the context the decision needs) and a map of typed questions, and you get back a typed answer per question. Here is a complete, paste-able first call that routes a support ticket and flags urgency:

const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
  },
  body: JSON.stringify({
    state: { message: ticket.body },
    questions: {
      queue:  { type: "choice", instructions: "Route this ticket.",
                criteria: { billing: "payments", bug: "something broken", sales: "pricing" } },
      urgent: { type: "noul", instructions: "Is it urgent?" },
    },
  }),
});
const { answers } = await res.json();
route(answers.queue.choice, answers.urgent.noul > 0.8); // typed + calibrated, no parsing

The official upstream endpoint is POST https://api.typesafe.ai/v1/systemone with the same request shape; jevtypesafeai.com/api/v1/decide is the hosted route that takes a jv_live_ key.

Why the confidence is trustworthy

The probabilities Jev returns are meant to be honest, not just ordered. Jev is trained with RLCD — Reinforcement Learning for Calibrated Decisions — so a 0.8 is right about 80% of the time across many calls. That is what lets you act on the number itself: auto-accept above a high threshold, send the uncertain middle to a human, fall back below a low one. Pin a model version in production so those thresholds stay stable.

Where to run it (free first)

You don't need a key to try it. Run a real decision in the browser playground with no signup, then grab a jv_live_ key and point your own code at the endpoint above. Each decision costs a fraction of a cent (output is free), so a classifier or a guardrail that would be expensive on a frontier LLM is cheap here. Current tiers live on the pricing page.

A short learning path

Once the first call makes sense, these are the next steps in roughly the order most people take them:

Prefer video or a third-party walkthrough? There are community-made "Jev 101" guides, courses and tutorials, plus Jev listed on OpenRouter — all independent of TypeSafe, so treat their API details as a starting point and check against the live docs.

FAQ

See also: What is Jev · How does Jev work · Jev examples · Playground · What is a decision model