Clef Flash on Ollama: Cloudflare's 9B decision model, hands on

Cloudflare's Clef Flash has landed on Ollama — a 9B model that doesn't chat, doesn't write, and just makes decisions, fast. Here's what it is, what hardware it wants, and how to run it.

Listen to this post · 11 min

Accessibility: the whole post is read aloud — Space plays or pauses, ← → skip 10 seconds, and you can change the speed. It keeps playing with your screen locked.

Share this post

In short

  • Clef Flash is a 9B decision model from Cloudflare, fine-tuned from Qwen3.5-9B, on the Ollama library as of today (14 October 2026) — Apache 2.0, 11–12GB download.

Most new models landing on Ollama are chat models with better benchmarks. Clef Flash, which appeared on the Ollama library as of today (14 October 2026), is something else entirely: a 9B decision model from Cloudflare that you don't talk to at all. You hand it a state — text, JSON, or images — plus a schema of typed questions, and it hands back decisions with probabilities. If you build agents, routing, or policy checks that run locally, it's worth ten minutes of your afternoon.

What is Clef Flash?

Clef Flash is a 9B multimodal decision model from Cloudflare, fine-tuned from Qwen3.5-9B, now on the Ollama library. It's Apache 2.0 licensed.

The key thing to understand: it's not a chat model. There's no conversation. You give it a state (a string, a JSON object or array, or images) and a set of typed questions, and it returns decisions — each with probabilities. It reads images too: screenshots, receipts, forms, photos, scored jointly with the text state.

It's also the fast sibling in Cloudflare's lineup. The readme says Clef Flash had the lowest measured latency of any decision model in Cloudflare's Decision Index runs, and the larger 27B Clef is roughly five times slower. That latency claim is Cloudflare's own; we haven't independently measured it, and there's no third-party data yet.

How it decides: one forward pass, typed answers

Here's the genuinely different bit. A normal model generates answers token by token. Clef Flash scores every option of every question jointly in a single non-autoregressive forward pass — no generation loop at all. The readme's example request reports 3 output tokens. That's why it's fast: the expensive part of running an LLM simply isn't happening.

There are three question types:

  • choice — 2 to 26 options, each optionally described in criteria. Returns the chosen option, a probability for every option, and a confidence value.
  • noul — a yes/no question. Returns the probability that the answer is true.
  • score — 2 to 26 ordered levels (lowest first, numbered from 0). Returns a probability-weighted level, the legend, per-level probabilities, and confidence.

You can ask up to 64 named questions per request, and answers come back in the same order you asked them.

Two gotchas worth flagging. First, confidence runs 0–1 and shows how concentrated the probabilities are — the readme is explicit that it isn't the chance the answer is right. A model can be confidently wrong. Second, ties follow the model's option order, so put your preferred option first when you build the schema.

Sizes, memory and the hardware you'll need

There's a single size: 9b. Both clef-flash:latest and clef-flash:9b list the same 11–12GB download and 256K window, so they appear to be the same model.

The usual rule of thumb applies: a model needs roughly its file size in RAM or VRAM, plus room for context. On that basis, budget 12–16GB minimum. That puts Clef Flash in gaming-GPU territory:

  • 16GB cards (an RTX 4080 or 4060 Ti 16GB, say, or an older 24GB card) should run it comfortably.
  • Macs with 16GB+ unified memory should work too.
  • 8GB cards and most laptops will likely need to offload some layers to CPU. It'll run, but you lose the latency advantage that is the entire point of this model — at that point a smaller decision model or a prompted small chat model may serve you better.

On context: the Ollama library page lists a 256K window, but the model's own readme says 64K — "twice the state Jev's 32K window holds". We'd treat the readme's 64K as the safe planning number until that's clarified. Either way, you'll rarely get near it: a decision model consumes long states, not long generations, and the output is a handful of tokens.

How to run it locally

First, check your version — Clef Flash requires Ollama 0.35.1 or later. If you need to upgrade, our Ollama guide covers installation.

ollama pull clef-flash
# or just:
ollama run clef-flash

Because it's not conversational, the interesting interface isn't the terminal — it's the API. Clef Flash is fully compatible with the Jev and System One APIs, so it works through Ollama's /v1/systemone endpoint. You put the text to judge in state and your questions in questions; Ollama builds the prompt for you, so you never hand it raw text.

Here's the readme's worked example — a support-ticket triage that uses all three question types in one request:

curl http://localhost:11434/v1/systemone -d '{
  "model": "clef-flash",
  "state": "Checkout has been failing for every customer for the last hour.",
  "questions": {
    "urgent": {"type": "noul", "instructions": "Is this support request urgent?"},
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this request?",
      "criteria": {
        "billing": "Payments, invoices, and refunds",
        "technical": "Outages, errors, and configuration",
        "sales": "Plans and upgrades"
      }
    },
    "severity": {
      "type": "score",
      "instructions": "How severe is the customer impact?",
      "criteria": ["No impact", "Minor", "Major", "Critical"]
    }
  }
}'

