Jev & Clef: the deciders

A full lesson, with a live one you can poke. Everything below is either running on the demo, measured on this page's own battery, or labeled as somebody else's claim.

1. The one-sentence version

2. Two kinds of thinking

Psychologists split thinking into System One — fast, intuitive, the gut call you make in a blink — and System Two — slow, deliberate, the careful reasoning you do on paper. TypeSafe named its product after the split: Jev is a System One model. A chat model is a System Two machine being asked to do both jobs, which is why using one to answer "is this email rude?" is like hiring a novelist to work a toll booth: brilliant, slow, expensive, and it might improvise.

Here is why this matters to us, measured on our own operation: when we audited the calls our coordinator layer actually makes, 93.8% of them were decisions, not writing — route this here, allow or block, urgent or not, which of these three. The bounded many are gut calls. The hard few deserve the big brain. The whole doctrine is: stop paying novelist rates for toll-booth work.

3. Anatomy of a call

Every call has the same three parts:

• The state — the thing being judged, in plain words. An email. A bark you dictated. A support ticket. A photo, even: pictures can ride along, up to four per call.
• The questions — as many as 64 in a single call, in three shapes only: yes/no ("does this threaten the reader?"), pick one ("which lane: health, people, ideas, money?"), and score ("how polite, on a scale from rude to warm that you define").
• The answers — for each question: the pick, the probability on every option, and a confidence score. Not a paragraph. A verdict with its odds attached.

One subtlety worth knowing, because it bites people: a score is a position on your scale, not a percentage. Ask "how polite, rude→blunt→neutral→polite→warm" and a score of 0.84 means "between rude and blunt" — quite rude — not "84% polite." The demo labels it in plain words so you can't misread it.

4. When it says "I don't know" — the safety system

A decider that must always answer is a liability. The craft is in what happens around the call:

• Thresholds. Every decision carries a bar. Confidence below the bar doesn't get acted on — in our own rule system, anything under 0.6 confidence gets flagged and escalated instead of executed.
• Abstention. "None of the above, a human should look" is a legitimate, designed outcome — not a failure.
• Fallbacks. If the decider is down or unsure, the work drops to the older, dumber, known path rather than stopping. Our doctrine splits this by stakes: advisory work fails open (a missing suggestion never blocks you), while routing and spend fail closed (no confident decision, no movement).
• Circuit breakers. Caps on how many calls, how much spend, how fast — so a loop can't burn money at machine speed.
• The ladder. Cheap decider first; the few percent it flags climb to a big chat model; the genuinely ambiguous reach a person. Each rung costs roughly ten times the one below and handles a tenth of the volume.

5. Jev, the product

Jev is TypeSafe's hosted decision model — the one that defined the category. Facts, with their labels on:

• Hosted API only. You send it your state and questions over the internet; the weights have never been released. Current version: Jev 1.14 (released October 14, 2026); the "jev-latest" alias points at it today — it pointed at 1.13 at launch, which is why you pin the versioned name in anything that matters.
• The speed claims are claims. presenter claim "Up to 200× faster and 400× cheaper than a frontier chat model" is the maker's own headline (193.6× / 444.6× on TypeSafe's site, rounded up in the launch videos), not a benchmark we ran. The direction is believable — small model, tiny outputs — and the one independent check we found (100 support tickets) shrank it to 4–7× faster and 31–65× cheaper: still a rout, honestly reported. Treat any multiplier as marketing until it names its baseline.
• The residency line — your own ruling. Because Jev is hosted-only, anything whose data cannot leave the building cannot use it. You ruled exactly that. Jev is therefore a fine tool for public or disposable data, and a non-starter for client material, health, or anything under our data doctrine.

6. Clef, ours

Clef is Cloudflare's answer, launched October 1, 2026, built with TypeSafe and speaking the same System One language — with two differences that matter. First, it runs on Workers AI, Cloudflare's edge network. Second, its weights are open (Apache 2.0): nobody can take the model away from us, and the same decisions could one day run on our own hardware.

