How does Jev work?

Jev works differently from a chat model. It's TypeSafe AI's System One model: you give it some state and a set of typed questions, and it returns a structured, calibrated answer to each — a pick, a score, or a yes/no — in a single non-autoregressive pass. There's no prose generated token by token, so there's nothing to parse and nothing to hallucinate. Here's the mechanism, step by step.

A normal LLM answers by generating text one token at a time, and then you parse that text back into the value you actually wanted. Jev skips both ends: you declare the answer space up front as typed questions, and Jev emits the typed value directly — one of your options with a probability for each, a score on your scale, or a calibrated yes/no — in one forward pass. That single parallel pass, not a smaller model, is why it lands in roughly 70–500ms, often 40–200x faster than prompting a frontier LLM for the same decision.

One call: state plus typed questions in, a typed answer per question out — each with calibrated probabilities, no free text in between.

One call: state + questions → answers

Every Jev call is one request to POST https://jevtypesafeai.com/api/v1/decide (official upstream POST https://api.typesafe.ai/v1/systemone). You send a state — the context the decision needs, as a string, object, or array — and a map of typed questions. Jev evaluates all the questions against that state in parallel and returns an answers map keyed to your question names. Because the type of each answer is fixed by your request, you branch on it in plain code.

The three question types

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

Why it's fast and never malformed

Jev is a non-autoregressive parallel sampler: it produces the whole structured answer in one forward pass instead of decoding a sentence token by token. Nothing is generated outside your declared answer space, so a choice is always one of your options and a noul is always a number — 0% structured-output error, nothing to repair. That is the real source of both the speed and the reliability, not a cheaper model.

Calibrated confidence (RLCD)

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 lets you route on the number itself: auto-act above a high threshold, send the uncertain middle to a human, and fall back below a low one. Pin a model version in production so those thresholds stay stable.

What Jev does not do

Jev doesn't write text — no essays, code, summaries, or chat. It's a decision primitive, not a generator. When you need prose you still use an LLM; Jev is what you put in front of it to route, classify, verify, or gate, cheaply and reliably. Jev is named after the economist William Stanley Jevons; "System One" is a nod to Kahneman's fast, intuitive mode of thought.

Make one call

The whole model fits in one request — a state and a couple of typed questions, a calibrated decision back for a fraction of a cent:

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

FAQ

How does Jev work in one sentence?

You send state plus typed questions to one endpoint, and Jev returns a typed, calibrated answer to each — a choice, a score, or a yes/no — in a single non-autoregressive pass, with no text to parse.

Why is Jev so fast?

It's a non-autoregressive parallel sampler: it emits the whole structured answer in one forward pass instead of decoding text token by token. That single pass is why decisions land in ~70–500ms, often 40–200x faster than prompting a frontier LLM for the same thing — not because it's a smaller model.

Does Jev generate text?

No. Jev only returns typed decisions — pick-one, score, or calibrated yes/no. It never writes prose, so there's nothing to parse and no invalid output. When you need text you use an LLM, and put Jev in front of it to route, classify, or gate.

What makes Jev's confidence trustworthy?

Jev is trained with RLCD (Reinforcement Learning for Calibrated Decisions) so its probabilities are calibrated — a 0.8 is right about 80% of the time across many calls. That lets you set action thresholds on the number itself. Pin a model version so the thresholds stay stable.

See how it works in one call

Run a real decision in the browser with no signup, then grab a jv_live_ key and call /api/v1/decide from your own code.

▶ Try Jev free Get an API key →