The response comes back with urgent as a probability, team as a choice with per-option probabilities, and severity as a weighted level with its legend — 486 input tokens, 3 output tokens in the readme's example.

Images go in the optional images field: base64-encoded PNG, JPEG or WebP, shared by all questions, in request order. URLs and data URLs aren't supported, so you'll be doing the encoding yourself.

For Python, use TypeSafe's official SDK pointed at Ollama:

pip install typesafe-sdk
export TYPESAFE_BASE_URL=http://localhost:11434
export TYPESAFE_API_KEY=ollama
export TYPESAFE_DEFAULT_MODEL=clef-flash

The SDK requires an API key, but Ollama ignores it — any value works.

One honest caveat: the Ollama page is the only documentation we've seen. We couldn't find LM Studio, llama.cpp or vLLM instructions as of today, so if you run something else as your main engine, you may be waiting. Other engines may follow, but nothing is confirmed.

What it's good for — and what it isn't

The readme lists four patterns:

  • Route a request — you define the destinations and when each applies; you get the chosen destination plus each destination's probability.
  • Check a condition — a yes/no question and evidence in; true or false with probabilities out.
  • Apply a policy — rules and allowed outcomes in; a typed decision on the text or images you supply.
  • Gate an agent step — a condition and the agent's proposed tool call in; go or no-go, with the probability of each.

That last one is the case local-AI builders should notice. A cheap, fast, schema-shaped check before an agent does something expensive or risky — a tool call, a file write, a spend — is exactly the kind of component that's been awkward to build with chat models, where you parse prose and hope. Here the output shape is guaranteed.

The limits are equally clear. It's a decision model, not a general assistant: don't expect it to write, summarise or chat. Images must be base64 in the request. Sixty-four questions max. And if you want accuracy over speed, Cloudflare points to the larger Clef (27B, roughly five times slower).

And to repeat, because it's an easy trap: confidence is about probability concentration, not correctness.

How it compares with what you might run instead

Clef FlashClef 27BJevChat model, prompted
Size9B, 11–12GB download27B—varies
Context256K listed / 64K per readme—32Kvaries
ModalityText + images——varies
OutputTyped decisions, probabilitiesTyped decisionsTyped decisionsProse you parse
SpeedLowest latency in Cloudflare's Decision Index runs~5x slower—Autoregressive
LicenseApache 2.0——varies

The nearest thing you might already run is a guard model — llama-guard3:1b or granite3-guardian:2b. Those overlap on the "gate an agent step" use case, but they answer a fixed safety schema. Clef Flash takes your schema — your destinations, your severity levels, your policy outcomes. That's the real differentiator: it's a guard-rail architecture applied to arbitrary decisions.

The other comparison is just prompting a chat model to answer questions. That works and it's flexible, but it's autoregressive, there's no typed schema, and no joint scoring across options — plus you're back to parsing prose. For latency-critical paths, that gap is the whole pitch.

On hardware: it's fine-tuned from Qwen3.5-9B, so if you already run models in that weight class, you're in familiar territory — same order of memory budget, different job.

Worth a look if you build decision steps

If you're already on Ollama 0.35.1+ with a 16GB-class GPU or Mac, this is a low-effort experiment — one pull command and a cURL. If you build anything with routing, gating or policy checks, try it before reaching for a prompted chat model; the typed output alone saves real glue code.

If you'd rather poke at decision-adjacent models without setting anything up, the marketplace has guard and small models callable through one API. And if you've got a 16GB+ GPU sitting idle, hosting open models on it is a way to earn from hardware that's otherwise doing nothing.

Questions people ask

What is Clef Flash?

A 9B multimodal decision model from Cloudflare, fine-tuned from Qwen3.5-9B, on the Ollama library as of 14 October 2026. You give it a state (text, JSON or images) and up to 64 typed questions, and it returns decisions with probabilities in a single forward pass. Apache 2.0 licensed.

Models in this post — live on Inpherio

Have a GPU, a Mac or a spare PC?

Let it earn while you sleep.

Run open models for people who need them. You set the price and keep everything but the 15% fee.

Become a host

Building with AI?

Every open model, one API.

OpenAI-compatible. Priced by the people who run the hardware.

Start free See the marketplace

Read “Clef Flash on Ollama: Cloudflare's 9B decision model, hands on” at https://inpherio.co.uk/blog/clef-flash-on-ollama-cloudflare-s-9b-decision-model-hands-on