Open Jev alternatives: which parts of Jev the open projects actually match

Rizzo Flow says code written for TypeSafe can point at localhost and keep POST /v1/systemone, while Laya says it answers choice, score and noul questions in one forward pass at 33 ms on a T4.

That is the practical answer to “open Jev alternatives” in the sources provided here. If you want the same HTTP shape as Jev, Rizzo Flow is the project that states that claim directly. If you want a small, non-autoregressive decision engine with published routing, batching and reload numbers, Laya documents that stack in far more operational detail. Jevlike is a research starter for one-pass option scoring rather than a service clone, and the cited OpenJev excerpt only supports one hard fact: the published safetensors total 89.1 GB on disk.

Rizzo Flow mirrors Jev’s endpoint, while Laya mirrors Jev’s typed primitives

TypeSafe’s public API is concrete about what Jev is: a POST /v1/systemone endpoint that takes a state, a required model field and a map of typed questions, then returns structured answers and token usage. The same API reference defines three native question types, noul, choice and score, and the models page says every model there is served by that same endpoint.

Rizzo Flow matches that developer contract most directly in the sources here. The repository says it gives you the same programming model on your own hardware, says code written against the TypeSafe API can point at localhost by changing one URL, and shows a local curl example against /v1/systemone with state, model and questions in the same broad shape as TypeSafe’s docs.

Laya matches Jev’s decision primitives more clearly than its HTTP contract. The repository says it evaluates typed questions of type choice, score and noul over text or structured state in a single forward pass, and it documents a router that selects among English, multilingual and typed-decisions checkpoints per request. That is close to Jev’s “state in, typed decisions out” model. What the cited Laya excerpt does not document is a Jev-compatible HTTP endpoint.

Jevlike is narrower. Its repository says it trains a small model that chooses among a changing list of text options, returns one probability per option in one pass, and is an independent starter model rather than a copy of Jev. That makes it relevant if your workload looks like Jev’s choice primitive. It does not, in the cited excerpt, claim a full Jev-style service interface.

The supplied OpenJev excerpt does not give enough evidence to classify it the same way. From the public record provided here, we can support a weight-size estimate from the published files, but not a claim about native primitives, API shape or feature parity with Jev.

So the clean answer is narrower than the original draft. For a local endpoint that looks like Jev, the cited evidence points to Rizzo Flow. For a documented typed-decision engine with explicit choice, score and noul semantics, the cited evidence points to Laya. For one-pass option scoring research, it points to Jevlike.

The compact comparison: licence, openness, release date and Jev-style features

The table below keeps to what the cited excerpts actually state. Where a page does not state a licence, a release date or a feature in the supplied the public record, the cell says so rather than guessing from repository names or page layout.

Source: project pages linked in each cell. “Not stated” means the information does not appear in the supplied excerpt for that page.

Laya and Rizzo Flow publish application timings; the OpenJev excerpt does not

Laya publishes measured T4 timings for the exact decision loop it describes. The repository says one English question on the English checkpoint takes 39.5 ms, one question on the multilingual checkpoint takes 32.8 ms, 10 multilingual questions batched take 72.3 ms, and 50 multilingual questions take 337 ms, or 6.8 ms per question. It also says batched throughput reaches 103 to 332 questions per second on one T4.

Those numbers come with an operational caveat that matters more than the single-query figure. With the default max_loaded=1, the router rebuilds a model on every language switch, and the same page reports a 7.4 s median reload on CPU and 10.3 s on T4. Preloading avoids that. If you are comparing open Jev alternatives for production routing, that reload behaviour is not a footnote. It is the difference between a fast hot path and a broken latency budget.

Rizzo Flow publishes a simpler number. The repository says its Snake demo made 140 moves in 25.6 seconds, or about 5.5 decisions per second, which it translates to about 150 ms per decision round trip on an RTX 5060 Ti with Spark-X2.5-4B at 8-bit and 0 generated tokens. The same sentence adds that the recording used an earlier MLX runtime and that today’s llama.cpp runtime is about 1.8 times faster per decision.

Jevlike publishes a narrower speed claim. Its repository says that, at eight options, one pass was about 100 times faster than a small decoder forced to write 400 tokens, but it also says those numbers describe local experiments rather than the quickstart run and do not show equal quality with Jev.

TypeSafe says Jev response time is 70 ms to 500 ms and prices Jev 1.13 at $0.042 per million input tokens. That is the commercial baseline. The open projects here are not sold on the same basis, and no public source provides a controlled head-to-head run on identical hardware and workloads.

The supplied OpenJev excerpt does not publish an application timing at all. It supports a footprint estimate from posted weight files, but not a Jev-style latency claim. That absence matters because the query here is not “which project exists” but “which project is an alternative.” Alternatives are judged on the interface and timings you can actually verify.

OpenJev is heavy on disk, while Rizzo Flow is packaged for a local download path

FuturPulse’s calculation from the published OpenJev files puts the repository’s safetensors at 89.1 GB on disk. That is the only weight-size figure in the public record for OpenJev, but it is enough to show the project is a large download before you say anything about serving, quantisation or hardware.

Rizzo Flow publishes the full local-footprint story. Its default 4B GGUF is 4.4 GB at q8_0, 2.6 GB at q4_k_m and 8.2 GB at bf16, while its smaller 1.7B option is 1.8 GB at q8_0, 1.1 GB at q4_k_m and 3.4 GB at bf16. The same repository says the llama.cpp runtime download is about 570 MB with CUDA, 30 MB with Vulkan and 11 MB on a Mac.

