Cloudflare Clef and Strands Decider: Decision Models for AI Agents Explained

Most of the “intelligence” spent inside an agent loop is not spent on reasoning. It is spent on small forks: which model should take this request, which tool fits this step, is this tool call grounded in what the user actually said, is this ticket urgent. We usually answer those forks by asking a frontier LLM to write a paragraph and then parsing a label out of it, paying for generation, latency and format drift every single time. On October 1, 2026, two vendors released open-weight models built to remove exactly that waste. Cloudflare Clef (27B parameters) and its 9B sibling Clef-flash, plus Amazon’s Strands Decider 2B from Strands Labs, are “decision models”: they do not generate text at all. They read a state, take a schema of typed questions, and return probabilities over the options you allowed.

That matters now because agent traffic is dominated by cheap, repeated, structured judgments, and every one of them sits on the critical path of latency and cost. This article explains what a decision model actually is at the mechanism level, what each release discloses and does not, how to wire one into an agent loop with a confidence threshold, and what the vendor-reported numbers do and do not prove.

What this covers: the decision-model idea versus a general LLM, the verified specifications of Clef, Clef-flash and Strands Decider, a worked cost and latency calculation (clearly labelled illustrative), a decision matrix, failure modes, and a rollout checklist.

Context and Background

The decision-model category has a short history. Before October 2026 the reference point was Jev from TypeSafe AI, whose request shape (a “state” plus a map of typed questions, the System One API) both new releases adopt. Cloudflare describes Clef as fully Jev-API compatible, and the Strands release is benchmarked on JevBench, a public evaluation suite built around the same idea. In other words, there is now a de facto interface for this model class, which is the more durable story than any single model.

The motivation is easy to state. A typical agent runtime makes dozens of small classification-like decisions per task. Teams have been satisfying them with one of three patterns: a regex or keyword rule (fast, brittle), a fine-tuned encoder classifier such as a BERT-class model (fast, needs a labelled dataset per decision), or a prompt to a large generative model (flexible, slow, expensive, and prone to answering outside the allowed options). Decision models try to occupy the gap: the flexibility of prompting with a natural-language schema, the latency profile of a classifier, and calibrated probabilities that a threshold can act on.

If you have read our piece on LLM semantic routing as an inference pattern, you have seen the routing half of this problem: a cheap component decides which expensive component handles a request. Decision models generalize that idea beyond model selection to tool choice, policy checks and escalation. They are also a natural companion to the tool-heavy patterns we covered in Claude computer use architecture for desktop agents, where every step of a long loop is a candidate for a fast gating decision.

Both releases are open-weight under Apache 2.0, which changes the economics of self-hosting. One caveat applies to Clef up front: the weights are published, but the training data and the full training pipeline are not, so it is an open-weights release rather than a fully reproducible open-source one. The Strands project, by contrast, states that training data and scripts are in its repository, which is a real difference for anyone who needs to audit or retrain.

The primary sources used throughout are the Cloudflare blog announcement, the Clef model card on Hugging Face, the Workers AI documentation for Clef, the Strands Agents announcement and the strands-decider repository. Every benchmark below is vendor-reported unless stated otherwise, and I flag where numbers differ between sources.

How a Decision Model Works: Reference Architecture for Cloudflare Clef

A decision model is a language-model backbone with the text-generation head removed and a scoring head attached, so it returns a probability for each option you allow instead of generating tokens. Clef does one prefill-only pass of a Qwen backbone over the input, then a joint schema head scores every allowed option of every question in parallel. Nothing is sampled, so an answer cannot contain an option you did not define.

Figure 1: Inference path of a decision model such as Cloudflare Clef. A single prefill pass feeds a schema head that emits one logit per allowed option, and a softmax per question turns those logits into probabilities.

Figure 1 shows the whole forward path. The state (text, JSON, and for Clef up to four images) goes through the backbone once, exactly like the “reading” phase of an ordinary LLM request. The question schema tells the head which options are legal. The head emits one logit per allowed option, and the model card instructs callers to apply a softmax per question to obtain probabilities. The key structural fact is that there is no decode loop: latency is roughly one forward pass of prompt processing, not prompt processing plus N sequential token steps.

The three question types

Both Clef and Strands Decider expose the same three question types, which is what makes them interchangeable at the API level.

