← Home

What We Know About How Jev Works, and How the Open Copies Build It

TypeSafe hasn't published Jev's architecture. Its docs and the open models that copy its interface still show a lot about how a model can return calibrated typed answers without writing text.

View as Markdown

I wanted to know how Jev works inside. Jev is TypeSafe AI’s “System One” model. It went into early access on 15 September 2026. It doesn’t write text. It reads some input, answers typed questions and gives a probability for every possible answer.

The short answer is that the inside isn’t public. As of 6 November 2026, TypeSafe has not published Jev’s architecture, weights or a technical paper. Wikipedia says the same.

So this post covers three things: what TypeSafe’s own docs say, what the open models that copy Jev’s interface actually do, and where I am guessing. The open models show one way to build the same interface. They don’t tell us how Jev is built.

I didn’t run Jev or any of the open models. Accuracy and speed numbers are reported by the source I link. The worked examples and figures apply those sources’ own formulas.

What goes in and what comes out?

Everything goes to one endpoint, POST /v1/systemone. A request has three parts (Models docs):

  • state: the thing to judge. It can be a string, a JSON object or an array of strings, and it can include PNG or JPEG images.
  • questions: a set of named questions. Each one has a type and instructions.
  • model: for example jev-latest.

There are four question types (System One docs):

Type Asks Answer space
noul Is this true? yes or no
choice Which option? an unordered list
score Where on this scale? ordered levels
box Where in this image? four edges (Jev 1.14 only)

For noul, choice and score, the answer is a probability distribution over that question’s possible answers. box is the odd one out: it returns four edges and a confidence. Questions are answered in parallel, so one answer can’t depend on another. If you need that, you send two requests.

Four boxes joined by arrows: state, then typed questions, then Jev answering in parallel, then one probability distribution per question that sums to 1.
Jev's public interface for noul, choice and score: a state and questions in, one distribution per question out.

What has TypeSafe said about the inside?

Very little. These are the lines that say anything about the inside.

The launch post says Jev uses “a new model architecture, parallel sampler for maximum efficiency, and training method”. It also says Jev “outputs all probabilities in parallel instead of autoregressively generating by token”. Wikipedia says TypeSafe describes Jev as transformer-based. The launch post itself doesn’t use the word.

The most useful line is in the Models docs: “Jev ingests the state once and evaluates every question against it in parallel.” There are also two context limits. A request can be 64k tokens in total, but the state plus any one question must fit in 32k.

My reading, and this is a guess: the state is processed once and shared, and each question is then scored against it on its own. That fits the per-question limit. It also fits the docs saying that adding questions “barely changes the response time”. But it doesn’t tell us if Jev is an encoder, a decoder or something new. Wikipedia notes that outsiders have guessed both an open-weight LLM and a BERT-like model. Neither is confirmed.

Which outputs are not from the model?

This part is fully documented, and I think it’s the clearest window into Jev. For noul, choice and score, the model gives probabilities. The other fields are fixed formulas on top of them (Confidence docs; Wikipedia also says these fields are computed “by fixed formulas” and not by Jev).

  • choice is the option with the highest probability.
  • score is the probability-weighted mean of the level numbers (Score docs). For example, 0.5 on level 1 and 0.5 on level 2 give a score of 1.5.
  • confidence for a Choice with $n$ options is
$$ \text{confidence} = \frac{p_{\max} - \frac{1}{n}}{1 - \frac{1}{n}} $$

So all the probability on one option gives 1, and an even spread gives 0.

A Score uses a different confidence, because its levels are ordered. With $m$ as the most likely level, it compares the average distance from $m$ with the same average for an even spread:

$$ \text{confidence} = \max\left(0,\ 1 - \frac{\sum_i p_i \, |i - m|}{\text{MAD}_{\text{unif}}}\right), \qquad \text{MAD}_{\text{unif}} = \frac{1}{n} \sum_i \left| i - \frac{n - 1}{2} \right| $$

A Noul has no confidence field, since its one probability already says everything.

The docs give an example that shows why Score needs its own formula. Both distributions below put 0.5 on two of three levels, and the figure shows both formulas for each.

Bar chart. With the Score formula, probabilities (0, 0.5, 0.5) give confidence 0.25 and (0.5, 0, 0.5) give 0.00. With the Choice formula, both give 0.25.
Being torn between opposite ends of a scale gives Score confidence 0.

How do the open copies build it?

Open Jev-style models appeared within weeks. Two of them document their design well: Laya from ConvAI Innovations, and OpenDecider-nano from this Hugging Face post. Both are encoders, and both use what their authors call option markers.

The shared idea is that every option gets its own [MASK] token, and each option is scored at its mask. A softmax over that question’s masks gives the probabilities. Because an encoder’s attention goes both ways, each mask can see its option, the question and the state.

OpenDecider-nano’s post gives the exact layout: question: …, [MASK] option 1, [MASK] option 2, …, input: <state>, read in one encoder pass. A small MLP turns the hidden state at each [MASK] into one logit. Here is that layout for a three-option ticket-routing question. The logits $z$ are mine, only to show the softmax step.

A row of tokens: question, which team, then MASK billing, MASK tech and MASK account, then input and the state. The three MASK tokens are outlined. Their logits 2.1, 0.3 and -0.4 give probabilities 0.80, 0.13 and 0.07.
Each option gets its own [MASK], and the softmax runs over the masks only.

The options are set at request time, so a new set of options needs no retraining. Whether the model is any good on a new kind of question is a separate matter, which I come back to below.

