Does Jev really have a threshold? OpenJEV has already split into 4 factions: it's easy to not speak out, but having reliable probabilities is very difficult.

Beating AI News Flash: Less than a week after Jev's release, the open-source community has already begun replicating this "don't write answers, directly give probabilities" model.

They all want to do the same thing: skip token-by-token generation and directly output options and probabilities. But how exactly to do it has already split into several completely different approaches.

1. SemIf is the simplest — it doesn't even require retraining the model. It directly takes an off-the-shelf Qwen, intercepts it when the model is about to answer A, B, C, prevents it from continuing to write, directly reads the score for each option, and converts them into probabilities.

2. Simple Jev also uses an off-the-shelf large model, but further eliminates redundant computation. The same passage is read only once, and subsequent multiple questions share that result, then each answer is judged separately. The author also explicitly states that it replicates Jev's usage pattern, but has not achieved equivalence in accuracy, speed, or probability calibration.

3. Laya simply doesn't use a text-generating large model, switching instead to an encoder model more like a traditional classifier. The advantage is that it's small and fast, but the shortcoming is also obvious. When choosing from 77 options at once, Laya's accuracy is only 42.5%, while Jev's is 87.0%.

4. Von also takes the dedicated decision model route. It has only about 400 million parameters, doesn't generate text, and completes Choice, Noul, and Score in a single forward pass — more like a next-generation classifier that can read natural language.

5. Verdict is even smaller, with only about 150 million parameters. The author focuses on addressing two problems: reporting high confidence even when the answer is wrong, and results changing when the order of options is shuffled. It cares more about how to stabilize both probabilities and judgments.

6. Kev chooses to keep the large model. It uses Qwen as the base, adds a dedicated decision structure, so that the same input is read only once, and multiple questions each compute their own probabilities. When third parties previously reverse-engineered Jev, they also speculated that it might use a similar design.

In Kev's self-testing, using new questions not seen during training, the 8B version achieved about 78% accuracy, while Jev was about 86%. The more obvious gap is in confidence — Kev still gives over 90% confidence on some questions it answers incorrectly.

7. Nimble focuses on training. It uses Qwen3.5-9B, then prepares a batch of data where "changing just one fact flips the correct answer" for post-training. Among 324 test samples not involved in training, Nimble selected the reference answer 90.1% of the time, while Jev was 93.2%. However, the author also cautions that it cannot yet guarantee that when the model reports 90%, it is actually 90% correct.

8. OpenJev went the furthest, directly switching to DiffusionGemma. It first leaves several answer positions blank, then fills them in all at once like a diffusion model completing an image. On an RTX PRO 6000, the median latency for a single request is about 94ms.

After a few days, OpenJEV has already split into four paths: directly reading the answer scores of off-the-shelf models, training dedicated decision models, transforming large models into decision models, and using diffusion models to directly fill in answers.

Jev's route looks very easy to copy. What truly creates the gap is still accuracy, generalization, and probability calibration. When a model dares to report 90%, how trustworthy that 90% actually is, that is the hardest part.