Jev is TypeSafe’s hosted System One model for typed decisions. A request combines application state with choice, score, or noul questions, and Jev returns probabilities that code can use directly for routing, policy checks, agent actions, and other bounded decisions.
TypeSafe serves Jev through a hosted API and does not publish a downloadable checkpoint. Teams that need local inference, private infrastructure, CPU or Apple Silicon deployment, multimodal input, or custom training need another model for that decision step. The ten projects below are current open-source Jev alternatives for that job.
Last updated: November 10, 2026.
Quick Picks by Deployment Need
- Keep an existing TypeSafe Python client: Kev-4B is the clearest starting point. The local server matches the System One request format, and the TypeSafe SDK connects after a base URL and model change.
- Run on a laptop CPU with no Python server: jevos-v5 ships as a native OpenVINO binary and also publishes GGUF files for llama.cpp.
- Use a smaller multimodal model: pplx-decider-flash-v1.2 is a 4B text-and-image decision model, and Perplexity publishes a 5.16 GB Q8_0 GGUF build for local runtimes.
- Run on Apple Silicon: Laya has a native MLX port for the compact checkpoints. Vega-backed readers handle longer text and multimodal inputs.
- Reuse an existing open LLM: AnyJev can score declared options with a model you already run. Tacit and Tacitus provide dedicated decision checkpoints.
- Use audio, images, or video in the decision: Clef-omni accepts all three media types through the Jev/System One request shape.
- Return boxes or video tracks as decision outputs: d3-ultra adds
BoxandTracktasks on top of typed decisions.
Quick comparison
| Project | Best for | Deployment |
|---|---|---|
| Cloudflare Clef family | Jev-compatible multimodal decisions, including audio with Clef-omni | Workers AI or self-hosted GPU |
| Perplexity pplx-decider | 27B and 4B text-and-image decision models with joint multi-question requests | CUDA, Flash GGUF, or Decisions API |
| Laya | Fast multilingual decisions plus optional long-context and multimodal readers | CPU, GPU, or Apple Silicon |
| Kev | System One compatibility plus trainable Qwen decision models | CUDA/ROCm or Apple Silicon |
| Decision 3.0 | Multimodal decisions, boxes, and video tracking | GPU or hosted Decision 3.0 API |
| AnyJev / Tacit | Training-free option scoring or dedicated Tacit checkpoints | Transformers or vLLM |
| Base Labs decision models | 2B, 9B, and 27B open decision models with text and image input | CUDA GPU or Baseten API |
| Bespoke Nimble | Open training recipe plus current 27B Nimble-v4-max | NVIDIA GPU or Apple Silicon for the 9B local scorer |
| Mapika Decider | System One models from small GGUF builds to larger image-capable checkpoints | CPU, CUDA, Apple MPS, or Metal |
| jevos | Native CPU deployment with Jev wire compatibility | CPU native binary or GGUF |
Best Open-Source Jev Alternatives
1. Cloudflare Clef family
Cloudflare’s Clef family keeps the Jev/System One request format and expands the input types a decision model can read. Clef uses Qwen3.8-27B, Clef-flash uses Qwen3.5-9B, and Clef-omni uses Qwen3-Omni-30B-A3B. All three return probabilities for declared choice, score, and noul answers through a Jev/System One-compatible API.
Clef and Clef-flash can decide over text, JSON, images, and video. Clef-omni adds native audio. One support request can combine a message, an attached image, or a call recording with several typed questions, such as which team should handle it, how urgent it is, and whether a policy condition is met. The questions share one state and are scored together.
Cloudflare serves Clef on Workers AI and publishes open weights for self-hosting. Clef and Clef-omni use 64K-class context windows, and labeled decision data can be used for RL fine-tuning. Clef-flash moves the family to a 9B backbone for lower GPU requirements. The 27B and omni checkpoints need substantially more memory.
License: Apache-2.0
2. Perplexity pplx-decider v1.2 / Flash v1.2
Perplexity’s pplx-decider-v1.2 and pplx-decider-flash-v1.2 turn text or images into typed probabilities. The larger model uses Qwen3.8-27B, Flash uses Qwen3.5-4B, and both support choice, noul, and score questions with large declared option sets.
The latest version can evaluate several related questions in one joint request. Each question sees the shared state and the other questions, letting related decisions use context from the full request. Reranking and tool selection need independent requests for competing candidates, since grouped candidates can influence one another.
The 27B checkpoint needs about 52 GiB for BF16 weights plus working memory. Flash needs about 9 GiB in BF16, and Perplexity also publishes a 5.16 GB Q8_0 GGUF build with a 672 MB vision projector. A fitted temperature calibrates the returned probabilities, and raw readout logits are available for ranking workloads.
License: Apache-2.0
3. Laya
Laya combines compact non-autoregressive decision models with Vega-backed readers for larger inputs. The compact line includes a 421M English checkpoint, a 322M multilingual checkpoint for 100+ languages, and a 421M typed-decisions checkpoint. Laya’s Router selects a compact checkpoint from the request language, and the HTTP server exposes Jev’s POST /v1/systemone wire format.
The compact checkpoints handle ordinary text classification and routing. For longer or multimodal inputs, laya.Agent(vegaml=True) uses Vega-backed readers that accept text up to 73,728 tokens plus images, audio, and video. Responses can include a conformal prediction set, abstention, out-of-distribution detection, and an auto or review route for uncertain cases.
Batch scoring processes many states against one question set, and labeled data can be used to fit a small per-question head with the reader kept frozen. Laya runs on CPU or GPU and also supports ONNX, TypeScript, an MCP server, and framework integrations. Laya-MLX runs the compact checkpoints natively on Apple Silicon.
License: Apache-2.0
4. Kev
Kev is built around a direct TypeSafe-style migration. The local server implements the System One request format. A TypeSafe Python client can keep the existing choice, score, and noul definitions after the base URL and model name are changed.
Kev 1.0 includes 0.8B, 4B, 9B, and 27B checkpoints. The 0.8B, 4B, and 9B models use Qwen3.5 bases. Kev-27B uses Qwen3.8-27B. Kev-4B is the recommended starting checkpoint. CUDA and ROCm serve the GPU models, supported Apple Silicon Macs use MLX, and the 27B release stores about 51 GB of weights for high-memory GPUs.
Every released checkpoint includes probability calibration. Kev can also cache a state and reuse it when later requests ask more questions about the same document. The 0.8B, 4B, and 9B checkpoints are validated to 8,192 tokens in the current tests. Kev-27B is validated to 65,536 tokens. Teams with labeled decisions can fine-tune a released checkpoint, fit a new calibration temperature, evaluate it on held-out data, and serve the resulting model through the same System One endpoint.
License: Apache-2.0
5. Decision 3.0: d3-ultra / d3-turbo
d3-ultra and d3-turbo treat typed decisions as a multimodal task. A request can combine text or JSON with images and video, ask several questions about the shared state, and return probabilities directly for choice, yes/no, and score answers.
Decision 3.0 adds Box and Track to the typed-decision API. Box locates an object in an image or a video frame. Track follows an object through video and reports visibility over time. Images can also appear inside a question or inside the answer options, supporting tasks such as matching one image against several visual candidates.
The larger models read the state once and reuse that representation across multiple questions. d3-ultra supports up to 131,072 tokens per question, and d3-turbo can also reach 131,072 tokens in long-context mode. Smaller d3-flash, mini, nano, lite, and edge checkpoints reduce the GPU requirement for simpler workloads. Open weights support local GPU deployment, and the hosted Decision 3.0 API provides another serving path. The Semantic Router runtime can expose the decision models through a System One-compatible endpoint.
License: Apache-2.0
6. AnyJev / Tacit
AnyJev supports two routes for typed decisions from open language models. The training-free Decider reads the probabilities an existing model assigns to declared options. Tacit uses dedicated self-distilled checkpoints from 1.7B to 9B for one-pass bounded decisions.
L0 is the no-training mode for an LLM that is already deployed. It rotates option order and corrects label bias before reading the option probabilities, reducing preferences tied to position or answer tokens. Tacit uses dedicated one-pass checkpoints. With adaptive=True, low-margin decisions can be escalated to the model’s reasoning mode and scored again, with a rolling cap controlling how often that slower path runs.
AnyJev also publishes the larger Tacitus 31B fine-tune. The training-free and Tacit paths support choice, yes/no, and ordered score decisions. They run through Transformers, in-process vLLM, or an existing vllm serve deployment. An optional HTTP gateway adds POST /v1/decide, batch requests, and runtime statistics.
License: Apache-2.0
7. Base Labs: joey-1 / elephant-1 / mammoth-1
Base Labs publishes three Qwen-based decision models: joey-1 at 2B, elephant-1 at 9B, and mammoth-1 at 27B. They read text plus optional images and answer several typed questions about the shared state, returning calibrated probability distributions directly.
The schema supports a choice among as many as 255 named options, a yes/no probability, or an ordered score with 2 to 10 levels. One shared state can feed several questions in one model pass, letting a document or image be classified, scored, and checked against several conditions together. The current releases use a 16,384-token maximum sequence length.
joey-1 keeps the model size down, elephant-1 moves to a 9B backbone, and mammoth-1 uses 27B for the highest-capacity checkpoint in the family. The weights are downloadable for local GPU inference, and Base Labs also serves the models through Baseten APIs.
License: MIT
8. Bespoke Nimble
Bespoke Nimble is a text-focused decision model that takes text plus a flat schema and returns probabilities for choices, boolean decisions, and ordered scores. The local scorer returns only the schema-defined answers and their probabilities, keeping the output bounded to the options defined by the caller.
The downloadable Bespoke-Nimble-9B supports up to 8,192 tokens and as many as 255 choices in an enum field. It runs on NVIDIA GPUs and Apple Silicon. Bespoke Labs also serves newer checkpoints through the Nimble API: Nimble-v4 is the current 9B default, and Nimble-v4-max 4.1 uses a 27B Qwen3.8 fine-tune for higher-capacity inference. The hosted API accepts up to 64 questions in one request and up to 32,768 prompt tokens per question.
The original 9B release includes contrastive training data, a held-out set, scoring code, evaluation tools, calibration work, and a LoRA training path. Your team can use that material to retrain the decision model, audit the scoring pipeline, or compare a custom checkpoint against the released weights.
License: Apache-2.0
9. Mapika Decider
Mapika Decider uses one Jev-style serving layer across a wide model family. The server accepts choice, score, and noul questions through /v1/systemone, with checkpoints that include 2B, 4B, 12B, 31B, and 35B-class variants.
The small end of the family is designed for local deployment. The 2B and 4B checkpoints are available as GGUF files for llama.cpp, with Q4_K_M builds of about 1.3 GB and 2.7 GB. Larger checkpoints move to GPU inference, and current 2B, 4B, 12B-vision, and 31B releases can also answer questions about images.
Decider returns bounded probabilities directly. Choice questions can define up to 255 options, score questions use ordered levels, and yes/no questions return a probability. Training code, datasets, calibration tools, model cards, and evaluation utilities are included for building and checking custom decision checkpoints.
License: Apache-2.0
10. jevos
jevos is built for Jev-style decisions on a normal laptop CPU. jevos-v5 ships as a native binary with 8-bit OpenVINO weights and also publishes GGUF files for llama.cpp.
The HTTP server speaks TypeSafe Jev’s wire format and supports yes/no, multiple-choice, and score questions. Several questions can share one text state, which the server reads once before producing the individual probability distributions.
A text cache speeds up later decisions about material the server has already read. The native server uses about 1 GB after loading the model and roughly 1.4 GB with the cache full. On an Intel Core Ultra 7 255H, jevos-v5 reports about 30 ms for a short request and 132 ms for a long request.
License: MIT
Switching from Jev to a local model
Migration is simplest when the replacement keeps the System One request format. Clef, Laya, Kev, Decision 3.0, Decider, and jevos provide Jev/System One-compatible serving layers. Kev has the most direct TypeSafe Python SDK migration in this list. Perplexity, AnyJev, Nimble, and the downloadable Base Labs models use their own APIs, libraries, or serving layers.
After the client is connected, validate the replacement model on held-out examples from your own traffic before reusing production confidence thresholds.
For example, with Kev-4B running at http://127.0.0.1:8009 and the TypeSafe SDK installed, the client below keeps the existing question definition and points it at the local server:
from typesafe_sdk import Noul, TypeSafeClient
client = TypeSafeClient(
api_key="local",
base_url="http://127.0.0.1:8009",
model="kev-latest",
)
result = client.system_one(
state="Refund the duplicate charge.",
questions={
"billing": Noul(
instructions="Is this a billing issue?"
)
},
)
print(result.nouls["billing"].noul)FAQs
Is Jev open source?
No. Jev is a hosted TypeSafe model, and TypeSafe has not published the model weights. The projects in this list provide open weights, source code, or both for running Jev-style decisions outside TypeSafe’s hosted service.
Can Jev itself run locally?
No public Jev checkpoint is available for local deployment. Running locally means choosing a different decision model such as Kev, Laya, Clef, Decider, jevos, or another open alternative and adapting the client when required.
Which alternative is easiest for an existing System One client?
Kev is the most direct option for the TypeSafe Python SDK: change the base URL and model name, then keep the existing question definitions. Clef, Laya, Decision 3.0, Decider, and jevos also expose Jev/System One-compatible endpoints. Their model names, server configuration, and probability behavior differ.
Which Jev alternatives run on CPU or Apple Silicon?
For CPU-first deployment, jevos ships as a native OpenVINO binary, and Decider publishes small GGUF checkpoints for llama.cpp. Laya also has CPU inference. On Apple Silicon, Laya-MLX runs the compact Laya checkpoints natively, Kev has MLX configurations for smaller checkpoints, Bespoke Nimble runs on Apple Silicon, and Decider can use Apple MPS or llama.cpp with Metal.
Are the benchmark scores directly comparable?
Only when the models were evaluated on an identical benchmark version under comparable conditions. The projects use the Jev Decision Index, JevBench, project-specific test sets, and vendor-run evaluations, and several suites have changed over time. Treat each result as evidence for the tested model and version, then validate the finalists on your own labeled decisions.
Related Jev resources
- The Ultimate Jev Resource List: SDKs, Agents, MCP Servers & More
- 10 Jev Use Cases: Real Projects & Demos
Changelog
November 10, 2026: Added Perplexity pplx-decider v1.2 / Flash v1.2 and AnyJev / Tacit. Updated Clef-omni, Laya Vega, d3-ultra, Base Labs joey-1, Nimble-v4-max 4.1, Mapika Decider, and jevos-v5.
October 26, 2026: Replaced Laya-MLX, NanoJev, and jevlike with Decision 3.0, Base Labs decision models, and Mapika Decider.