Two sizes: Flash (9 billion parameters, the sprinter — vendor-median latency 38.8 ms, about $0.038 per million input tokens — cut from the $0.09 launch price on October 9) and the full Clef (27 billion, the heavyweight, about $0.24 per million). A real decision costs on the order of a hundred-thousandth of a dollar — at the launch price our first metered runs cost $0.000026 each; at today's price the same call is closer to $0.00001. We know, because we've been paying it since October 15.

Why the edge is the point

• No cold starts. Cloudflare Workers run in V8 "isolates" — lightweight sandboxes that start in roughly zero milliseconds, versus seconds for a traditional server waking up. A decider that answers in 40 ms but takes 3 seconds to wake is not fast.
• 300+ cities. The code and the model live in data centers near the person asking, including here in California — the round trip is a drive across town, not a flight.
• Where memory lives, in plain words: D1 is the ledger book — proper records you can audit later. KV is the sticky-note wall — fast little facts, eventually consistent. Durable Objects are single rooms with one doorkeeper — when exactly one actor must own a thing (one game room, one counter), that's the tool.

7. Limitations — honestly

• State design is the real work. The model judges the summary you hand it. Leave the decisive fact out of the state and no model saves you.
• Hosted means dependency. Jev entirely; Clef less so (open weights, our own account, portable doctrine) — but any vendor can change prices or retire a model. The house answer is the same as everywhere: the rules and the record live with us.
• Scores are slippery. A score is an index on your scale (see §3), scales drift as you edit their wording, and a 2.1 today isn't perfectly comparable to a 2.1 next month if you changed the level descriptions in between.

8. How you'd actually do common things

No syntax — the recipes. Each is: what state you hand it, what you ask, what you do with the answer.

• Route a bark. State: the transcript. Ask: pick one lane (health, people, ideas, money), is there a health report in it (yes/no), how urgent (scale). Under a second, the bark is filed, logged, and queued — the demo's second preset does exactly this.
• Approve or flag content. State: the draft. Ask: does it break each house rule (one yes/no per rule), tone (pick one), risk (score). Anything flagged or low-confidence goes to a human with the odds attached; the clean 90% never touches a desk.
• Triage a lead. State: the inquiry. Ask: fit (score on a rubric you wrote), budget signal (yes/no), which offer (pick one). The decider sorts; people persuade.
• Pick a thumbnail. State: the video's title and goal — with the candidate images attached (up to four ride along per call). Ask: pick the strongest, score each for click-appeal. A decision over pictures, in milliseconds, for fractions of a cent.
• Grade urgency. State: the message. Ask: the four-level urgency scale. The top level pages a human; the rest queue. The scale's wording is yours — that's the control.
• Rubric checks. State: the work product. Ask: one yes/no per line of the rubric ("does the episode page carry a transcript?", "is there exactly one play button?"). Mechanical verification at decider prices instead of novelist prices.
• Run a home. State: sensor readings and the house rules. Ask: pick one from the valid actions only — the decider literally cannot choose an action that isn't on the menu, which is what makes it safe near real switches. Unsure → do nothing and log it.
• Guard a spend. State: the proposed purchase and the budget rules. Ask: allowed (yes/no), over cap (yes/no). Fails closed: no confident yes, no money moves.

9. The cool shit — games

Start with the arithmetic that rules everything in games. A frame at 60 fps lasts 16 milliseconds. A living game world wants hundreds of little brains ticking — every NPC deciding what to do next, all the time. A chat model takes about a second to even start answering. You cannot put a novelist inside a goblin. But a decider that finishes in ~130 ms fits the "brain tick" — the few-times-a-second moment where a character picks its next move — and it fits at a price where a thousand goblins cost pennies.

Games have actually always worked this way, with hand-built deciders:

