Sixteen open-source Jev alternatives and what each one does

TL;DR

• Laya
• Kev
• GLiNER2.5-Decide
• JevK5
• GLiFormer large-v1
• PlayJev
• SemIf
• NanoJev
• jevlike
• simple-jev
• AnyJev
• mini-jev
• open-jev (nico-martin)
• minojev
• Open-Jev (Zefan-Cai)
• open-jev (daseinlabs)

Jev takes a state and a set of questions, then returns short typed decisions: a choice, a score, or a number. In my Codex subagent router, that decision helps choose the model and reasoning level for the next agent. The projects below include local servers, training tools, and even a model trained on game frames. Similar names hide quite different jobs.

Laya

Laya makes several typed decisions in one pass. It has a Python library and a local server with a Jev-compatible HTTP interface. Its English and multilingual checkpoints make the latter relevant when a routing summary is written in another language. It also supports batching. I would still test accuracy and calibration on my own Codex tasks before relying on its choices.

Kev

Kev provides a family of open models at different sizes and a local /v1/systemone endpoint. Its README suggests starting with 4B; larger versions need substantially more memory. This is a direct candidate for replacing a remote decision engine when local compute is available. The published measurements describe the author’s tests, not Codex subagent routing.

GLiNER2.5-Decide

GLiNER2.5-Decide classifies text with labels supplied at inference time. The English checkpoint has 340M parameters; there is a 1B version and a 287M multilingual version. GLiNER2’s AutoExtractor.classify_text() can answer several classification heads in one pass without generating text. A Codex router needs an adapter because this is not the Jev System One API.

JevK5

JevK5 is a project separate from Kev, based on Qwen3.5-4B. It reads option probabilities from logits with the SemIf protocol, and its local server provides /v1/systemone. Speed and accuracy on real Codex assignments need separate measurement.

GLiFormer large-v1

GLiFormer large-v1 is a 575.6M-parameter DeBERTa-based model. It classifies text using supplied labels and also extracts entities, relations, and structured data. Its classification head could route text tasks, but the Python API needs a Jev adapter.

PlayJev

PlayJev chooses actions in browser games from a frame and a list of legal moves. It returns choice probabilities through /v1/systemone, but the input is visual and game-specific. Choosing an agent for a text search would need a different model or new training. Its value here is showing how typed decisions can work on images.

SemIf

SemIf, previously OpenJev, reproduces the decision format with open language models. It reads option scores from logits and can run with PyTorch, MLX, or llama.cpp. Its CLI accepts JSONL, so Codex needs an adapter. It is a way to test local routing without a dedicated decision checkpoint, although starting the model for every request may erase a latency gain.

NanoJev

NanoJev uses a small Qwen backbone with heads for choices, booleans, and scores. The repository includes weights, data, training code, and a local /api/evaluate server. Its released model was trained mostly on game tasks. Whether those decisions transfer to Codex task descriptions remains an open measurement.

jevlike

jevlike is closer to a research kit. It can train a small byte encoder or score arbitrary text options with a frozen Hugging Face encoder. Training and prediction run from a CLI. There is no demonstrated result for distinguishing an exact file lookup from difficult diagnosis in Codex, but the project gives you a way to build and test that classifier with your own examples.

simple-jev

simple-jev turns the logits of a compatible open language model into a typed decision instead of generating JSON. Its Transformers and PyTorch server exposes /v1/classifier and a /v1/systemone alias. The answer depends on the underlying model and wording of the options; its scores are not automatically calibrated probabilities of success. It is convenient for trying a model you already run locally.

AnyJev

AnyJev offers three levels for adapting an existing language model: position-bias correction without labels, temperature calibration, and a fitted head on hidden states. Later levels need examples from your own work, and the head requires access to internal model states. This fits a router tuned to a known task mix. The simplest mode may require multiple model passes, so measure its latency.

mini-jev

mini-jev compares logit-based option scoring on a frozen Qwen model against grammar-constrained JSON generation. It is more of a teaching and benchmark project than a ready production router. Its scores rank options but do not guarantee calibrated probabilities. It helps expose when short decisions save work and when, for example with a simple boolean, that advantage disappears.

open-jev by nico-martin

nico-martin’s open-jev runs typed decisions in the browser with Transformers.js and WebGPU or WASM. Its TypeScript API is OpenJev.load().decide(), and it supports several models, including Kev variants. This is useful for local decisions inside a web app. Codex needs a Node bridge, and the first run has to download model weights.

minojev

minojev pairs a frozen Qwen3-1.7B model with a small trainable decision head. It serves typed questions through local /score, publishes weights and data, and can run on a CPU. Its authors also report a drop on an out-of-distribution task. I would evaluate it on actual Codex assignments before using its published metric to route agents.

Open-Jev by Zefan-Cai

Zefan-Cai’s Open-Jev publishes trained 2B, 9B, and 27B variants with a decision head and calibration. It has a local /v1/systemone server, data, and training tools. Of the three similarly named projects here, this one looks most like a ready model family; runtime cost varies substantially with size. Its benchmark results still need checking against subagent routing tasks.

open-jev by daseinlabs

daseinlabs’ open-jev scores options on Gemma 3 4B, reusing a shared prefix and batching work. It offers local /score and /v1/systemone endpoints, MLX on Mac, PyTorch on other platforms, and optional task-specific head training. Gemma weights require accepting access terms on Hugging Face. It is a practical Mac experiment if you already have local inference running.

The fast-decisions benchmark

On the GLiNER2.5-Decide model card, Fastino reports exact-match accuracy on fast-decisions: 17 English domains with 300 held-out examples each. Every model received the same text and candidate labels. These are the publisher’s results, not my independent evaluation.

The public dataset files contain 100 development examples per domain; these scores refer to a separate held-out set. They do not establish routing accuracy on my Codex tasks or on Russian input.

Choosing one for Codex

For a local endpoint with a familiar format, I would start with Laya, Kev, JevK5, simple-jev, or one of the server-based Open-Jev projects. NanoJev, jevlike, AnyJev, and minojev are more interesting if I want to train for my own assignments. SemIf and mini-jev help examine the mechanics of a short decision. PlayJev targets visual games. GLiNER2.5-Decide and GLiFormer are classifiers to try with a separate adapter.

My Codex Jev Router supports several of these engines through adapters. Protocol compatibility alone does not establish equal accuracy or savings. Before swapping engines, I would measure the full decision time and cost, routing mistakes, and the cost of the agent that follows. I do not yet have a public comparison of all sixteen on my own task mix.