Stop hiring geniuses to guard the door.

If you’re into orchestration, you’ve probably absorbed one assumption along with the rest of the field: more powerful models make orchestration more possible. I held it for a long time too. The research I’ve been doing for months says it’s half right, and the people I’ve talked to lately keep landing on the same correction. Bigger models are better at writing, at planning, at holding a messy problem in mind. On small decisions they’re slower, more expensive, and no more reliable — and they overthink.

Here’s the part that gets missed. An orchestrator spends most of its decision budget not writing. It gates. Is this request allowed? Which tool should handle it? Does the draft match the constraint we wrote down? Is this input a prompt injection wearing a support ticket? Those are questions with a short list of options and one right answer, asked hundreds of times per run. That’s classification. Paying frontier-token prices to sort mail never made sense.

The industry noticed before I did. On September 15, TypeSafe AI launched Jev, a model that doesn’t generate text. You hand it a state and typed questions; it returns choices, scores, or yes/no answers with calibrated probabilities. TypeSafe reports up to 200× faster inference and 400× lower cost than comparable LLMs on classification work, and says Jev was the fastest-adopted launch in Vercel’s AI Gateway history. The company was founded in 2024 and raised a $40 million seed round led by DCVC. Since then the pattern has spread: OpenAI launched a Decisions API of its own — now generally available, powered by GPT-6 Luna, Cloudflare shipped Jev-compatible models under the name Clef, and llama.cpp has served the same wire format since early October.

Jeff is the open version. It speaks Jev’s request format but isn’t affiliated with TypeSafe — it began as a fork of AutoJev, Denis Yarats’ open recipe for the same idea. The 0.8-billion-parameter model takes a situation and a list of options in plain words and returns a calibrated probability for every option in a single forward pass. No generated text, nothing to parse. The options don’t need to appear anywhere in its training data. The code is MIT, the weights are Apache 2.0, and it runs on your own hardware — about two gigabytes of GPU memory, next to the 28.6 the 27B in the comparison below needs.

The numbers are why I’m writing this today. On eight tasks, with the same held-out test rows handed to both systems, a Qwen3.8-27B making every decision scored 86.6% at 8.1 seconds per decision. Jeff with the matching adapter scored 94.6% at 0.25 seconds — eight points better and 35 times faster. Keep the 27B around as a fallback for the cases Jeff flags as uncertain, and the mean climbs to 95.0%. On prompt-injection detection, the gate that matters most for enforcement, the 27B scored 84.0% and Jeff scored 98.7% in seventy milliseconds. On seven of the eight tasks, not one query needed the 27B. On grounding — does this answer match its sources — Jeff passed 11% of the queries upstream, which is the design working: the small model knows when it isn’t sure, and it escalates only those.

Now the honest part, because these are vendor-published numbers and I read the methodology. The 27B ran with step-by-step reasoning off, on one Mac, against fixed samples of held-out rows; the team publishes the per-row data and a reference app that rebuilds the comparison. Jeff doesn’t reason. On the BBH reasoning benchmark the published 0.8B number is 63.2 against Jev’s 94.3; on JevBench’s hard tier, 44.8. Inputs cap at 8,192 tokens, English only. It’s a gate, not a brain.

That profile is exactly what rule enforcement needs. Last week I described what happens when a big model obeys complicated rules: the failures concentrate on conflicting input, and the model never announces them. A calibrated gate turns that from a mystery into a threshold. Rules and constraints require a gate that is fast, cheap, and calibrated — calibrated meaning the confidence score is honest, so you can set a threshold and route everything below it to the big model. One user ran Jeff with two adapters on an 8 GB laptop GPU at 144 to 274 milliseconds per decision. And the pattern already pays at the system level: Jeff-Code, a coding agent that routes routine information-gathering through Jeff and only wakes the 27B when a turn needs real thought, matched the 27B-alone pass rate across 1,242 tasks and finished 47% faster per task. Turning the big model’s thinking off instead was faster still and 7.6 points worse — the small model deciding when the big one thinks is what keeps the quality.

You’re not behind the times for not running one of these yet. You’re behind if every decision still flows through the big model. The split is here: the big model does the thinking, the small one makes the calls at the door, and the orchestrator’s job is wiring them together.

To go deeper, start with the repo — adapters, GGUF builds, training kit. The results page publishes every number with its source. The what-the-jev resource list tracks the whole ecosystem. And the Hacker News thread is worth your time: the skeptics are mostly right about what a 0.8B model can’t do, and none of that is gating.