• noul is a yes/no question. The answer is the probability that the statement is true, a number between 0 and 1. Example from the Strands blog: “Are the tool’s argument values grounded in facts the user actually provided?”
• choice names the options, such as which team should handle a ticket. The response carries the chosen option, a confidence, and a probability for every option.
• score is an ordinal rating over ordered levels, such as severity. The response carries an expected score (a probability-weighted position along the scale), a confidence, and per-level probabilities.

The score type deserves attention because it is the one place a decision model offers something a plain classifier does not: a continuous output with ordinal structure. In one published Clef-flash example reproduced by an independent reviewer, a severity question returned an expected score of 1.11, sitting between two adjacent levels, with a confidence of only 0.43. That is the model telling you it is torn between two neighbouring severities rather than lying confidently about one.

What Cloudflare discloses about Clef

Cloudflare’s announcement describes Clef as built on a Qwen backbone, with rank-256 low-rank adapters (LoRA, a technique that trains small added matrices instead of all weights) for the 27B model. The model card names the backbone as Qwen3.8-27B and states that Clef is post-trained from it, with a “joint schema head” that routes evidence to each question and scores all options jointly. Clef-flash is the 9B sibling built on Qwen3.5-9B. Both keep the backbone’s vision encoder, though the Workers AI page documents image input for Clef, so check the flash page before assuming image support there.

Cloudflare describes the head as using a two-stage attention routing process: valid choices pull out the relevant context, then fields cross-attend with each other before scoring. The practical implication is that the options of one question can influence how another question’s evidence is read, which is why scoring all questions in one request can be better than issuing them separately. I would treat that as a design claim to test on your own data, not as a guarantee.

Training, per the announcement, used internal synthetic datasets that permute field orders, prompts and schema structures, so the model does not memorize one layout. The loss is label-smoothed cross-entropy over the valid outputs plus a Brier loss to improve calibration. A secondary stage called Reinforcement Learning for Calibrated Decisions (RLCD) grants partial credit when a score answer lands adjacent to the correct level. None of the dataset sizes, compute budgets or data sources are published, and I could not find them.

What Strands Labs discloses about Decider 2B

Strands Decider takes a smaller, more transparent route. Its torso is Qwen3.5-2B with the language head removed and a rank-16 LoRA adapter fine-tuning the torso. A pointer head of just over one million parameters scores the answers by comparing the hidden state at each option position against the hidden state at the answer position. The total is reported as 1.9 billion parameters. The released checkpoint is StrandsAgents/strands-decider-2B-hobson-v19, and the blog notes that “v19” hides many iterations, all documented in the repository.

One source inconsistency is worth flagging. The Strands blog and the MarkTechPost write-up say Qwen3.5-2B; a summary of the repository README I retrieved said Qwen2.5-2B. I follow the vendor blog and flag the discrepancy in the review notes.

Why removing the decode loop changes the economics

An autoregressive model pays a prefill cost proportional to prompt length and then a decode cost for each generated token, each decode step being memory-bandwidth-bound. A routing decision rarely needs more than one token of information, yet a generative router spends a full chain of tokens expressing it, especially if you ask it to explain. A decision model keeps the prefill and drops everything after. That is why a 9B model can post a 38.8 ms median while a generative model of the same size would typically take far longer once decoding and output parsing are included (the second half of that sentence is general mechanism, not a measured comparison).

It also changes the failure surface. A generative router can output “billing, maybe sales” or invent a team name; a decision model cannot, because the answer space is closed. What it can do instead is be confidently wrong inside the closed space, which is a different problem and one we return to in the trade-offs section.

Deeper Analysis: Specifications, Benchmarks, Cost and Placement in the Agent Loop

The three models share an interface but differ in size, hardware profile and openness. The table below consolidates what the primary sources state. “Not disclosed” means I could not find it in the vendor material.

Attribute	Clef	Clef-flash	Strands Decider 2B
Publisher	Cloudflare	Cloudflare	Strands Labs (Amazon)
Release date	October 1, 2026	October 1, 2026	October 1, 2026
Parameters	27B	9B	1.9B total
Backbone	Qwen3.8-27B	Qwen3.5-9B	Qwen3.5-2B (per vendor blog)
Adaptation	Rank-256 LoRA, joint schema head	Same family	Rank-16 LoRA, pointer head near 1M params
Context window	65,536 tokens	65,536 tokens	Not disclosed in sources I read
Image input	Yes, up to 4 images	Documented for Clef; verify for flash	No
License	Apache 2.0	Apache 2.0	Apache 2.0
Hosted price	$0.24 per M input tokens	$0.09 per M input tokens	Self-host only
Median latency	209.3 ms (p95 238.6 ms)	38.8 ms (p95 122.4 ms)	About 115 ms on RTX 3090, about 153 ms on M3 Pro
Training data public	No	No	Stated as included in repo

