Cloudflare Clef and Strands Decider: open-weight decision models for agent routing

Cloudflare and Strands shipped open-weight "decision models" on the same day. Here is where they fit in an agent

On 1 October 2026 two companies published the same idea on the same day. Cloudflare released two decision models, Clef and Clef-flash, hosted on Workers AI and published on Hugging Face under Apache 2.0. The same day, Strands Labs released Strands Decider 2B, a two-billion-parameter decision model with its weights, training data and scripts open under Apache 2.0.

A decision model does not write text. It reads a situation, the "state", and a set of typed questions, and returns a probability for every allowed answer, so your code can route a ticket, approve or hold a tool call, or hand off to a human. Both vendors present their release as a response to the attention around Typesafe AI's Jev decision model, and both say their models are compatible with its API.

One frame applies to everything below: every accuracy and latency number in this article is vendor-reported. That includes Cloudflare's reported 209 ms median for Clef and 39 ms for Clef-flash, and the roughly 115 ms that Strands reports on a local RTX 3090.

For an MSP, the interesting part is not who leads a leaderboard. It is that the small, structured, repeatable decisions inside an agent can move off a large general model onto something cheap, calibrated and runnable on your own hardware. This article covers what a decision model is, what each vendor shipped, where the pattern fits, and where it stops.

Both posts describe the same interface. You pass a state, which can be text or JSON and, for Clef, images, plus typed questions. A yes/no question is called noul in both APIs, a pick-one question is a choice, and an ordered scale is a score. The model returns a probability for each allowed option, and it always answers from the options you gave it.

That is useful for two reasons. An answer from a closed set needs no output parsing and cannot invent a new category. And a probability lets code set a threshold: act above it, ask a human below it. Strands stresses that several questions about the same input are cheap to ask together, so one pass can return a routing team, an urgency flag and a grounding check.

The vendors frame the difference from a language model in terms of how the answer is produced. The decision is made in one parallel pass over the input rather than token by token, which is where the speed claims come from.

What a decision model is not matters as much. By Strands' own account, its model is much weaker than reasoning models on complex problems, and it is useless for coding, chat or summarisation because it cannot generate text. Its strength is small, repeated choices, not hard ones.

Classifiers have existed for years, and a sceptical reader will say so. The pitch, as Cloudflare's post frames it, is one model that accepts new categories at request time without retraining: you change the question, not the model.

According to Cloudflare's 1 October post and its Hugging Face card, two models shipped: Clef and Clef-flash, hosted on Workers AI and downloadable under Apache 2.0. The card describes Clef as a 27B multimodal model post-trained from Qwen3.8-27B, reading text, JSON, images or video and answering in one forward pass with no free-form generation. The post says Clef-flash freezes a Qwen3.5-9B backbone. Both add a small routing head and rank-256 low-rank adapters, trained with calibration losses.

Cloudflare names two things it says set Clef apart: a vision encoder, so images can be part of the state, and a 64k-token context window, which it contrasts with Jev's 32k.

The numbers come from Cloudflare's own internal run of the Decision Index suite, and all of them are vendor-reported. Cloudflare reports BFCL case-exact accuracy of 98.47 for Clef and 98.76 for Clef-flash. It reports median latency of 209.3 ms for Clef and 38.8 ms for Clef-flash, with reported p95 latency of 238.6 ms and 122.4 ms respectively.

The same tables also show the weaker side. Cloudflare's own reported figures show Clef trailing Jev on harder reasoning sets such as GPQA Diamond, MMLU-Pro and BBH. That fits the pattern: decision models are built for bounded choices, not hard reasoning.

Two more vendor statements, labelled as such. In an anecdote, Cloudflare reports that a domain-classification workflow took 2.2 seconds with Clef versus 4.7 seconds with gpt-oss-120b. As a promise, Cloudflare says it does not read, store or train on requests and responses unless the customer opts into its fine-tuning service.

Self-hosting is possible but not light. The card's reference example was tested on a single H200; Clef is a 27B model, not a laptop model. Clef-flash and the hosted endpoint are the lighter paths. Cloudflare also announced a reinforcement-learning fine-tuning service, offered first through its forward-deployed engineers and later as self-serve; the post publishes no pricing.

According to Strands Labs' 1 October post and its Hugging Face card, Strands Decider 2B is a two-billion-parameter decision model built on Qwen3.5-2B, with the text-generation head removed and replaced by a small pointer head, just over a million parameters, that scores each option. The torso is fine-tuned with a rank-16 LoRA. The released checkpoint is v19, after many iterations whose history is in the repository.

