Kev: Open-Source Jev Clone Brings Decision Models to Your Own Hardware

TypeSafe AI's Jev model, with its sub-500-millisecond decision times and near-zero output costs, has stirred significant interest in the AI community. But for developers who prefer to keep their data and inference on their own infrastructure, a new open-source project is closing the gap. Kev, created by Jared Palmer, is a family of small decision models built on Qwen3.5 that replicates Jev's architecture and API, offering a practical path to running these efficient classifiers locally.

The project, which has already attracted over 1,300 GitHub stars, provides pretrained models in three sizes—0.8B, 4B, and 9B—along with training code and a frozen evaluation suite. All weights are released under the permissive Apache-2.0 license, and the API is designed to mirror TypeSafe's System One interface, meaning developers can point TypeSafe's Python SDK at their own Kev server without modification.

What Makes Kev Different

Kev's core innovation lies in how it handles structured decision-making. Instead of generating text tokens, the model performs a single forward pass and reads logits for allowed options only. This approach, shared by other Jev clones, eliminates the need for autoregressive generation, making decisions dramatically faster and cheaper. On a single RTX 3090, for example, SemIf—another Jev clone—answers 21 yes/no criteria in 1.023 seconds, compared to 5.332 seconds for a generative approach.

Kev extends this concept with a flexible question format. A single request can include three types of questions: noul (yes/no), choice (multiple-choice), and score (rating). All questions share the same input text but are isolated from each other, preventing cross-contamination of information. This is achieved through careful attention masking or, for Qwen3.5's hybrid architecture, by running each question as an independent row with shared state caching.

Performance and Hardware Requirements

The models are designed to run on consumer hardware. The 4B and 9B variants can fit on a 32GB Mac using bf16 precision, though performance varies significantly by platform. On an Apple M5, a five-question request with a ~230-token state takes about 779ms for Kev-4B, while the 9B model takes roughly 2 seconds. CUDA users with H100 GPUs see much faster results, with requests completing in tens of milliseconds.

For developers needing low latency on Apple Silicon, the previous Qwen3-based models remain available and are significantly faster, though they are no longer actively developed. An MLX backend for the Qwen3.5 models is listed as the next planned change.

Accuracy and Calibration

Kev's evaluation results show promising accuracy, particularly on new, unseen data sources. Kev-9B achieves 0.812 accuracy on development sets and 0.837 on test sets for new sources, trailing hosted Jev by about 4.5 points. The model also demonstrates strong calibration on these tasks, with a Brier score of 0.291 on development data.

However, the project is transparent about its limitations. Probabilities are not well-calibrated on new sources—Kev-4B assigns at least 0.9 probability to a wrong answer on 8.2% of questions. Fine-tuning can also degrade base model capabilities, particularly date arithmetic and knowledge-based tasks, where Kev-9B scores 0.74 on MMLU compared to Jev's 0.90.

Training and Customization

One of Kev's most compelling features is the ability to fine-tune models on custom data. The released checkpoints were trained on a mix of public datasets and generated policy examples, but users can easily adapt them to their own domains. A short fine-tune on a few hundred labeled examples often yields significant improvements over prompt engineering alone.

The training process uses LoRA adapters with rank 16 and a small pointer head, keeping the base Qwen model frozen. This approach is efficient enough to run on a single H100 via Modal, with the 4B model training in about an hour. The project also includes a --init_from flag that lets users start from a released checkpoint, preserving existing knowledge while adding new domain expertise.

The Growing Jev Clone Ecosystem

Kev is part of a broader movement to replicate Jev's architecture. Other notable projects include SemIf (2,685 stars, built on Qwen3.5-4B), jevlike (1,122 stars, with a byte-level encoder), and openjev (240 stars, built on DiffusionGemma). Each takes a slightly different approach, but all share the core principle of reading logits directly rather than generating tokens.

The rapid emergence of these clones highlights a growing demand for efficient, locally-runnable decision models. For enterprises concerned about data privacy or inference costs, Kev offers a viable alternative to hosted services. The project's Apache-2.0 license and public evaluation suite also make it an attractive foundation for further research and development.

Getting Started with Kev

To begin using Kev, developers need Python 3.12+ and the uv package manager. The setup process is straightforward:

git clone https://github.com/jaredpalmer/kev.git && cd kev
uv sync --extra serve
KEV_DTYPE=bf16 uv run --extra serve python -m kev.serve --run jaredpalmer/kev-4b --port 8009

Once the server is running, sending a support ticket with multiple questions returns structured probabilities for each decision. The playground, built with Next.js, provides a visual interface for testing different question formats and option orders, including a chess demo that showcases the model's decision-making capabilities.

Kev represents a significant step toward democratizing access to efficient decision models. By providing open weights, transparent evaluation, and the ability to fine-tune on custom data, it empowers developers to build and deploy AI-powered decision systems on their own terms.