How big is Jev? What's known about the model size

A common question for any model is "how many parameters?" — and for Jev the honest answer is that TypeSafe AI hasn't published one. Jev is a hosted, closed System One model, so its parameter count and internal architecture aren't public. Here's what TypeSafe has disclosed, why the size isn't the number that decides whether Jev fits your call, and the open Jev-class models that do ship a size you can see and run.

There's no official parameter count for Jev, and no reliable way to infer one from the outside. Latency and price don't pin down a size — a non-autoregressive sampler returns a whole structured answer in one forward pass, so it's fast for reasons that have little to do with how many parameters it has. Treat any specific "Jev is N billion parameters" figure from a secondary blog as unverified.

What TypeSafe has disclosed

Jev's public material describes how the model behaves and is trained, not how large it is:

• It's a System One model — it emits typed structured values (a choice, a score, a yes-probability), not token-by-token text.
• It's non-autoregressive: one state plus your typed questions are evaluated in a single parallel forward pass, which is why decisions land in about 70–500 ms, roughly 40–200x faster than a frontier LLM.
• It's trained with RLCD (Reinforcement Learning for Calibrated Decisions), so the published quality measure is calibration — whether its probabilities match reality — not a parameter count.
• 0% structured-output error: the answer is always inside your schema (which is not the same as always correct).
• Versions are pinned checkpoints — jev-1.13.0 is the current stable line (jev-latest); jev-1.14.0 (jev-preview) adds the vision path. Neither version note states a model size.

What's absent from all of it is the parameter count, layer widths or any architecture internals. That's a deliberate consequence of Jev being a hosted, closed model: you call it over the API and never host the weights, so TypeSafe never has to publish a size.

So how big is it, really?

Unknown, from the outside — and worth being disciplined about. You can't back it out from the latency (the single-pass design makes speed a poor proxy for size) or from the price (output is free and input is billed per token, which says nothing about parameters). If you need an exact on-disk size for capacity planning, a closed hosted model is the wrong place to look for it; reach for an open one instead.

The open Jev-class models give you a size you control

Several independent, open-weight models rebuild Jev's shape — typed choice / score / yes-no — on public weights, so with those you can see the size and run them yourself. They are not TypeSafe's Jev; their calibration and accuracy are their own and should be validated on your data.

So if "how big is it" is really "what can I download and run on my own hardware," Laya at roughly 420M is the concrete answer — not a figure for Jev, but the closest self-hostable model of the same kind. The alternatives page lays out the full open field.

Why size isn't the number to optimise here

For a generative LLM, parameter count is a rough proxy for capability. For a System One decision model it mostly isn't: the job is one bounded judgment returned fast and calibrated, so the two numbers that decide whether Jev fits are its latency on your questions and whether its confidence is trustworthy enough to gate on. Both are things you can measure directly — size is not.

Measure what actually matters

Instead of chasing a parameter count, send your real cases and time them. One decide call returns every answer in a single pass, with a confidence you can check against your own ground truth:

const t0 = performance.now();
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: yourRealCase,
    questions: {
      route: { type: "choice", instructions: "Which queue handles this?",
               criteria: { billing: "money", bug: "broken", other: "anything else" } },
    },
  }),
});
const { answers } = await res.json();
console.log(answers.route.choice, answers.route.confidence,
            `${Math.round(performance.now() - t0)}ms`); // the numbers that matter

FAQ

See also: The Jev benchmark · How Jev works · Open Jev alternatives · Jev 1.14 (versions) · The Jev paper