Laya publishes parameter counts rather than weight-file sizes. Its three checkpoints are 421 million parameters for the English model, 322 million for the multilingual model and 421 million for the typed-decisions model, and the repository says you can preload all three into memory for sub-35 ms routing or manage them under LRU eviction with max_loaded.

Source: project pages linked in each cell.

Laya publishes routing evidence and a concrete failure case; Rizzo Flow is explicit about uncalibrated probabilities

Laya gives the most detailed benchmark table in the supplied open-source the public record. On a shared benchmark of 17,416 questions on one T4, the English checkpoint scores 0.783 on MASSIVE intent in English and 0.860 on English XNLI, while the multilingual checkpoint scores 0.451 on MASSIVE across 13 other languages and 0.731 on XNLI across 14 other languages. The repository’s routed row says the router preserves the best score in each lane and reaches 45 usable languages out of 51 by its >3x-random criterion.

The same page also publishes the failure case that makes the router matter. It says the English checkpoint scores 0.000 accuracy at 0.952 confidence on Khmer, which means the model is confidently wrong enough that simple confidence gating will not rescue the pipeline. That is a useful disclosure because it tells a buyer where the system breaks, not just where it looks good.

Laya also states that its probabilities are trained with strictly proper scoring rules through RLCD and are intended to be statistically meaningful for confidence gating. That is still a project-authored claim, but it is at least paired with a concrete benchmark table, a published bad case and deployment guidance about routing and preload.

Rizzo Flow is more conservative on quality claims. The repository says it does not reproduce Jev’s proprietary architecture or RLCD training, that probabilities are uncalibrated unless you calibrate them on your own data, and that it makes no claim of matching Jev or SemIf in quality. For readers who want an open local API and will do their own evaluation, that candour is useful. For readers who want a drop-in quality replacement, it is also a warning.

Jevlike is equally direct about being a research starter. The repository says that, in the experiments leading to the starter, a frozen Qwen2.5-0.5B encoder plus the scorer reached 26% on target-disjoint Wikispeedia next-click data, against about 8% for shuffled and random-encoder controls, while a small model trained from scratch on 40,000 clicks reached 29%. The same page says the starter is not a copy of Jev and did not reproduce TypeSafe’s private training method.

TypeSafe’s own Jev evidence remains vendor-authored. The company says the headline gains of 193.6 times faster and 444.6 times cheaper come from workflow evaluations that use the average of GPT-6 Astra and Fable 5.1 as the reference answer, and the same post concedes that the workflows were made by people on its model capabilities team. That does not invalidate the results, but it does set the standard for how much independent evidence is still missing across the whole category.

Setup friction is low for Rizzo Flow, simple for Laya, and explicit for Jevlike

Rizzo Flow documents the shortest end-to-end local setup in public sources. It requires Python 3.11 or newer, git and uv, then uses four commands to clone the repository, sync the environment, download the runtime and model, and start the server. The same quickstart says nothing is compiled and no GPU toolkit is installed.

Astral says uv is 10 to 100 times faster than pip and can replace pip, pip-tools, pipx, poetry, pyenv, twine and virtualenv. That is a vendor claim, not an independent benchmark here, but it explains why multiple repositories in this comparison use uv as the installer of record.

Laya’s install path is simpler on paper. The repository says pip install laya is enough and that Python 3.10 or newer is required because huggingface_hub 1.x, transformers 5.x and torch 2.14 all require 3.10. The trade-off is that the interesting operational choice comes later, when you decide whether to preload checkpoints or accept multi-second reloads on language switches.

Jevlike also uses a direct local workflow. Its quickstart creates a virtual environment with uv venv, installs the package with uv pip install -e '.[dev]', then trains, evaluates and runs predictions from the command line. That is fine for experimentation, but it is not presented as a local Jev-compatible HTTP service.

Rizzo Flow also publishes hardware notes that matter in practice. The repository says rizzo download picks an official prebuilt llama.cpp package for your machine, checks its sha256, and supports CUDA, Vulkan, Metal and CPU builds, with current README numbers taken from Windows 10 plus an RTX 5060 Ti. That is not the same as broad cross-platform benchmarking, but it is more concrete than the “just works locally” language that often appears around open inference projects.

The incentives behind the claims are mixed, and the sourcing should be read that way

The current search results for “open Jev alternatives” mix a closed vendor, open repositories and research starters. Their incentives are not the same, and the article should not flatten them into one tier.

What we could not verify?

We could not verify a single best “open Jev replacement” from the supplied the public record because there is no public head-to-head benchmark where TypeSafe Jev, Laya, Rizzo Flow, Jevlike and OpenJev answer the same typed-decision workload under the same hardware, batching and calibration rules.

TypeSafe has not published Jev’s architecture in the cited API docs, so no open project can claim design parity on public evidence alone. TypeSafe’s models page says GET /v1/models returns a release_date field, but the supplied excerpt does not give the current release date value for Jev 1.13 itself.

The cited Laya excerpt does not publish exact checkpoint file sizes or an explicit software licence. The cited Rizzo Flow excerpt states that the project is open-source and has open weights, but the excerpt supplied here does not show its licence text. The cited OpenJev excerpt supports only the 89.1 GB safetensors total; it does not, in the supplied the public record, support claims about architecture, benchmarks, primitives, API compatibility, licence terms or release date. The cited Jevlike excerpt includes the MIT licence but not a release date.

Rizzo Flow’s repository says its probabilities are uncalibrated unless users calibrate on their own data. Laya says its probabilities are meaningful for confidence gating because of RLCD training, but that claim still comes from the project itself. The next useful step for all of these projects would be a shared benchmark harness, fixed workloads, fixed hardware notes and published traces.