Jev vs Clef, compared

A new kind of AI model appeared this autumn: one that never writes a word. TypeSafe's Jev (launched September 15, 2026) and Cloudflare's Clef (October 1, 2026) are "System One" decision models. You send them a piece of state — a support ticket, a transaction, a document — plus typed questions, and they hand back choices, scores and yes/no answers with calibrated probabilities your code can branch on directly. No prose to parse, no malformed JSON to retry.

They are aimed at the same jobs: routing, classification, triage, policy checks — the millions of small judgments that software currently borrows expensive chat models to make. Here is how the two compare.

#The models on offer

Both answer the same three question types — choice (pick 1 of 2–255 options), score (rate on a 2–10 scale) and noul (a yes/no probability) — and both evaluate every question against the state in a single pass rather than generating tokens one by one. That architecture is why both are fast and why their outputs can't be malformed: the answer is selected from your options, never written freehand.

Differences that matter:

• Vision. Clef takes images (up to 4 per request) and video. Jev is text only — TypeSafe's docs are explicit that media must be converted to text or structured fields first.
• Questions per request. Jev has no cap beyond context: pack as many questions as fit, and it fans them out in parallel. Clef allows up to 64 per request.
• Long context. Jev's default limits (64k per request, 32k per question) rise to 262k with a header flag, at the cost of speed and accuracy. Clef sits at 65,536 tokens either way.
• Versions. Jev ships point releases fast — 1.14 arrived October 14, a month after launch. The jev-latest alias still points at 1.13 as the stable build; jev-preview gets you 1.14.

#Pricing: Jev is cheaper, both are cheap

Both vendors charge for input tokens only. On published rates, Jev undercuts Clef by about 5.7× per token and Clef-flash by about 2.1×.

A worked example — 100,000 support tickets at roughly 400 input tokens each (40 million tokens total):

• Jev: $1.68
• Clef-flash: $3.60
• Clef: $9.60

For calibration, a frontier chat model doing the same triage job would typically cost two orders of magnitude more. At these prices the model bill stops being the interesting number; the engineering around it costs more.

Two wrinkles. Clef runs on Workers AI's "Neurons" billing, and every Cloudflare account gets 10,000 Neurons a day free — roughly 458,000 Clef tokens or 1.2 million Clef-flash tokens daily, enough to evaluate either properly at no cost. And pricing in this category is moving weekly: Clef-flash's hosted rate has already been reported lower (~$0.038 per million, with a smaller 24,576-token window) since launch. Check the live pricing pages before committing a budget.

#Quality: read the benchmarks like an auditor

The headline comparison comes from Cloudflare: on BANKING77, a standard intent-classification benchmark for banking queries, Clef scores 94.20 macro-F1 against Jev's 79.74. On latency, Cloudflare puts Jev's median at 524.1 ms against 209.3 ms for Clef and 38.8 ms for Clef-flash.

Treat those as vendor numbers, because they are. TypeSafe quotes Jev's end-to-end latency at 70–500 ms depending on the request, which doesn't square with Cloudflare's 524.1 ms median for it — and no neutral party has yet published a full head-to-head. What independent hands-on testing does show so far: Clef routes support tickets accurately (including in Japanese), its answers are deterministic — same input, same probabilities to four decimal places — and option ordering doesn't move the result.

On calibration, both vendors train for honest probabilities rather than confident-sounding ones: TypeSafe uses a method it calls RLCD (Reinforcement Learning for Calibrated Decisions); Cloudflare trained Clef's head with a Brier-score loss, which directly rewards accurate probabilities.

Honesty cuts the other way too. TypeSafe publishes a "jaggedness" page listing Jev's known failure modes: unreliable counting and arithmetic, dates read as text rather than values, trouble with indirect questions and distracting context. Clef has a documented quirk of its own: with no "none of the above" option in your question, it will force an out-of-scope input into one of your categories — you have to add an other bucket yourself (or threshold on its confidence score, which drops sharply for out-of-scope inputs).

Neither model replaces a chat LLM. They can't draft the reply, explain their reasoning in words, or do exact maths. They decide; something else still has to talk.

#Setup: API key vs Cloudflare account

Jev is the simpler on-ramp. Create an account, generate a key in the TypeSafe console, and call one endpoint — POST /v1/systemone — with your state and questions. There are official Python and JavaScript SDKs, and Jev is also reachable through Vercel AI Gateway and OpenRouter if you already route model traffic through them. Nothing to deploy, nothing to host. Customization happens inside the request: your rules live in each question's instructions and criteria, because the same weights serve every customer — Jev is never fine-tuned on your data.

Clef does not require a Worker. The common assumption is wrong: Clef is callable over a plain REST API — POST /accounts/{account_id}/ai/run/@cf/cloudflare/clef with an API token created from the dashboard's Workers AI template. If your application already runs on Cloudflare, you can also call it from a Worker binding, which is where it gets convenient: decisions happen inside the same platform as the rest of your edge logic. The costs of entry are ecosystem-shaped rather than technical — you need a Cloudflare account, billing runs in Neurons, and volume beyond the free daily allowance needs the Workers Paid plan. One gotcha from hands-on reports: on Workers AI, every question must include instructions, even though the open model card treats them as optional.

Clef's unique escape hatch is the open weights. Both models are on Hugging Face under Apache 2.0, so if the hosted price or platform ever stops working for you, the model can move in-house — though "in-house" means a datacenter GPU: roughly 85 GB of VRAM for Clef and 41 GB for Clef-flash at full context. Cloudflare is also building an RL fine-tuning platform around Clef, starting with its own engineers working alongside customers; Jev's counter-offer is that its probabilities need no tuning to be usable.

Switching costs between the two are low by design: Clef is compatible with the System One API shape, so an integration built for Jev can be pointed at Clef with minimal changes.

#Which one should you pick?

• Pick Jev if your decisions are text-only, high-volume and cost-sensitive — it's the cheapest per decision by a wide margin, the setup is a single API key, and unlimited questions per request suits wide fan-out checks. It's also the safer pick if calibrated probabilities are the whole point: that's what the model was trained for, and TypeSafe publishes its failure modes where you can read them.
• Pick Clef if your inputs include images or video, your stack already lives on Cloudflare, or you want the open-weights exit and fine-tuning roadmap. Clef-flash at 38.8 ms median is the pick for latency-critical paths, and Cloudflare's BANKING77 numbers — vendor-run, but large — suggest the bigger model is the stronger classifier today.
• Pick both, in sequence, if you're building seriously: prototype on Jev's key-in-minutes setup, evaluate Clef against the same workload, and let your own numbers — not either vendor's — make the call. At these prices, running the evaluation costs less than the meeting where you'd debate it.

#Key terms

System One model

A model built for fast, automatic judgment rather than deliberation, named for the System 1 / System 2 distinction in decision psychology. It returns decisions, not text.

Noul

A yes/no question type in the System One API; the model returns the probability of "yes" (the name is "no" + "oui").

Calibrated probability

A probability that matches reality: when the model says 0.8 across many calls, it is right about 80% of the time.

Prefill

The single pass in which a model reads its entire input. Decision models score all answers from this pass instead of generating output token by token.

LoRA

Low-rank adaptation: a small set of trained weights layered over a frozen base model. Clef is Qwen plus LoRA adapters and a decision head.