Note one difference from TypeSafe’s description. In this layout, the question and the state sit in one sequence, so the state is read again for every question. Jev’s docs say it ingests the state once.

The two open models also differ in one detail:

  • Laya is ModernBERT-large (395M) plus a decision head trained from scratch: 2 transformer layers, an option-marker scorer and an act/escalate head. It’s 421M in total. Its options share a fixed head budget, head_max_len. That’s 192 tokens for the English checkpoint, and 256 for the multilingual and typed-decisions checkpoints.
  • OpenDecider-nano is a ~400M Ettin encoder. Its author says it has no shared option budget, so “a 78-option question still gets every option in full”. The total context limit still applies.

The Laya card gives its own rule for the 256-token default: each label gets (256 - 16) // n tokens. Here is that rule as a curve.

Curve of tokens per option against the number of options for Laya's 256-token head budget, using (256 minus 16) divided by n. It is 80 tokens at 3 options and 3 tokens at 77 options.
At 77 options, each label gets 3 tokens of Laya's default budget.

On BANKING77, a 77-label intent dataset, the Laya card reports 0.425 at this default budget. It reports Jev at 0.870, but on 72 labels. The OpenDecider post reports 0.645 for nano, and its author puts the gap down to the budget. Both Laya and OpenDecider point to the budget. But the two models also differ in backbone and training data, so this comparison alone doesn’t prove the budget is the cause. The Laya card suggests raising head_max_len for questions with 50 or more options.

Why is it fast?

The slow part of an LLM is generating text, one token after another. None of these models do that. They give a few numbers per question.

Even a decoder can answer this way. OpenDecider-small, a 4B decoder, letters the options and reads the probability of each letter as the next token. For up to 26 options, that’s one forward pass with no generation. So the speed comes from skipping generation, plus using a small model. It isn’t about encoder against decoder. The cost isn’t flat either: more options and more questions mean a longer input.

The speed numbers below were measured in different ways, on different hardware, so they can’t be compared directly:

Model Latency Setting Source
Jev 70–500 ms end-to-end, from TypeSafe’s laptops launch post
Jev 236–276 ms p50, third-party Laya card
Jev 404 ms via API OpenDecider post
Laya (English) 39.5 ms one question, T4 Laya card
Laya (multilingual) 32.8 ms one question, T4 Laya card
Laya (typed-decisions) 21 ms hardware not stated OpenDecider post

Jev’s numbers include a network round trip, and the Laya numbers are local GPU runs. Read the table as orders of magnitude, nothing finer.

How is it trained?

TypeSafe calls its method Reinforcement Learning for Calibrated Decisions, or RLCD. The AI primer puts it next to RLHF and RLVR. RLHF trains for answers people prefer, RLVR for answers a program can check, and RLCD for calibrated probabilities. Calibrated means that across many answers given 0.8, about 80% are right. Wikipedia says Jev was trained only on synthetic data. TypeSafe hasn’t published how RLCD works.

Laya’s card describes its own version of RLCD:

  1. The model outputs a distribution over the options.
  2. For exploration, zero-mean Gaussian noise is added to the logits.
  3. The reward is a strictly proper scoring rule: the log score and the spherical score, plus the ranked probability score for ordinal questions.
  4. The update is REINFORCE with a group-mean baseline, like GRPO.

“Strictly proper” is the key part. With the log score, the reward is $\log p(\text{correct option})$. If you really believe an answer is right 70% of the time, your expected reward is highest when you report exactly 0.7. Saying 0.99 loses reward on average. So the reward pushes towards honest probabilities. It doesn’t guarantee calibration, though: a model can still be off on data unlike its training data, or when the labels are noisy.

OpenDecider skips RL and uses distillation. Two open teachers, Qwen3-235B-A22B-Instruct-2507 and DeepSeek V4.1 Flash, answered about 190K questions. Each teacher’s probabilities were temperature-scaled on held-out gold labels, then the two were averaged. The student learns to copy that averaged distribution.

How do they compare?

These are all reported numbers on the typed-decisions test set (2,000 decisions). The two sources disagree on Jev, so I list both.

Model Accuracy ECE Source
OpenDecider-nano 0.796 0.092 OpenDecider post
Laya (typed-decisions checkpoint) 0.766 0.162 OpenDecider post
Laya (typed-decisions checkpoint) 0.766 0.213 Laya card
Jev 1.13 0.754 0.164 OpenDecider post
Jev 1.13 0.727 0.144 Laya card

ECE is calibration error, so lower is better. Three caveats matter for this table:

  • Laya and OpenDecider-nano were both fine-tuned on this benchmark’s training split. Nothing public says Jev saw it. Laya’s base checkpoint gets 0.362 zero-shot, below the 0.461 majority-class baseline.
  • The Laya card gives a teacher self-agreement ceiling of 0.735, and says the fine-tuned checkpoint clears it. The test labels come from a teacher model, so none of these accuracies are against human ground truth.
  • On the OpenDecider post’s 200-question general set, Jev scores 0.730 and OpenDecider-nano 0.680. The author notes that set is about ±3 points, from single training seeds.

So on the task they trained on, the small open models come out ahead. On that small general set, Jev does better.

What I still don’t know

  • Whether Jev is an encoder, a decoder or a new kind of model.
  • What the “parallel sampler” is.
  • What RLCD’s loss is, and what synthetic data Jev saw.

The open models show that the same interface can be built with a ~400M encoder and option markers. They don’t show that Jev is built that way.

Support the writing

If this post helped, a coffee keeps the deep dives coming.

Buy me a coffee