I Rolled My Own Router. Then Jev Showed Up.

September 2026

Everyone is building routing intelligence right now. I'm no exception.

For the last month I've been running System One — my own attempt at a broker, not just a model. The thesis from my Week 4 piece still holds: your next infrastructure investment isn't a model, it's a broker. Something has to decide what goes where, what it costs, what gets verified, and what gets trusted.

Like everyone else, I started by rolling my own.

Mine was Kev — Kev-0.8B, local on a 3070 Ti. Its only job: screen JDs for negative-space filters and verify Hermes done-claims. Did the agent actually write the file, or did it just say it did?

Kev was too weak. That's not an insult, it's data from this week's pilot:

• fabrication rate (did_write on fake claims): Kev 0.776, Jev 0.130 — lower is better, and that's roughly 6x lower
• Kev was confident about things that never happened. That's fatal for verification.
• Exclusion bands were noisy, 0.59-0.77. Anything scoring above ~0.5 with bands that wide means the router abstains on nearly every JD — and a router that punts everything to a human isn't saving triage time, it's generating a to-do list. You can't route on that.

So I swapped in Jev — typesafe/jev-1.13 via OpenRouter, ~2e-5 per request — as the default backend for jd_screen.py.

Jev was nouls sharp: neg-JD excl 0.990, clean-JD fits 0.960, did_write 0.130.

Same harness, same JDs, same claims. Different routing decision.

This is why Jev has hit a chord, and why OpenRouter just put a Jev-powered router in front of their Auto Router — they're reporting 237 vs 130 tasks solved on their agent benchmarks. I haven't independently verified that number, but directionally it matches what I saw: a purpose-built decision model beats a general model guessing at routing.

One piece of a bigger broker

Here's the part we have to be honest about while we're all building this out: Jev is a portion of the routing intelligence needed for a full solution. Not the whole thing. A full broker still needs policy (who routes where), cost/latency tradeoffs (2e-5 is cheap until it's 10M calls), verification (the done-claim problem Kev failed), and memory (what did we decide last time and why).

Jev solves one core problem really well: reliable classification and decision so we don't all have to train our own Kev. That's huge. Every team rolling their own 0.8B classifier is burning weeks I just burned. But you still have to wire it into something. In my stack that's jd_screen.py plus the morning ritual plus Hermes. In yours it'll be something else.

Free-first, privacy-first

If you're rolling your own router right now, stop at the classifier layer. Learn from Jev's design — Choice, Noul, Score with calibrated probabilities — but think hard before you send it your best data. A buck a year isn't the cost; the data is. Every JD, CV, health note or wealth detail sent to a hosted decision API is free training and content for them. For a job search with no budget, that trade is not OK. Same for health, same for most wealth questions.

That's what I'm doing, with one hard line: pilot used OpenRouter Jev, but ops stays local. I'm watching Jev — someone will ship a free or close-to-as-good local decision model — and when they do I'll cut over. Until then: rules-first, local-first, receipts over prose.

Kev is retired as a judge. Jev is the reference design, not the dependency. The broker is still mine to build — and it runs on my LAN.

#AIRouter #AIAgents #LLMOps #PlatformEngineering