The latency figures are not comparable row to row. Cloudflare’s numbers are measured on its hosted service, and the Clef model card says the model was tested on a single H200. The Strands numbers come from a consumer RTX 3090 and an Apple M3 Pro. The Jev median Cloudflare reports for its comparison is 524.1 ms (p95 536.0 ms).

Reading the benchmarks honestly

Cloudflare reports results across 43 evaluation benchmarks in its announcement (the model card says 44 in a “Decision Index” suite; I flag that mismatch). Selected numbers from the announcement and model card:

Benchmark	Clef	Clef-flash	Jev
BFCL, case exact	98.47	98.76	95.75
ToolRet, nDCG@10	69.19	66.43	65.28
BANKING77, macro-F1	94.20	90.93	79.74
CLINC150+OOS, macro-F1	97.43	not retrieved	89.27

Three things stand out. First, Clef-flash edging Clef on BFCL (a function-calling benchmark) shows that for tool-choice style tasks the bigger model is not automatically better, which is useful when the 9B costs 62.5 percent less per input token ($0.09 versus $0.24). Second, the margins over Jev on intent classification are large, but BANKING77 and CLINC150 are well-known public intent datasets, so contamination of any backbone’s pretraining data cannot be ruled out by the vendor’s word alone. Third, one aggregator reports that Jev wins on GPQA Diamond (78.3 versus 48.0) and MMLU-Pro (82.7 versus 65.9). I could not confirm those two figures on a Cloudflare page, so treat them as secondary-source claims, but the direction is plausible and matches the design intent: a decision model is not a reasoning model, and you should not use it to solve hard science questions.

Strands reports its own result on JevBench v1 (231 tasks): 72.3 percent public accuracy, an expected calibration error of 0.052, and a Brier score of 0.342, ranking 3rd of 33 in the 2B class, or 1st of 30 excluding models just over 2B. The repository adds a difficulty split of roughly 100 percent on easy tasks, 87.5 percent on standard and 50.5 percent on hard, and notes a standard deviation of plus or minus 3.2 tasks across retrains, so differences smaller than about 10 tasks between runs should be treated as noise. That candour is more useful to an engineer than the headline rank.

A methodology caveat applies to both vendors: the numbers are self-reported, run by the publisher on suites the publisher selected or helped design. One independent reviewer states plainly that Cloudflare ran the benchmarks and that no independent reproduction existed at the time of writing. Run your own labelled sample before you trust any of it.

Where a decision model sits in the agent loop

Figure 2: Four recurring decision points in an agent loop, each served by the same decision model and gated by a confidence threshold that escalates to an LLM or a human.

The Strands team lists model routing, tool selection, evaluations, guardrails, memory, context management and policy classification as early successful uses. Figure 2 reduces that to four patterns that cover most of my own agent deployments.

1. Model routing. Choose between a small and a large generative model per request. This is the same job as the semantic router pattern, with typed outputs instead of embedding similarity.
2. Tool selection. Given the state and a list of tools, pick one. With dozens of tools, the problem becomes retrieval plus choice; Cloudflare’s ToolRet score (nDCG@10) targets exactly the retrieval half. See how Claude Skills dynamically load agent capabilities for the context-loading side of the same problem.
3. Guardrails. A noul question such as “does this tool call use only values the user supplied” turns a policy into a probability you can threshold.
4. Escalation and triage. Urgency, severity and ownership questions on tickets or alerts.

The unifying design rule is that the decision model never acts alone on a low-confidence answer. The threshold branch in Figure 2 is the reason the pattern is safe, and it is only meaningful if the probabilities are calibrated, which is why both vendors emphasise calibration metrics.

Worked cost arithmetic (illustrative)

Cloudflare bills hosted Clef on input tokens only, since no text is generated. A third-party analysis gives the example of one million decisions with a 2,000-token state: that is 2 billion input tokens, which is $480 on Clef and $180 on Clef-flash at the published rates. I verified the arithmetic: 2,000 tokens times 1,000,000 decisions is 2,000 million tokens, times $0.24 is $480, and times $0.09 is $180.

