Clef-Flash vs Qwen3.5-9B: same base weights, different job
Clef-Flash is post-trained from Qwen3.5-9B, so the fair question is not “which model is smarter” but “which output contract fits the job”. Here are the verified specs, the real prices, and the cases where the base model wins.
The short answer
Qwen3.5-9B is a general multimodal language model. You give it a prompt and it writes text back: an answer, a draft, a tool call, or a block of JSON if you ask carefully. Clef-Flash takes the same 9B base and post-trains it to return a probability for every allowed option in a typed schema, in a single forward pass.
If your program ends with “write something and then parse it”, the base model is the flexible choice and the cheaper self-hosted option. If your program ends with “pick one of these six labels and tell me how confident you are”, Clef-Flash removes the parsing step and the malformed-output failure mode entirely.
Neither verdict is universal. The rest of this page gives the numbers behind both, including the areas where Qwen3.5-9B is clearly ahead.
Specifications, side by side
Everything in this table comes from the two model cards and the Cloudflare pricing page, read on 21 October 2026. Where a number is published for one model and not the other, the cell says so instead of guessing.
| Specification | Clef-Flash | Qwen3.5-9B |
|---|---|---|
| Parameters | 9B, post-trained from Qwen3.5-9B | 9B (the Hugging Face repo metadata lists 10B params) |
| License | Apache 2.0 | Apache 2.0 |
| Context window | 64K on the model card; 24,576 through this API | 262,144 tokens natively, extensible to 1,010,000 |
| Output | A probability for every allowed option, plus the winner | Free-form text, tool calls, or JSON under prompt guidance |
| Vision | Built-in vision encoder | Multimodal, with a published MMMU of 78.4 |
| Published benchmarks | About 39 ms median latency and 122 ms at p95 | MMLU-Pro 82.5, GPQA Diamond 81.7, MMMU 78.4 |
| Input price on this API | $0.019 per million input tokens (upstream) | Not quoted in this comparison; check the current Workers AI model page |
| Release | 1 October 2026 | February 2026 |
| Local memory | About 41 GB of VRAM for full-precision inference | Quantised Ollama builds: 6.6–7.6 GB for qwen3.5:9b, 8.9 GB for the MLX tag |
The output contract is the real difference
With a language model, structure is a request, not a guarantee. You can use JSON mode, a schema in the prompt, or a constrained decoder, and every one of those approaches still needs a validation layer and a retry path for the case where the model returns something your parser rejects. That layer is not free: it is code, tests, and a failure mode that appears in production at the least convenient time.
Clef-Flash moves the constraint into the model. You send a state and a schema of typed questions, and the response is a distribution over the options you allowed. There is nothing to parse, and the model cannot answer outside the schema because the schema defines the answer space.
The trade is flexibility. A language model can summarise a ticket, write a reply, and then classify it. Clef-Flash only does the last part. If your pipeline needs the prose as well, you will run a language model anyway and the decision call may be a second step.
Benchmarks: what can and cannot be compared
The Qwen3.5-9B card publishes academic benchmarks: MMLU-Pro 82.5, GPQA Diamond 81.7, and MMMU 78.4. Those measure general knowledge, graduate-level reasoning and multimodal understanding. They are useful for comparing Qwen3.5-9B with other general models.
Cloudflare publishes latency for Clef-Flash: roughly 39 ms median and 122 ms at p95. A latency figure is not a quality figure. There is no shared benchmark that scores both models on the same decision task, and this page will not invent one by comparing a reasoning score with a millisecond count.
The practical consequence is that you cannot pick between them from published numbers alone. You have to run your own labelled sample through both and measure agreement with your ground truth. The test protocol is at the end of this page.
What a decision costs on Workers AI
Cloudflare lists Clef-Flash at $0.038 per million input tokens on Workers AI, which it also expresses as 3,455 neurons per million input tokens; this deployment is charged $0.019 upstream through OpenRouter. Workers AI bills at $0.011 per 1,000 neurons and includes 10,000 free neurons per day.
Those two numbers make the free allowance easy to read: 10,000 neurons per day is roughly 2.9 million Clef-Flash input tokens per day at the listed rate. For a request of about 600 tokens, a paid call costs a small fraction of a cent, and the daily free allowance covers thousands of decisions.
Self-hosting has the opposite shape. The marginal cost of a decision is near zero once the hardware exists, but the hardware requirement is the published 41 GB of VRAM, and idle GPUs are not free either. Cloudflare’s own blog material positions the model for teams that want the weights; the hosted price exists for teams that do not want to own the machine.
Running Qwen3.5-9B yourself
The Ollama library lists qwen3.5:9b at 6.6–7.6 GB, with an MLX tag at 8.9 GB for Apple silicon. Those are quantised builds, which is why they fit on consumer hardware that could not hold the full-precision model.
Quantisation is a real trade, not a free lunch. It reduces memory and usually increases throughput, and it can shift behaviour on edge cases. If you are evaluating a quantised build against Clef-Flash, evaluate the build you will actually deploy, not the full-precision model card.
The same rule applies to Clef-Flash: the 41 GB figure is the published local requirement, and community MLX 4-bit conversions exist on Hugging Face. Test the artefact you intend to ship.
Context length: 24,576 served against 262k
Qwen3.5-9B documents a native context of 262,144 tokens, extensible to 1,010,000. Clef-Flash’s model card documents 64K, of which this API reads 24,576.
For decision work, this rarely matters. A support ticket, a moderation item, a document classification, or a set of video frames almost always fits inside 24,576 tokens, and a decision model only reads the state once. If your state is a 200-page contract and the question is about a clause on page 180, the base model’s longer window is a genuine advantage.
Long context is also not the same as long-context accuracy. A model that accepts 262k tokens does not automatically retrieve the right detail at 262k. If you need long-document decisions, test retrieval quality at your real document length rather than trusting the window size.
Where Qwen3.5-9B is the better choice
Be honest about this list; it is longer than a vendor page usually admits.
- You need free-form output. Summaries, rewrites, chat, explanations and multi-turn prose are language-model work.
- You need a very long context. 262k native beats 24,576 when the state is a long document or a large transcript.
- You want to fine-tune on your own labels with standard tooling. The base model is the conventional starting point and the ecosystem is larger.
- You need multilingual coverage well beyond English. The Qwen card claims 201 languages and dialects; Clef-Flash’s card does not publish a language list.
- You are cost-sensitive at high volume and already own the GPU. Quantised local inference has the lowest marginal cost per call.
Where Clef-Flash is the better choice
The case for the decision model is narrow but sharp.
- The answer must be one of a fixed set of options, and the program needs a confidence number rather than a sentence.
- You want to delete the parsing and retry layer, not maintain it.
- You need the decision inside a request path. A published median of about 39 ms is fast enough to sit in front of a user action.
- You want a hosted endpoint without owning a GPU. Workers AI lists $0.038 per million input tokens and a daily free neuron allowance; this API’s own upstream rate is $0.019.
- You want one call, one response, one schema, and no prompt that tries to talk a generative model into behaving like a classifier.
Who this page is for, and who it is not for
This comparison is for engineers choosing between a general open-weight model and a decision model for a bounded classification or routing task: ticket triage, moderation, intent routing, document type detection, or an agent choosing among a fixed set of tools.
It is not for teams that need a chat product, a writing assistant, or an agent that must reason in open-ended prose. In those cases the base model is the right tool and the comparison is over before it starts.
It is also not a claim that Clef-Flash is universally more accurate. Cloudflare publishes latency, not a decision accuracy table, and no third party has published a head-to-head on a shared labelled set. Anyone who tells you otherwise is quoting a benchmark that does not exist.
A test protocol you can run in an afternoon
Pick 100 real items from your own queue, label the correct answer for each, and keep the labels out of both prompts.
Run the items through Clef-Flash with your schema, and through Qwen3.5-9B with a JSON instruction and your validation layer. Record the answer, the confidence where available, and whether the response parsed on the first attempt.
Then compare three numbers: agreement with your labels, the share of responses that needed a retry, and the p95 latency of the whole call including parsing. The third number is where the decision model usually wins, and the first is where the result is genuinely uncertain until you measure it.
Run the same test again on a quantised build if you plan to self-host. The deployable artefact is the one that matters.
Sources
All competitor figures were read on 21 October 2026. Model cards and prices change; verify before you commit.
Qwen3.5-9B model card: https://huggingface.co/Qwen/Qwen3.5-9B — parameter count, 262,144-token native context, Apache 2.0 licence, 201 languages, MMLU-Pro 82.5, GPQA Diamond 81.7, MMMU 78.4, February 2026 release.
Ollama library, qwen3.5: https://ollama.com/library/qwen3.5 — tag list, download sizes of 6.6–7.6 GB for qwen3.5:9b and 8.9 GB for the MLX tag.
Cloudflare Workers AI pricing: https://developers.cloudflare.com/workers-ai/platform/pricing/ — Clef-Flash at $0.038 per million input tokens on Workers AI (3,455 neurons per million input tokens), $0.011 per 1,000 neurons, 10,000 free neurons per day; this deployment is charged $0.019 upstream.
Frequently asked questions
Is Clef-Flash just a fine-tuned Qwen3.5-9B?
Cloudflare describes Clef-Flash as a 9B multimodal model post-trained from Qwen3.5-9B. The weights and the licence carry over; the behaviour does not. Clef-Flash returns typed decisions with probabilities instead of free-form text.
Can Qwen3.5-9B do the same job with JSON mode?
It can produce JSON when asked, and the Qwen card documents tool calling and prompt-based output formats. The difference is the guarantee: with a generative model you still validate and retry; with a decision model the allowed answers define the output space.
Which one is cheaper?
Per call, a hosted Clef-Flash decision is very cheap: Workers AI lists $0.038 per million input tokens and includes 10,000 free neurons per day, while this API is charged $0.019 upstream. Per month, self-hosted Qwen3.5-9B can be cheaper at high volume once you already own the GPU. Compare at your real volume, including the cost of the parsing and retry code.
Does Clef-Flash support a 262k context like Qwen3.5-9B?
No. Clef-Flash’s model card documents 64K tokens, and this API reads 24,576 of them. Qwen3.5-9B documents 262,144 tokens natively, extensible to 1,010,000. If your state is a long document, that difference matters.
Can I fine-tune Clef-Flash on my own labels?
Cloudflare’s release includes reinforcement-learning fine-tuning aimed at exactly that case, and the Apache 2.0 licence permits it. Check the current Cloudflare documentation for the supported recipe before planning a training run.
Do both models run on Ollama?
Yes. Qwen3.5-9B is in the Ollama library at 6.6–7.6 GB for the 9b tag, plus MLX builds for Apple silicon. Clef-Flash is also published for Ollama under the clef-flash tag.
What should I measure before choosing?
Agreement with your own labels on 100 real items, the share of responses that needed a retry, and p95 latency for the whole call including any parsing. Published benchmarks do not cover a shared decision task, so your labelled sample is the only honest comparison.
Keep reading
Model notes
One short email when a new decision model lands or a benchmark changes. No spam, unsubscribe in one click.