Sam Witteveen surveys seven open projects inspired by Jev and demonstrates how fast, structured decisions can run locally. These are independent Jev-style implementations, not a release of TypeSafe’s actual Jev weights. His comparisons are a snapshot of a rapidly changing ecosystem, with compute sponsored by Dell.

What makes the idea useful

  • Classification itself is old: BERT-family models and other text classifiers have long assigned labels to text. Witteveen argues that the useful shift is broad classification without retraining every time the labels change.
  • Earlier approaches framed classification as entailment: whether an input supports a candidate statement. His explanation for their limits is that smaller, older models lacked enough general knowledge to handle many different domains.
  • The practical question is what can leave an expensive reasoning model and become a quick yes/no decision, choice, or score.

Read the benchmark as a set of trade-offs

  • Witteveen uses JevBench, which combines intelligence, calibration, speed, and cost. Changing those weights changes the ranking; a high composite score is not the same as high accuracy on difficult tasks.
  • In the snapshot he shows, Jev leads the overall ranking and several open implementations come close. Reasoning models remain stronger on harder questions but carry latency and cost penalties.
  • He also criticizes what he describes as a restriction on comparative benchmarking in Jev’s terms of service. That is his account of the terms at recording time, not a legal assessment here.
  • The local demonstrations run on an NVIDIA RTX Pro 6000 Blackwell workstation. Their speed should not be read as a promise for ordinary laptop hardware.

SemIf: turn an existing model into a chooser

  • SemIf, originally called Open Jev, uses a frozen Qwen 3.5 4B model without additional training.
  • Put the question and answer options into the prompt, then read the model’s scores for the option tokens instead of generating an explanation. A softmax converts those scores into a distribution over the choices.
  • This reuses one pass over the prompt. Witteveen’s policy-check demo shows that changing the wording can move the model from uncertainty to a clear answer.
  • He presents this as the simplest starting point if you already run an open model. His suggestion that TypeSafe Jev may use a related approach remains an inference, not disclosure of Jev’s architecture.

Bespoke Nimble: teach the fact that flips the answer

  • Bespoke-Nimble-9B adds a LoRA—a small trained adapter—to Qwen 3.5 9B using fewer than 3,000 training examples. Witteveen notes the developers say they did not distill it from Jev.
  • Its contrastive training pairs differ in one decisive fact: a refund signed by the authorized person should pass; the same refund signed by someone else should fail.
  • He cites roughly 90% accuracy on the developers’ holdout set, versus roughly 66% for the base model and 93% for Jev, but only around 44% on JevBench’s hard tier. These are different evaluations, not interchangeable measures of quality.
  • His live approval-policy example exposes brittleness: changing “approval” to “pre-approval,” and explicitly stating that it occurred before the purchase, changes the results. The adapter is not uniformly better than the base model.

Decider: a small server with a familiar API

  • Mapika’s Decider projects hidden states at answer slots onto the available options rather than simply reading ordinary output-token scores.
  • Witteveen describes a smaller Qwen-based model with a 32K context window and a response format compatible with TypeSafe’s API.
  • His support-ticket example asks about department, urgency, escalation, and frustration together. The demo averages around 33 milliseconds per answer in one repeated run on his hardware.
  • Speed is the attraction; uncertainty is a caveat. He finds Decider frequently assigns middling confidence where Jev is more decisive. Confidence alone, however, is not evidence that an answer is correct.

Alex Wortega’s OpenJev: choices from images

  • Alex Wortega’s OpenJev builds on the entailment approach and accepts images.
  • Witteveen checks statements about a payment-error screenshot, including whether the retry button is green or blue, and shows the scores changing with the statement.
  • He highlights Doom and Minecraft examples in which the model chooses among available actions. The useful abstraction is the same: provide observations and a constrained action set rather than asking for free-form text.

DiffusionGemma: throughput with a larger model

  • The DiffusionGemma implementation takes a different route: a denoising step followed by reading probabilities at answer slots.
  • In his ticket-routing demo, it handles a batch of 16 tickets quickly, answering questions about team assignment, urgency, and customer sentiment.
  • Witteveen is impressed by its throughput but questions some urgency judgments and says clearer instructions could change them.
  • This is a 26B model, not a tiny classifier. He distinguishes its speed from the smaller hardware footprint of other projects and describes its general capability as less mature than some comparably sized models he has tested.

NanoJev and Laya: how small can the classifier be?

  • NanoJev is a 600-million-parameter model. His Snake demo supplies a grid and directional choices; it plays successfully for a while before running out of safe moves.
  • Laya uses ModernBERT-large at about 420 million parameters. Witteveen describes multilingual support, multiple structured questions in a single forward pass, and a Colab demo running on a T4 GPU.
  • Laya also illustrates the difference between rediscovering a useful technique and inventing classification. Witteveen discusses its developer’s earlier work while noting that Jev remains substantially stronger when the benchmark emphasizes accuracy.

Choose by workload, then escalate the hard cases

  • For no-training experiments, try SemIf-style scoring on a model you already have. For a small TypeSafe-compatible server, consider Decider.
  • For a narrow policy task, adapt Nimble’s contrastive-data recipe to your own examples. For images, investigate Wortega’s implementation or Decider’s vision variant.
  • Witteveen’s main limitation is hard reasoning: multi-step inference and date arithmetic remain difficult across these open alternatives.
  • His proposed design is a cascade: let the fast model handle ordinary decisions, then send uncertain cases to a reasoning model. The open projects are closer than he expected on easy and standard cases, but they have not erased the gap on hard ones.