• The Sims runs on utility AI: every possible action gets a score from the Sim's current needs, and the highest score wins. A menu, a scorer, a pick — Clef's exact shape, hand-tuned instead of learned.
• F.E.A.R. made GOAP famous: each soldier holds goals and a menu of actions with preconditions and effects, and a planner chains them into behavior that looks startlingly alive. Still the same skeleton — bounded options, chosen fast.

What changed is the other half: the world itself can now live on the edge.

• Durable Worlds verified, Cloudflare's own repo Cloudflare's engineers published a multiplayer voxel game — think small Minecraft — where each world runs inside a single Durable Object (the "one room, one doorkeeper" from §6), players connect over WebSockets, and the terrain sleeps in object storage. Open source; you can read every line.
• Multiplayer Doom verified, Cloudflare's own blog yes, that Doom — Cloudflare ported it to run in the browser, with multiplayer coordination on Workers and WebSockets and each session's state in a Durable Object. If the edge can run Doom deathmatch rooms, it can run your game's rooms.
• PartyKit verified the real-time layer Cloudflare acquired in 2024: rooms for multiplayer apps and games, used at "hundreds and eventually thousands" of projects' scale (tldraw's collaborative whiteboard is its famous production case). The programmer Tim Bray built Microcrawl on it — a tiny multi-user dungeon, 80 characters, two rooms, turn-based — specifically to prove the game-server pattern. Honest update: the hosted PartyKit service wound down in October 2026; the pattern survives as PartyServer — the same rooms, run in your own Worker with your own Durable Objects.
• Hibernation Cloudflare docs idle game connections cost nothing: a WebSocket can sleep inside its Durable Object and wake the instant a message arrives. That one trick is what makes ten thousand mostly-quiet game rooms affordable — you pay for play, not for waiting.

The RoboNuggets canon, graded. The "19 Jev Use Cases" video exists and is the source of the famous multipliers presenter claim — 200× faster, 400× cheaper. Its actual list isn't recoverable from text sources, so we won't pretend to grade item-by-item. The use patterns that are documented in writing: decisions embedded directly in agent workflows as tool calls — the agent asks "can I do this, yes or no, with what confidence" mid-task and gets an immediate typed answer instead of stopping to deliberate. That one is real, and it's the pattern our own fleet runs on.

10. Latency — measured, not promised

Measured on this site's own live endpoint, October 25, 2026, over ~100 real calls. "Model time" is the decider's own thinking time, stamped at the edge; round trip was timed from the house in Manhattan Beach. Stalls are reported, not averaged away.

The comparison that makes it visceral: a chat model on the same network (llama-3.1-8b, one of the fast small ones) took 0.9–2.0 seconds just to produce its first token on the same email question — and a first token is not an answer: the rest streams after, in prose, which something then has to read and interpret. Clef's ~130 ms is the finished decision, odds attached, ready for a machine to act on. Our own production rule-checker, running the same doctrine on a chat-model engine, medians 842 ms a decision — the native decider is roughly 6× faster to a finished answer, and against a frontier chat model doing the same job the gap widens from there. Cloudflare's published Flash median is 38.8 ms vendor figure; our stopwatch says ~130 ms typical in the wild. Believe the wild.

How to read this: a chat model's time-to-first-token is when it starts answering — the full answer takes longer, and then something still has to parse prose into a decision. Clef's number is the whole decision, finished, structured, ready to act on. The vendor's 38.8 ms median for Flash is their figure; ours above are our own stopwatch.

11. The takeaway

Most of what a smart operation does all day is not writing — it's judging. Deciders like Jev and Clef take that 93.8% and make it nearly free, nearly instant, and — the part nobody else gives you — honest about its own uncertainty. The craft moves up a level: from writing answers to designing menus, scales, thresholds, and ladders. Which is, not coincidentally, exactly the business we're in.

📖 Back to the live demo · 🎧 Hear this lesson (about 15 minutes)