Kev is an open-source family of small decision models built on Qwen3.5 (0.8B, 4B, and 9B variants) by Jared Palmer. Instead of generating text, it takes a document plus a set of typed questions and returns a probability distribution for each answer in a single forward pass. It's an open reproduction of TypeSafe's closed 'Jev' decision model.

How is a decision model different from a normal LLM?

A normal LLM autoregressively generates tokens to produce free-form text. A decision model is prefill-only: it reads the input once and reads out calibrated probabilities for pre-defined questions (yes/no, multiple-choice, rating). No decoding loop, no parsing JSON out of prose — just numbers you can threshold.

Why does answering multiple questions in one pass matter?

You send one document and N typed questions and get N probability distributions back from a single forward pass. That's dramatically cheaper and lower-latency than N separate LLM calls, and the outputs are structured probabilities rather than text you have to coax and parse.

Can I actually run Kev myself?

Yes — that's the point. Kev ships weights, a training recipe, evaluation, and a fine-tuning script (usable with Modal). The Qwen3.5 family was reportedly ported for about $95 of H100 time. The original 0.5B prototype was trained on a laptop. Repo: github.com/jaredpalmer/kev.

Kev: An Open-Source Decision Model That Answers, Not Generates

By Prahlad Menon Published 2026-09-23 3 min read

The AI naming game has officially jumped the shark. There’s a closed-source decision model called Jev (from TypeSafe), so naturally someone built an open-source clone and named it Kev. Before GTA 6, after everything else. 💀

Jokes aside, Kev — from Jared Palmer — is one of the more interesting small-model releases in a while, precisely because it doesn’t do the thing every other model does.

It answers questions. It doesn’t write essays.

Almost every model you touch is a generator: give it a prompt, it autoregressively emits tokens until it decides to stop. Great for chat, code, and prose. Miserable when all you actually want is a decision.

Kev is a decision model. You hand it one document — Palmer calls it “the state” — and a set of typed questions:

Yes/No: “Does this support ticket describe a billing problem?”
Multiple-choice: “Which category best fits this document: A, B, C, or D?”
Rating: “On a 1–5 scale, how urgent is this?”

It returns a probability distribution for each question in a single forward pass. No text generation. No prompt-engineering the model into emitting clean JSON. No regex salvage operation on the output. Just calibrated numbers you can threshold and route on.

Why this design is a big deal

The efficiency story is the headline. If you have a document and ten questions about it, the generator approach is ten LLM calls (or one big call and a fragile parse). Kev does all of them in one prefill-only pass — read the input once, read out ten distributions. That’s a different cost curve entirely.

Architecturally it’s lean. The original prototype was a LoRA adapter plus a small pointer head on top of a frozen Qwen base — the 0.5B version was literally trained on a laptop to prove the mechanism works. The current family moves to Qwen3.5 bases at 0.8B, 4B, and 9B, found through roughly 110 controlled training trials, with the bigger checkpoints scoring meaningfully better on out-of-domain transfer.

And it’s genuinely yours. The release includes:

Open weights across the three sizes
A documented training recipe and evaluation suite
A fine-tuning script you can run (e.g., with Modal)

Reportedly the whole Qwen3.5 port cost about $95 in H100 time. That’s not a typo — an open, reproducible decision-model family for less than a nice dinner.

Where you’d actually use it

Decision models shine anywhere you’re currently abusing a chat LLM as a classifier:

Content moderation — is this safe / spam / policy-violating? With a probability, not a vibe.
Ticket & email routing — category + urgency in one shot.
RAG pre-filters — is this chunk actually relevant before you spend tokens on it?
Structured extraction gates — cheap yes/no checks before an expensive pipeline stage.
Eval harnesses — score model outputs against rubric questions at scale.

Because the outputs are calibrated probabilities, you get something a generator never really gives you cleanly: a confidence you can set thresholds on, tune precision/recall against, and log for drift monitoring.

The bigger pattern

Kev is part of a quiet but important trend: stop making one giant generalist do everything. For a huge class of production tasks you don’t need eloquence — you need a fast, cheap, confident decision. Purpose-built small models that emit structured probabilities beat a 400B-parameter chat model reluctantly returning {"answer": "yes"} on both latency and cost.

The name is ridiculous. The idea is not. If any part of your stack is currently a general-purpose LLM cosplaying as a classifier, Kev is worth a look.

🔗 github.com/jaredpalmer/kev