Most of the bots I build are novelists forced to work a turnstile. You wire up a chat model, hand it a question with four possible answers, and it writes you three paragraphs of reasoning before committing to “B” — then occasionally commits to “B) probably, though it depends.” You parse it. You regex it. You add a retry. You add a schema validator. You add a fallback. And somewhere along the way the thing you actually wanted, a decision, got buried under prose you never asked for.
That is the itch decision models are scratching, and it’s why jaredpalmer/kev hit 370 points and 164 comments on Hacker News within a day of going up. Kev is a small family of decision models built on top of Qwen3.5, described as Jev-like but trained differently, shipping at 0.8B, 4B, and 9B parameters, released in 2026, and designed so you can train and run it on your own hardware.
Why the parameter counts matter more than the benchmarks
I want to be careful here, because the reporting around this whole category has been messy. explainx.ai openly admitted that its own coverage of six Jev clones shipping inside 48 hours was assembled from digest headlines with no primary source to check against. That’s a confession worth respecting. So I’m not going to pretend I have verified scores in hand. What I have is a repo, a size range, and a stated goal.
The size range alone tells you who this is for. 0.8B is a model you can hold in memory next to everything else your bot is doing. 4B is the size where quantization gets you onto consumer GPUs without drama. 9B is the ceiling where you’re still not renting anything by the hour. If you build bots for a living, you already know that the difference between a 9B you own and a frontier API you rent isn’t just cost. It’s latency you control, failure modes you can reproduce, and a version number that doesn’t change underneath you on a Tuesday.
What “decision model” actually changes in your architecture
The framing from Tonbi’s AI Garage, in a September 2026 video covering Jev, is that it gives up free-form text. That tradeoff is the entire pitch. When your model’s output space is constrained to a choice rather than a paragraph, several layers of your stack get to retire:
- No output parser guessing at where the answer starts
- No prompt scaffolding begging for JSON that arrives malformed one time in fifty
- No temperature roulette on a task that has exactly one correct shape
- No token budget spent on reasoning you throw away
In my experience that last one is underrated. A routing step in a bot pipeline gets called constantly. Classify the intent, pick the tool, decide whether to escalate, decide whether the retrieved chunk is relevant. Each of those is a decision wearing a chat interface as a costume. Paying generation costs for them adds up, and every extra token is another chance to wander off.
The local training part is the actual story
“Train and run on your own” is doing more work in that repo description than the parameter counts are. Running a small model locally has been table stakes for a while. Training one on your own decision data, on your own machine, is the part that changes how you build.
Routing decisions are extremely domain-specific. What counts as an escalation in a support bot for developer tooling is not what counts as an escalation in a bot for scheduling. A general model has to be talked into your taxonomy through prompt engineering, forever, on every call. A small model you can retrain gets your taxonomy baked in once. That’s the difference between renting judgment and owning it.
The repo also carries planning docs, including notes tracking work against MMLU-Pro figures. I’d read those as a developer’s working notebook rather than published results, which is roughly how you should read most active planning files. If you’re evaluating Kev for something real, the honest move is to test the 0.8B and 4B checkpoints against your own routing set and ignore everyone’s headline numbers, including mine.
How I’d approach it this week
My plan is unglamorous. Take a bot I already run, find the cheapest decision in the pipeline, and log a few thousand real inputs with the choices my current setup makes. Then fine-tune the 0.8B on that log and see whether the small model matches its much larger teacher on the narrow task. If it does, that’s one less API call per turn and one less thing that can return prose when I wanted a label.
Six clones in 48 hours means the category is moving faster than anyone can verify. That’s a reason to test rather than a reason to wait. Small, local, retrainable models are cheap enough to evaluate that skepticism costs you nothing but an afternoon.
🕒 Published: