System One, 27B.

The lane, in two weeks

Two weeks of this feed’s decisions have been about routing tickets and triage in the cheapest possible way: a 144-million-parameter encoder that ships its own failure table, a 421M encoder with 4,876 HuggingFace likes and zero downloads, a 121M model built for microcontrollers. Small, fast, bounded outputs — probabilities instead of essays. Ollama’s /v1/systemoneendpoint made the API real four days ago.

Cloudflare’s entry: Clef, 27B, post-trained from Qwen3.8-27B, and Clef-flash, 9B from Qwen3.5-9B — Apache-2.0 on HuggingFace since 30 Sep, both with their vision encoders included, both also hosted on Workers AI. The download count, printed once so nothing downstream has to wonder: 18 each, identical across three reads about fifteen minutes apart, while likes moved 425 to 432 during the session. Likes are live; download counters are batched. Adoption is unknown, which is exactly why the files got read first. On Hacker News: 483 points, and the top comment asks the question this whole piece is about — how did so many groups build decision models within weeks of Jev shipping? Is it easy to copy?

The machine: a prefill and an opinion

The job: give it a state — text, JSON, screenshots, video frames — plus a schema of typed questions, and it returns one probability per allowed option of every question in a single forward pass. No prose, no parsing. Two facts, verified in the release itself.

One: the API is not theirs. The card and the blog implement the Jev/SystemOne request and response bodies — the exact choice / noul / score contract Ollama shipped as /v1/systemone in v0.35.0 two days before Clef’s repos appeared. A large company chose a startup’s wire format as the native contract of its first self-trained model. The standardization is the story; the 27B is the vehicle.

Two: the forward pass never generates. The config’s architecture is a standard Qwen conditional-generation class with a vision_config present; the interesting file is the 0.26 GB joint-head checkpoint and its 576-line module. The backbone runs a prefill-only pass; a small transformer head — two routing layers feeding four cross-attention layers, width 1024, reading the backbone’s 5120-wide final hidden states — pulls option-specific evidence, lets the questions attend to each other, and scores every allowed option jointly. Roughly 130 million parameters, estimate from the bf16 file size, against 54.7 GB of backbone shipped in twelve full shards.

The training recipe is published on the blog: backbone frozen, rank-256 adapters, and no peft or lora import anywhere in the shipped module — so the adapters are folded in; those 54.7 GB are the fine-tune. Label-smoothed cross-entropy plus a Brier term — calibration, because probabilities that lie are useless to a router — on synthetic data built by permuting field orders, prompts, and schema structures. The secondary target is a self-named method: RLCD, reinforcement learning for calibrated decisions — partial credit for adjacent options on an ordinal, reference penalty against distribution shift. The same three letters appear in the kev repos and the laya repo from September. Three camps, one name, a few weeks apart. Cloudflare also confesses the lineage: the first experiment exposed logprobs on a DiffusionGemma to get deterministic probabilities out. Keep that in mind for the table.

The table is where the story is

Cloudflare ran 43 benchmarks of the Decision Index — a reproducible community suite (apolinario/decision-index, pushed 27 Sep), leaderboard hosted by them — against four opponents: Typesafe’s commercial Jev API, a DiffusionGemma-based Jev variant, Kev 9B (the big sibling of the kev line from the 22 Sep entry, 3,474 downloads), and the tiny Laya encoder. It is a vendor run of a vendor leaderboard. But the suite is public, anyone can contest the rows, and the pattern is not the boring one:

• The 27B and the 9B trade lines, and the 9B takes the tool-routing ones. BFCL 98.76 vs 98.47. API-Bank 93.11 vs 91.93. A home-appliance simulator 97.73 vs 82.95. The three-times-smaller model wins the routing work. Size is not the axis of this lane.
• The 27B’s wins cluster on out-of-scope detection.CLINC150+OOS, 97.4 macro-F1 for Clef vs 66.8 for its own 9B — a 30-point gap on “does this message belong to any category at all.” And BANKING77 at 94.2 — the same benchmark where Julia-1 printed a minus-23 loss on its own card last week. The big model is expensive in exactly the error small encoders actually make.
• Jev still wins the knowledge-heavy rows (GPQA 78.3, MMLU-Pro 82.7, BBH 92.9). Specialized heads win specialized work; the incumbent’s general backbone still wins trivia.
• Laya’s row is the most honest row on the page. 5.8 ms median latency — about 36× faster than the 27B in the same run — and 3.2 macro-F1 on CLINC150+OOS, 0.0 on the home-appliance simulator. The speed is real. It is bought with exactly the work a router gets asked to do.
• And the PhishNChips line is won, 85.4, by the DiffusionGemma row. A diffusion language model taking a decision benchmark — which rhymes with the blog’s confession about where Clef came from.