Two caveats make that a floor rather than a quote. I could not confirm from the Workers AI page whether the question schema counts toward billed input tokens, and a 64-question schema with long instructions is not free. If the schema adds 500 tokens per request, the same million decisions become 2.5 billion tokens, or $600 on Clef and $225 on Clef-flash. That second pair is illustrative arithmetic, not a vendor figure.

Now the comparison that matters is against a generative router. Suppose, purely hypothetically, that a frontier model costs $X per million input tokens and also charges for the roughly 20 output tokens a terse label takes. The decision model removes the output term entirely and typically sits at a lower input rate, but the saving depends on $X, which varies by provider and changes frequently, so plug in your current contract price rather than trusting any number I could print here.

Latency compounds in loops. Illustrative: an agent that makes 10 sequential gating decisions per task spends about 5.2 seconds waiting on a 524 ms decision service, about 2.1 seconds on Clef at 209 ms, and about 0.39 seconds on Clef-flash at 38.8 ms (medians, ignoring network and queueing). The same 10 decisions on a local Strands Decider at 115 ms take roughly 1.15 seconds on an RTX 3090, on different hardware and a different test than Cloudflare’s. For interactive agents, that arithmetic, not the accuracy delta, is usually what justifies the move.

Self-hosting economics follow from throughput. At 115 ms per decision, a single serial stream on one RTX 3090 handles roughly 8.7 decisions per second, or about 31,000 per hour, so one million decisions would take around 32 hours on one stream. The vendors do not publish batched throughput in the sources I read, and batching a prefill-only model is typically very effective, so measure before sizing hardware. For a local-first view of what consumer silicon can sustain, see our analysis of the AMD Ryzen AI Max Pro 400 as a local LLM inference workstation.

Placement of each model

Figure 3: Where each decision model fits by size, measured latency and hardware. Latencies come from different vendors and different hardware and are not directly comparable.

Figure 3 is a placement heuristic, not a ranking. Strands Decider fits edge and on-device flows, where data must not leave the machine and the decision is simple enough for a 2B torso. Clef-flash fits high-volume gates on a hosted API where tens of milliseconds matter. Clef fits harder or multimodal decisions, such as classifying a screenshot, where the extra capacity and the vision path justify roughly five times the median latency of the flash model. Image requests need extra caution: an independent test reported 13 to 30 seconds of image-request latency on launch day and context errors for images above roughly 190 KB, which may be launch-day behaviour but should be re-tested before you rely on the vision path.

Decision matrix

Use case	Strands Decider 2B	Clef-flash 9B	Clef 27B	Generative LLM router
High-volume tool gating, text only	Good if self-hosted and accuracy suffices	Best default for hosted latency	Overkill unless accuracy gaps appear	Too slow and costly
Privacy-bound or offline edge agent	Best fit, runs on CPU, GPU or Mac	Self-host needs a bigger GPU	Needs H200-class hardware as tested	Depends on local model
Screenshot or image classification	Not supported	Verify image support first	Designed for it	Strong but expensive
Ambiguous, reasoning-heavy judgment	Weak, hard-task accuracy 50.5 percent on JevBench	Weak to moderate	Moderate, still not a reasoner	Best choice
Auditable, retrainable pipeline	Training data and scripts published	Fine-tuning service planned	Data not published	Vendor dependent

Trade-offs, Gotchas, and What Goes Wrong

Decision models trade generality for speed, and the trade has sharp edges. The first is that they cannot do anything else. Strands states directly that its model cannot generate text and is unsuited to coding, chatbots and summarization, and that it is significantly worse at complex problems than reasoning models. The same logic applies to Clef. If a decision needs multi-step inference, such as working out whether a refund policy applies given three interacting clauses, a closed-form scorer will give you a fast, confident and possibly wrong probability.

Figure 4: Request flow with a confidence gate. High-confidence answers are taken directly, low-confidence ones escalate to a larger model, and sampled cases feed human labels back for recalibration.

Calibration is a claim you must re-verify