Openness is the headline. The code is on GitHub, the weights are on Hugging Face and, per Strands, so are all the training data and scripts used to build the model, under Apache 2.0. The card says retraining takes about 11 hours on one RTX 3090. For an MSP that wants to adapt a decision model to its own ticket categories, that reproducibility is the point.

The numbers are vendor-reported. Strands reports a median of about 115 ms for local decisions on an RTX 3090, and the chart caption says that measurement was taken on v18, not v19. It reports about 153 ms for small tasks on an M3 MacBook. The card reports 167 of 231 public JevBench tasks correct and marks that result "self-reported."

Strands publishes its own limits, and they belong in any adoption note. Long multi-step documents are the weak spot. Questions are read less carefully than the documents. Calibration was fitted on short classification tasks, so the card advises measuring thresholds on your own traffic before you trust them.

One operational line an MSP must not miss: according to the card, the built-in strands-decider serve command binds to 127.0.0.1 and has no authentication, and the card says to use it for local experiments. Do not expose it on a shared network as it is.

The post's worked example is a check before a tool call: are the tool's arguments grounded in what the user actually said, and is it too early to act? Strands calls it an illustration rather than a recommendation, and it should be read that way.

Below is Strands' own example from its model card, run on a local machine. The card notes that a retrain gives somewhat different numbers.

pip install strands-decider

strands-decider ask StrandsAgents/strands-decider-2B-hobson-v19 \
  --state "Help! My payouts have been failing for 3 days! " \
  --choice "Which team should handle this?=billing,sales,retail" \
  --noul "Does this convey urgency?"

Both vendors name the same family of uses, and they map neatly onto MSP agent operations: ticket routing and urgency, model routing (sending a request to a cheap or an expensive model), tool selection, checks before a tool call, policy classification and alert triage. These are the rote decisions where a general LLM is slow, expensive and harder to audit.

Strands describes the hybrid shape plainly: let the LLM take the hard decisions and the decision model the routine ones. That cuts cost and latency only if you measure it on your own workload. No savings figure is offered here, because none exists for your workload until you measure one.

Adoption controls, on the defender's side, each with its evidence:

1. A golden set per workflow. Real, anonymised decisions for each customer workflow, with an accuracy and calibration check before go-live. Evidence: a report on your data, not a leaderboard screenshot.
2. Thresholds with a human fallback. Below the threshold, a person decides, and every low-confidence hand-off is logged.
3. Pinned revisions. Pin the model revision you validated, as with any model, so that a silent update or a retirement cannot change behaviour underneath you.
4. Authenticated local servers. Put local servers behind authentication and network controls. The Strands demo server has none by design.
5. Data terms on file. For the hosted path, read the provider's data terms. Cloudflare's no-retention line is its own promise, so record it in the vendor file.

What not to do: do not let a decision model be the only gate on an irreversible action. Pair it with a deterministic policy or a person, as Strands' own example does with its proceed, deny and confirm actions.

Four things this article is not.

It is not a review of Typesafe's Jev. Both vendors cite Jev as the trigger for their releases; this article did not test it and quotes no Jev number except as it appears in Cloudflare's tables.

It is not about Laminar flow-1, a small model that reads agent traces to find failures. That is a separate story.

It is not about Reflection Beam, a large general model announced with its weights still pending.

It is not a Workers AI pricing piece. Cloudflare's post publishes no price for Clef or for its fine-tuning service, and this article invents none.

The verified facts: on 1 October 2026 Cloudflare released Clef, a 27B multimodal decision model post-trained from Qwen3.8-27B, and Clef-flash, on Workers AI and on Hugging Face under Apache 2.0, with a reinforcement-learning fine-tuning service to follow. The same day Strands Labs released Strands Decider 2B, built on Qwen3.5-2B with a LoRA and a pointer head, with weights, code, training data and scripts under Apache 2.0.

Every accuracy and latency figure in this article is vendor-reported: Clef's reported BFCL score of 98.47 and 209 ms median, Clef-flash's reported 38.8 ms median, and the Decider figure of about 115 ms on an RTX 3090 that Strands reports. Cloudflare's own tables show Clef trailing on harder reasoning sets.

The pattern is the story. Bounded, calibrated decisions inside an agent can move to small open-weight models you can run yourself, with a human or a deterministic policy behind every low-confidence or irreversible step. Measure on your own traffic before trusting any threshold.