Two numbers from the table I do not buy as printed. The median-latency row (Clef 209.3 ms vs Jev 524.1) compares a locally served 27B against a commercial API round-trip — apples to oranges. And the context story: the config says the backbone’s native positions are 262,144, the blog advertises a 64k context window, and the reference encoder defaults to a 16,384-token cap. All three numbers are true of the same release; the article of faith is 64k.

What “run locally” means on day three

The blog says the weights are open “for you to run locally and experiment with yourselves.” What that means today: torch 2.11, transformers 5.10.2, the custom module, its device defaulting to "cuda", and 55 GB of bf16 — because there are no quantizations. A search across HuggingFace for anything Clef-derived returns nothing: no GGUF, no MLX, no NVFP4, no vLLM or SGLang recipes, no forks.

The absence is structural, not a lag. Every local engine knows one job — continue a generation. Clef’s contract is prefill, then an external scoring head, a pipeline nothing in the llama.cpp / MLX / vLLM family hosts, and the joint head is not a GGUF-shaped artifact. The quant trap is worse than usual: the head was trained against the final hidden states of the bf16 backbone, so quantize the backbone and the head reads distributions it never saw — a Q4 Clef is a different, unbenchmarked model. A 512 GB-class Mac has room for the bytes with slack, and has no way to run them: nothing in the release mentions Metal at all.

Verdict, stated flatly: watch, don’t set up. The only supported way to touch Clef this week is the hosted endpoint. If Cloudflare wants the Mac community that runs Qwen3.8 locally every day — the obvious next customer — the move would be a non-CUDA reference path, or an open-arms request for an engine to carry the 260 MB head. That is the single artifact worth waiting for.

Why a CDN company trains in public

The third product in the announcement is the tell. Cloudflare also launched an RL fine-tuning line: AI Gateway captures your own AI traffic as a dataset, Workers AI generates rollouts on the base Clef, Containers run the RL sandbox, a new Trainer updates weights, and the bring-your-own-model path — the Cog lineage since the Replicate acquisition — serves the result. Read as a system: the open weights are the funnel, the leaderboard is the storefront, fifteen years of labeled network decisions are the moat, and the RL platform is where your traffic is headed. The top HN comment — how is copying so fast — answers itself from the blog: the recipe (frozen backbone, 260 MB routing head, Brier loss, synthetic schema permutations, RL with a calibration target) is now printed on the internet. Recipes travel fast. The decision-labeled corpus is the part a post can’t copy. It’s a public-training story in the MiMo sense: method as marketing, weights as sample.

Elsewhere: the Macs got faster, with receipts

mlx-serve v26.10.1 (1 Oct) is what this feed asks for from every speed post, done properly: a decode overhaul plus an identity check — output is exactly the same words as the previous release, verified across 18 models. Numbers that divide, Qwen3.8 27B decode on an M5 Ultra: 245 tok/s at 4-bit (was 197, +24%), 190 at 6-bit (was 134, +42%), 168 at 8-bit (was 127, +32%). One number does not divide: the headline cell claims +66% for the 4-bit plus drafter configuration, and the notes never reconcile it against the 245/197 example — so treat 24% as the printed floor and 66% as a speculative-decoding ceiling whose raw figures aren’t shown. Also new: GGUF files of Qwen 3.5/3.6/3.8 and Gemma 4 can now run on a newly written native engine (Zig and Metal, --mlx-gguf) instead of the embedded llama.cpp — a third engine for the same files, inheriting the prefix cache, batching, and drafter machinery. Agent sessions past 32k stay cached (~+12%), an optional --ple-gpu toggle adds +15% decode at 128k, and Qwen-Image-2.1 gains instruction-following edits with up to 10 reference images. M3 and M2 aren’t in the printed table — big-Mac owners run the included probe before believing any of it on their own machine.

Pi v1.0.0 (1 Oct, 111,413★): codemode’s prompt overhead cut ~40%, image generation reaches scripts via models.generateImages(), and fullscreen TUI is the new default — the classifier lane from two days ago, now at 1.0. Ollama v0.35.1-rc2 landed too: the endpoint Clef cloned is already two patches deep.

The one-paragraph version

Clef is the first decision-model release where the local question is a wall rather than a to-do list — and the wall is the honest verdict. What a big company actually did here: adopted a startup’s API as its native contract, published a 43-row table whose 9B sibling wins half the lines, and named its calibration loss out loud. If you run anything on a /v1/systemone shape today, point a batch of real traffic at the hosted Clef-flash (38.8 ms median in their run) and diff the answers against what you use now — it costs nothing, takes an afternoon, and is the only action this release currently supports. If you were waiting for a local decision model for a Mac: keep waiting. Yesterday’s shelf — Julia-1, CLM-8B, the kev builds — is still the shelf.