8 Open-Source Alternatives to the Jev Model You Can Run Yourself

Let me as you a question, what if your AI application didn’t need another chatbot? 

Imagine an agent receiving a support ticket. It doesn’t need an essay. It needs to answer:

Traditionally, developers reach for an LLM, ask it to return JSON, parse the response, handle malformed output, and hope the model’s confidence means something.

Jev takes a different approach.

TypeSafe AI describes Jev as a System One model give it a state and typed questions, and it returns structured decisions such as a choice, score, or yes/no probability.

But there’s a catch, Jev is closed-weight and hosted.

That has created an interesting open-source ecosystem around the same idea. I went through eight projects that explore different ways to reproduce, approximate, or specialize in the Jev-style decision model.

A normal LLM works roughly like this:

A Jev-style system changes the architecture:

Instead of giving the statement like, “Read this ticket and explain which department should handle it.”

you ask:

The model only needs to select among those options.

That makes these models particularly interesting for routing, classification, scoring, guardrails, ranking, tool selection and agent control loops.

Now let’s look at the open-source alternatives.

GitHub: TheoLeeCJ/SemIf

SemIf is one of the most interesting approaches because it doesn’t try to reproduce Jev’s undisclosed architecture.

SemIf uses open models and extracts typed option probabilities directly rather than generating an answer sentence and parsing it afterward.

The project targets consumer hardware, including an RTX 3090-class GPU, and also provides browser/WebGPU experimentation.

The architecture is surprisingly simple:

For developers experimenting with local AI agents, this makes SemIf particularly interesting as a practical starting point.

Model: Bespoke-Nimble-9B on Hugging Face
Recipe: Bespoke Nimble GitHub

Bespoke Nimble is arguably one of the most educational projects in this space. Instead of only publishing weights, Bespoke Labs published:

Nimble is a LoRA fine-tune of Qwen3.5–9B designed for typed decisions. It supports choice and boolean-style decisions and returns probabilities for the allowed answers.

The interesting part is the contrastive data curation technique.

The training examples deliberately modify facts so that changing a small piece of information can flip the correct decision.

The authors report 90.12% on their 324-example holdout, compared with 93.21% for Jev 1.13.0 on that particular evaluation. They also explicitly note that the evaluation is narrow and synthetic.

That caveat matters. A benchmark result is not the same thing as general intelligence. But the project gives developers something even more valuable a recipe for building their own decision model.

GitHub: Mapika/decider

If you want a more complete System One research project, Decider deserves attention.

Its philosophy is straightforward “Don’t generate text. Make a decision.”

Decider supports typed choices, scores and yes/no-style decisions, with models ranging from 0.8B to 35B parameters.

The 2B model is built on Qwen3.5–2B, while the larger model uses Qwen3.5–35B-A3B.

It also includes:

That’s important because the project isn’t simply:

It explores the entire decision-engine stack.

For engineers interested in calibration, inference performance and production architecture, Decider is particularly useful to study.

Model: AlexWortega/openjev on Hugging Face

This project takes another route. Instead of turning an LLM into a generic choice engine, openjev fine-tunes Qwen3.5 into an NLI-style cross-encoder.

Its fundamental operation is:

The model card describes applications including reranking, grading, content guarding and game decision-making.

The newer 4B version also explores vision-based decision-making and game environments such as Doom and Minecraft.

This is an important architectural idea.

Sometimes your application doesn’t need “Choose option A, B or C”, it needs “Does this candidate logically follow from the current state?”

That’s essentially an NLI problem.

And that primitive can become a surprisingly powerful building block.

GitHub: TianyuCodings/NanoJev
Model: NanoJev on Hugging Face

The name gives away the idea. NanoJev is a 0.6B decision model.

It uses a Qwen3–0.6B backbone with dedicated decision heads and produces probability distributions over supplied candidates without output-token decoding.

The project is especially interesting because it publishes the whole pipeline:

Its current unified model covers:

The authors report 128/128 successes for the Basic ViZDoom test and 27/128 for Predict Position on their matched test setup.

Those numbers should be treated as project-specific experimental results, not proof that NanoJev is universally better than Jev.

But the engineering lesson is more interesting A decision model doesn’t necessarily need billions of parameters.

For narrow, well-defined control loops, a small specialized model can be extremely compelling.

GitHub: NandhaKishorM/laya

Laya takes the idea in a different direction multilingual, non-autoregressive decision making.

It provides multiple checkpoints, including:

and supports more than 100 languages according to the project documentation.

The API exposes typed questions such as:

That makes Laya interesting for applications such as:

The project also focuses heavily on low latency and batch inference.

If your application needs local, multilingual decision infrastructure, Laya is a particularly relevant project to investigate.

GitHub: OpenSourceJev

OpenSourceJev goes even closer to the hardware. The project describes itself as a local System One research experiment powered by llama.cpp and Qwen.

Its goal is to transform open-weight models into deterministic, strictly typed decision engines.

The architecture is roughly:

The interesting part is that the system works at the logit level rather than relying on generated text.

That makes it useful for developers interested in:

It is more of a research implementation than a polished enterprise platform, but that’s exactly why it is worth reading.

Model: sales-conversion-model-reinf-learning on Hugging Face

This one needs an important clarification. It isn’t a general-purpose Jev replacement.

It is a specialized decision model for sales conversations.

The project uses reinforcement learning and PPO to predict sales-conversion outcomes from conversation data. Its model card describes synthetic training data containing more than 100,000 sales conversations and reports an 85ms inference time in its own evaluation.

This illustrates an important alternative to building a general Jev clone:

For example:

For a sales platform, that may be more useful than a general-purpose decision engine.

The projects also differ considerably in what their benchmarks actually demonstrate. For example, NanoJev’s headline numbers come from specific game environments, while Bespoke Nimble’s reported holdout is a narrow synthetic evaluation. Laya publishes its own performance measurements and limitations, while SemIf emphasizes reproducibility and direct scoring rather than claiming to reproduce Jev’s undisclosed training.

So don’t treat a single leaderboard number as the answer.

This is the part I find most interesting. For years, we treated every AI problem as:

Then developers started wrapping that text in JSON.

System One-style models suggest another architecture:

That’s a fundamentally different way of thinking about AI engineering.

Your LLM can remain responsible for:

while a small decision model handles:

The future AI stack may not be one giant model.

It may be a collection of specialized models, each responsible for a very specific cognitive primitive.

Don’t choose based purely on benchmark numbers. Choose based on your workload.

Start with SemIf or NanoJev.

Study Bespoke Nimble.

Look at Decider.

Look at Laya.

Try OpenSourceJev.

Explore openjev.

The Sales Conversion Model is the more focused approach.

Jev introduced an interesting idea AI doesn’t always need to talk. Sometimes it just needs to decide.

The open-source community is now exploring that idea from several directions:

None of these should automatically be described as the open-source Jev. Jev’s internal architecture and training remain proprietary. What these projects provide are open implementations of the broader System One / typed-decision pattern, each with different trade-offs.

And that’s arguably more exciting than a single clone. Because now developers can experiment with the architecture themselves. The interesting question isn’t “How do I replace my LLM?”

It’s:

That’s where Jev-style models become genuinely interesting.

Benchmarks for this all models: https://benchmarkheaven.com/jev-models

I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.