The entire safety story in Figure 4 depends on probabilities meaning what they say. An expected calibration error (ECE) of 0.052, as Strands reports on JevBench v1, means that on that benchmark the model’s stated confidence deviates from its observed accuracy by about five percentage points on average. That is encouraging, but it was measured on one distribution. Calibration degrades under distribution shift: your tickets, your tools and your jargon are not the benchmark. A model that is well calibrated on banking intents can be overconfident on industrial maintenance logs.

The Brier score, which both vendors reference, is the mean squared difference between predicted probability and the 0/1 outcome. A tiny worked example (illustrative) shows why it punishes overconfidence: predicting 0.9 for an event that happens costs (1 – 0.9)^2 = 0.01, but predicting 0.9 for an event that does not happen costs 0.9^2 = 0.81, eighty-one times more. Training with a Brier term, as Cloudflare describes, pushes the model toward honest probabilities, but it does not guarantee them off-distribution.

Closed answer spaces hide bad schemas

Because the model must pick from your options, a poorly designed schema silently forces a wrong answer. If you ask “which team handles this?” with options billing, sales and retail, a request about a security incident will still be assigned to one of them, possibly with moderate confidence. Always include an explicit “other” or “none” option, or pair the choice with a noul question such as “does this request fit any listed team?” The noul type is cheap, and per-request limits allow 1 to 64 questions, so a gating question next to the main question costs little.

Multi-question coupling

Cloudflare’s design lets questions in one request cross-attend, which can help or hurt. If questions are well-formed, shared context improves consistency. If one question is ambiguous or adversarial, it may bleed into the others. Test by comparing answers to the same question asked alone and asked alongside 20 others. If they diverge materially on your data, split the request.

Prompt injection and untrusted state

The state often contains attacker-controlled text: an email body, a web page, a tool result. A generative router can be talked into emitting a different label. A decision model cannot emit an out-of-schema answer, which reduces the attack surface, but it can still be steered inside the allowed options by text like “this is urgent”. Treat the output as a recommendation that passes through policy, not as authorization. For anything that spends money or deletes data, the decision model should only narrow the choice and a deterministic check or a human should confirm.

Operational and vendor-risk issues

Open weights are not the same as operational independence. The hosted Clef path depends on Workers AI, and one independent test measured text requests from one location averaging between 191 and 726 ms depending on model size, a spread wide enough that network placement matters as much as model choice. Self-hosting Clef at the tested configuration implies an H200-class GPU in BF16, which is a real fixed cost compared with the per-token rate. Cloudflare also describes a forward-deployed fine-tuning service, with a self-serve data capture, fine-tune and redeploy flow planned rather than shipped at announcement; do not architect around it until it exists.

The Qwen lineage matters for compliance reviews. Clef’s license is stated as Apache 2.0, following its Qwen base model, so check whether your policy covers derived models from a given upstream provider. Finally, versions move: Strands says its release is “v19, with lots of iterations under the covers,” so pin checkpoints by name and re-run your evaluation set whenever you upgrade.

Practical Recommendations

Start by treating a decision model as a replaceable component behind your own interface. Both vendors converge on the Jev-compatible shape of a state, a map of typed questions and typed answers, so write one thin adapter and keep your prompts, schemas and thresholds in your code. That lets you swap Strands Decider, Clef-flash or a future model without touching the agent logic, and it lets you shadow-test two models on the same traffic.

Pick the first model by constraint, not by benchmark. If data cannot leave your environment or you need sub-second decisions on a laptop or edge box, begin with Strands Decider. If you run on Cloudflare already and want a hosted gate, begin with Clef-flash and escalate to Clef only for decisions where an evaluation shows a gap. If you must classify images, test Clef’s vision path on your real images, including their sizes, before committing.

Build the evaluation set before the integration. Hand-label two or three hundred real states per decision type, include the ambiguous and adversarial ones, and measure accuracy, ECE and the accuracy of high-confidence answers specifically. The number that determines whether the pattern pays for itself is the fraction of traffic that clears the confidence threshold with acceptable accuracy; everything else is secondary. Our write-up on agent evaluation harnesses and trajectory evals covers how to run such a set continuously.

Rollout checklist

• Wrap the model behind one adapter that speaks state, questions and typed answers.
• Add an explicit “other” or “none” option to every choice question.
• Label 200 or more real examples per decision and measure accuracy and ECE yourself.
• Set the confidence threshold from your own calibration curve, not the vendor default.
• Route low-confidence cases to a larger model and sample them for human labels.
• Never let a decision model alone authorize irreversible actions.
• Log the full probability vector, not just the top option, for later recalibration.
• Pin the exact checkpoint or model ID and re-run the evaluation on every upgrade.
• Re-test image paths and latency from your own region before production.
• Record the licence and upstream base model for compliance.

