Open-source alternatives to Jev, and what each one actually replaces

TypeSafe released the System One model Jev on 15 September 2026 without weights or a description of its training method, and by 23 September an independent tracker listed 33 open-source alternatives, according to systemonemodels.org. The projects fall into four groups: trained small encoders such as ConvAI Innovations' Laya (Apache 2.0, about 19,800 GitHub stars, 322M-421M parameters), LoRA-plus-decision-head builds on Qwen bases including Jared Palmer's Kev (about 5,600 stars) and Zefan Cai's Open-Jev, zero-training logit readers such as TheoLeeCJ's SemIf at openjev.com (MIT, about 4,000 stars), and special-purpose tools like ZTC-Judge-9B. None is a drop-in replacement for all of Jev, and Bespoke Labs' Nimble had no licence file as of 23 September.

Open-source alternatives to Jev, and what each one actually replaces TypeSafe released Jev https://stackness.dev/tools/typesafe-jev on 15 September 2026 without weights and without describing its training method. People replicated it anyway, and fast. By 23 September, one independent tracker https://systemonemodels.org/examples/alternatives/ listed 33 entries, general-purpose libraries included. The short answer to "what are the open-source alternatives to Jev?" is Laya, Kev, SemIf the project at openjev.com , Open-Jev, Nimble and a few narrower tools. The useful answer is that they are four different kinds of project, and none of them is a drop-in replacement for all of Jev. Our explainer https://stackness.dev/blog/what-is-a-system-one-model-and-where-does-it-go-in-your-stack covered what a System One model is and where it sits in a stack: beside your LLM, taking the small, frequent, typed decisions. This piece is for the next question. If you want that slot filled by something you can run yourself, which project fills it, and what does it cost you? What open-source alternatives to Jev exist? Here are the projects worth knowing as of 23 September 2026, grouped by what they actually are. Star counts come from the GitHub API on that date. Trained small encoders. Not LLMs at all, just a fine-tuned text encoder with a decision head. - Laya https://laya.convaiinnovations.com/ by ConvAI Innovations. Released 18 September. Apache 2.0 code and weights, about 19,800 stars. Three checkpoints on ModernBERT and mmBERT bases, 322M to 421M parameters. It supports the same Choice, Score and Noul primitives, and the README https://github.com/NandhaKishorM/laya says its HTTP server takes a "schema-identical" payload at /v1/systemone . LoRA plus a decision head on a Qwen https://stackness.dev/tools/qwen base. A small open LLM, frozen, with a trained adapter and a head that reads the answer from its hidden states. - Kev https://github.com/jaredpalmer/kev by Jared Palmer. Released 17 September. Apache 2.0, about 5,600 stars. Checkpoints at 0.8B, 4B and 9B on Qwen3.5. It is built to be trained on your own data, and its README says you can "point their Python SDK at your local server". - Open-Jev https://github.com/Zefan-Cai/Open-Jev by Zefan Cai. Released 20 September. MIT code on Qwen3.5 2B, 9B and 27B bases. It states plainly that it does not reproduce TypeSafe's training method, weights or data. - Nimble https://github.com/bespokelabsai/nimble by Bespoke Labs. Released 18 September. A 9B Qwen3.5 fine-tune with tooling for curating contrastive training pairs. The repository had no licence file on 23 September, so check before you ship it. - NanoJev https://github.com/TianyuCodings/NanoJev by TianyuCodings. Released 17 September. MIT, Qwen3 0.6B with decision heads, trained on four games including Doom. A readable training pipeline, not a general model. Zero-training logit readers. No new weights. They ask an existing open model the question and read the answer straight from its next-token probabilities. - SemIf https://openjev.com/ , formerly OpenJev, by TheoLeeCJ. Released 16 September, the earliest of the lot. MIT, about 4,000 stars. It runs Qwen3.5 4B and smaller models on a 3090, on a CPU through llama.cpp https://stackness.dev/tools/llama-cpp , or entirely in a browser tab over WebGPU. The only one here that needs no install. - open-alternative-jev https://github.com/ikermoel/open-alternative-jev by ikermoel. A small Apache 2.0 library that does the same thing on any ChatML model through Transformers https://stackness.dev/tools/hugging-face-transformers or vLLM https://stackness.dev/tools/vllm . It says outright that it is "not a drop-in API" for the Jev SDK. Special-purpose tools. They share the name, but the job is narrower. - ZTC-Judge-9B https://huggingface.co/FINAL-Bench/ZTC-Judge-9B , a verifier that scores whether an answer can be trusted. It is not a general decision engine. - laya-ultrafast https://github.com/ipenywis/laya-ultrafast , a port of browser-use https://stackness.dev/tools/browser-use 's Jev-powered web agent with Laya swapped in for the hosted calls. One naming warning. "OpenJev" refers to at least three unrelated projects this week, and "Open-Jev" with a hyphen is a fourth. Search by author, not by name. Which System One models can you run on Apple Silicon today? Laya, Kev, SemIf and Nimble all run on a Mac. The Laya route is the most finished, largely thanks to one pseudonymous Hugging Face publisher, aac6fef, behind the laya-mlx package, a Core ML conversion for the Neural Engine and the MLX weights the browser agent uses, all within four days. - laya-mlx https://github.com/mizorewww/laya-mlx is an independent port of all three Laya checkpoints to Apple's MLX https://stackness.dev/tools/mlx framework. It reports a 13.4 ms median for one short question on the 421M checkpoint on an M3 Max, and 7.4 ms on the 322M one. It matches upstream on all 63 test fixtures, and its README adds that this "measures fidelity on those fixtures, not accuracy". More launch pages should say that. - Laya on Core ML https://stackness.dev/tools/core-ml runs on the Neural Engine following a setup gist https://gist.github.com/fordnox/e592d0f68b543fd044be8e6d040863a0 for an M4. It reports memory use, about 560 MB, and no latency figure. - Kev runs on MLX. Five questions over a 270-token state took 149 ms on Kev-0.8B and 721 ms on Kev-4B on an M5, or 136 ms for 4B when the state is cached. - Nimble runs on MLX but wants about 64 GB of RAM for its 9B weights. It reports 444 ms per question on an M5 Pro. - SemIf runs through MLX or in the browser, the latter with uncalibrated scores. Can you train your own decision model, and on what base? Yes, and this is the clearest thing the open projects offer that Jev does not. TypeSafe trains the model and you write the questions. The open projects let you do both. Kev is the most complete answer: a rank-16 LoRA adapter and a pointer head on a frozen Qwen3.5 base, a training script that starts from its released checkpoints, and a parity harness. Open-Jev and Nimble follow the same pattern on Qwen3.5 2B to 27B. Nimble's real contribution is data. It builds training pairs that differ in exactly one fact, so the model learns which fact decides the answer. Laya ships a fine-tuning notebook that runs on a free Kaggle pair of T4s. NanoJev https://stackness.dev/tools/nanojev is the smallest end-to-end pipeline, and the one to read if you want to understand how it works rather than ship it. If your decisions are specific, like "is this ticket a refund request under our policy", a few hundred of your own labelled cases will probably matter more than which base you pick. The zero-training readers are the fastest way to find out whether you need to train at all. What do the latency claims actually measure? Different things each time, and no comparison page has said so. Each headline number is honest on its own terms. None can be compared with another, or with Jev's. - Jev, 70 to 500 ms. End to end over the network, from TypeSafe's launch post https://typesafe.ai/blog/introducing-system-one-models-and-jev . No hardware, input size or batch is stated. - Laya, 33 ms. One question on the 322M multilingual checkpoint on a T4 GPU. The English checkpoint takes 39.5 ms. The 0.766 accuracy figure on the same landing page comes from a third checkpoint, the 421M typed-decisions one, which runs at about the English speed. Input length is not stated. - laya-mlx, 13.4 ms. One short question on an M3 Max, including tokenisation and calibration, excluding model load. - Kev, "tens of milliseconds". Five questions on an H100 or MI300X. - SemIf, 1.02 seconds. All 21 questions about one state on an RTX 3090, against 5.33 seconds for the same model writing JSON. That is about 49 ms per decision, not per call. - Nimble, 106 ms. One question on an H100. - Open-Jev, 85 ms against 295 ms for Jev. Measured against the live Jev API on a customer service case. On a harder case the order flips: 1,016 ms against 301 ms. A local forward pass on a datacentre GPU and an HTTPS round trip are not the same measurement. If latency is why you are looking, the only number worth having is your own. Take your state, your question count and your hardware, and time the whole call, including whatever it takes to get the state into the model. What do you give up when you swap Jev for an open model? Mostly calibration, context length and someone else's pager. In return your data stays where it is, there is no waitlist, the weights are yours to fine-tune, and the bill is your hardware. Calibration is the big one. Jev's pitch is that when it says 60 percent it means 60. The open projects mostly fit a single temperature on their own development data, and they say so. Kev's README is unusually specific: served Kev-9B puts 0.9 or more probability on a wrong answer 4.0 percent of the time against Jev's 3.7, and the share of decisions you could automate at a 5 percent error budget is 0.45 to 0.57 against Jev's 0.70. That second number is the one that decides whether a human still reads the output. open-alternative-jev says its readings are "not calibrated out of the box". Laya's model card says it "ships over-confident", and its English checkpoint answered Khmer text with 0.0 accuracy at 95 percent confidence. That is a checkpoint mismatch, not a scandal, but it is the kind of wrong answer a threshold will not catch. Context and edge cases come next. Kev trains on at most 384 tokens of state, and says changing the order of options can change the answer. Laya's accuracy drops sharply past 50 options. Nimble caps prompts at 2,048 tokens. Jev's own limits are unpublished, which is not the same as having none. Operations are yours. Kev's server handles one request at a time. No project promises uptime, and none of the accuracy comparisons against Jev were run by anyone other than the project's own author. Several ran against live Jev, which is more than many benchmarks manage, but it is still homework marked by the student. Which slot in a stack does each alternative fit? The slot is the same one Jev fills: a fast, typed checkpoint beside an LLM that does the open-ended work. That is the Stackness move Use a fast small decision model instead of an LLM call for structured filtering and scoring https://stackness.dev/moves/use-a-fast-small-decision-model-instead-of-an-llm-call-for-structured-filtering-and-scoring-2 , which tags Claude Code https://stackness.dev/tools/claude-code and Jev. What differs is which part of the slot each project covers. - High-volume routing and filtering, local or multilingual: Laya https://stackness.dev/tools/laya , and laya-mlx https://stackness.dev/tools/laya-mlx on a Mac. The smallest models here, with the most careful speed numbers. - Decisions that depend on your own rules: Kev https://stackness.dev/tools/kev , then Open-Jev https://stackness.dev/tools/open-jev or Nimble https://stackness.dev/tools/bespoke-labs-nimble . Pick these when you have labelled cases and are willing to train. Kev is the only one that claims the TypeSafe SDK works against it. - Finding out whether you need a decision model at all: SemIf https://stackness.dev/tools/semif or open-alternative-jev https://stackness.dev/tools/open-alternative-jev . No training, any open model, and SemIf runs in a browser tab. - Checking another model's answer: ZTC-Judge, which ranks and thresholds answers rather than making decisions. - Driving a browser agent: laya-ultrafast, which still uses an LLM to write the text. Most of these projects joined the Stackness catalog on 23 September 2026 with no listings yet, and Jev itself has one as of that date: the founder's. When profiles start adding them, the tool pages will show who keeps which one next to what. Until then, a GitHub star count is not an install base, and we will not treat it as one. Key numbers - 15 September 2026 is when TypeSafe announced Jev https://typesafe.ai/blog/introducing-system-one-models-and-jev , with no weights and an unpublished training method. - 16 September 2026 is when the first open replication, SemIf, appeared, one day later. - 33 entries were listed by systemonemodels.org https://systemonemodels.org/examples/alternatives/ by 23 September, general-purpose libraries included. - About 19,800 GitHub stars for Laya https://github.com/NandhaKishorM/laya on 23 September, five days after release. - 0.822 against 0.857 is Kev-9B against Jev on Kev's new-source development set, measured by Kev's author https://github.com/jaredpalmer/kev . - 4.0 percent against 3.7 percent is how often Kev-9B and Jev put 0.9 or more probability on a wrong answer. - 1 Stackness user lists Jev as of 23 September 2026, the founder, so the number carries no signal yet Stackness, September 2026, see data sources https://stackness.dev/about/data-sources . Quick answers Is Jev open source? No. TypeSafe has not released Jev's weights or described its training method, which it calls RLCD. Jev is a hosted API in early access. What is the best open-source alternative to Jev? It depends on the job. Laya for fast local routing, Kev if you want to train on your own data and keep the TypeSafe SDK, and SemIf to test the idea with no training in a browser tab. Can I run a Jev alternative on a Mac? Yes. laya-mlx runs every Laya checkpoint natively on Apple Silicon, at about 13 ms per short question on an M3 Max. Kev, Nimble and SemIf also support MLX. Is any open model a drop-in replacement for Jev? Kev and Laya both claim their servers accept the TypeSafe request format. Neither matches Jev's calibration out of the box, and no independent test of the compatibility claims has been published. Are the open models calibrated? Partly. Most fit one temperature on their own development data, which helps in distribution and less elsewhere. Kev-9B is confidently wrong 4.0 percent of the time against Jev's 3.7. Are the latency numbers comparable? No. Laya's 33 ms is one question on a T4 GPU, SemIf's 1.02 seconds covers 21 questions on a 3090, and Jev's 70 to 500 ms is a network round trip. Time your own workload.