Frequently Asked Questions

What is a decision model in AI?

A decision model is a small language-model-based classifier that returns typed probabilities rather than generated text. You give it a state and a schema of questions such as yes/no, pick one of N, or rate on an ordered scale, and it scores only the options you allowed. Because nothing is generated, it is faster and cheaper than prompting a chat model, and its answers cannot fall outside your schema. It is designed for routing, tool selection, guardrails and triage, not for open-ended reasoning or writing.

What is Cloudflare Clef?

Cloudflare Clef is a 27B-parameter open-weight decision model released on October 1, 2026 under Apache 2.0. It is post-trained from a Qwen backbone, accepts text and images, supports a 65,536-token context window, and returns probabilities for typed noul, choice and score questions. A 9B variant, Clef-flash, targets lower latency. Both are available on Workers AI with Jev-compatible requests, and the weights are on Hugging Face. Cloudflare has not published the training data or full pipeline.

How much does Cloudflare Clef cost?

On Workers AI, Clef is priced at $0.24 per million input tokens and Clef-flash at $0.09 per million input tokens, with no output-token charge because no text is generated. As an illustration, one million decisions with 2,000-token states equals 2 billion input tokens, or about $480 on Clef and $180 on Clef-flash. Whether the question schema counts toward billed tokens was not clear in the pages I read, so check your own usage metrics. Self-hosting trades per-token fees for GPU costs.

What is Strands Decider 2B?

Strands Decider 2B is an Apache 2.0 decision model from Strands Labs at Amazon, released October 1, 2026. It uses a Qwen3.5-2B torso with a rank-16 LoRA adapter and a pointer head of about one million parameters, for 1.9 billion parameters in total. It runs locally on a CPU, consumer GPU or Apple silicon, with a reported median of about 115 ms on an RTX 3090. It supports choice, noul and score questions and cannot generate text.

How do decision models differ from LLM routers and classifiers?

A generative LLM router writes a label as text, which costs output tokens, adds latency and can drift outside the allowed set. A traditional classifier is fast but needs training data for every fixed label set. A decision model accepts the labels at request time in natural language, like an LLM, but scores them in one forward pass, like a classifier, and returns calibrated probabilities you can threshold. Its weakness is that it cannot reason through hard cases, so keep an escalation path.

Can I trust the vendor benchmarks?

Treat them as directional. Cloudflare’s results across its benchmark suite and Strands’ JevBench results were produced by the publishers, and at launch no independent reproduction existed. Public intent datasets such as BANKING77 may overlap with backbone pretraining data. Strands is unusually candid that differences under about 10 tasks between retrains are noise. The reliable approach is to label a few hundred of your own examples, measure accuracy and expected calibration error, and set confidence thresholds from that evidence.

Further Reading

• LLM semantic router: the inference routing pattern for the routing half of the same problem.
• AMD Ryzen AI Max Pro 400 as a local LLM inference workstation for self-hosting hardware context.
• Claude computer use architecture for desktop agents for long agent loops that need fast gating.
• Claude Skills architecture for dynamic LLM agents for capability loading and tool-selection context.
• Cloudflare: Clef decision models announcement
• Strands Agents: Introducing Strands Decider

References

1. Cloudflare, “Clef decision models” announcement, blog.cloudflare.com/clef-decision-models/ (accessed 2026-10-04).
2. Cloudflare, Clef model card, huggingface.co/Cloudflare/clef (accessed 2026-10-04).
3. Cloudflare, Workers AI model documentation for Clef, developers.cloudflare.com/workers-ai/models/clef/ (accessed 2026-10-04).
4. Strands Agents, “Introducing Strands Decider,” strandsagents.com/blog/introducing-strands-decider/ (accessed 2026-10-04).
5. Strands Labs, strands-decider repository and README, github.com/strands-labs/strands-decider (accessed 2026-10-04).
6. MarkTechPost, coverage of Clef and Strands Decider 2B, October 1, 2026 (secondary).
7. Developers Digest and Flavio Copes independent write-ups on Clef pricing and launch-day testing (secondary).

By Riju – about