Clef-Flash

Clef-Flash

Turns a state and a set of typed questions into decisions, returning a probability for every option of every question in one pass, with no free text. A 9B multimodal model from Cloudflare for developers.

Made by Cloudflare on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Clef-Flash is a 9B multimodal model from Cloudflare, post-trained from Qwen3.5-9B. You give it a state and a list of typed questions. The state can be plain text, a JSON record, pictures or video. In one pass the model gives back a probability for every answer option of every question. It writes no free text, so there is nothing to parse.

Who it suits: Developers who want a model to make routine decisions, such as sorting messages or judging records, and want probabilities back instead of prose.

Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route and rank incoming messages | Deciding which team should handle a message
Finance operations | Billing teams | Classify records by status | Judging whether an invoice is overdue
Software development | Backend developers | Add a decision step to a service | A yes or no check on a message's urgency
Content review | Operations teams | Judge images and video against rules | A typed question about a picture

If you want a model that writes answers or chats, you can skip it, because it only returns option probabilities.

Where to use it:

• Python with torch and transformers, on a CUDA GPU
• SGLang, which can serve it, with launch notes for H200, B200 and B300 GPUs
• Services that speak the Jev or SystemOne request format

Use case | Who | What they get back
Message triage | Support teams | A probability for each team or urgency option
Record checks | Finance teams | Probabilities for choice, score or yes-no questions
Multimodal decisions | Developers | Probabilities from text, JSON, images or video input

How to set it up:

• Python with the torch and transformers packages
• A CUDA GPU, since the card's example runs on one (it was tested on a single H200)
• The pillow package, if you send images or video
• About 18.8 GB of disk space in BF16, or about 4.7 GB at 4-bit (an estimate)

1. Install the Hugging Face hub tools.
2. Download the model files.
3. Run the Python example from the card, which loads the model and asks two questions.

pip install -U huggingface_hub
hf download Cloudflare/clef-flash

How to use it: Build a record with a state and a set of questions. Each question has a type, an instruction and, for choice questions, the criteria for each option. Encode the record, run the model and apply a softmax to each question's logits to get probabilities.

import sys

import torch
from huggingface_hub import snapshot_download

path = snapshot_download("Cloudflare/clef-flash")
sys.path.insert(0, path)
from joint_schema_model import collate_records, encode_record, load_release_model

model, processor = load_release_model(path, device="cuda")

record = {
    "state": {"invoice": {"vendor": "Acme", "total": 1250.0, "currency": "USD", "status": "overdue"}},
    "questions": {
        "status": {
            "type": "choice",
            "instructions": "What is the invoice status?",
            "criteria": {"paid": "Invoice is paid.", "overdue": "Invoice is past due.", "draft": "Not sent."},
        },
        "large": {"type": "noul", "instructions": "Is the total above 1000 USD?"},
    },
}

encoded = encode_record(processor.tokenizer, record, processor=processor)
batch = collate_records([encoded], processor.tokenizer.pad_token_id, torch.device("cuda"))
with torch.inference_mode():
    logits = model(batch)[0]

for question, question_logits in zip(encoded.questions, logits):
    probabilities = question_logits.float().softmax(-1).tolist()
    print(question.question_id, dict(zip(question.option_ids, probabilities)))

Tool | What it does
load_release_model | Loads the model and its processor
encode_record | Turns a state and questions into model input
collate_records | Batches encoded records for the model
systemone | Answers a request written in the Jev or SystemOne format

Example: You give it an invoice from Acme for 1,250 USD marked overdue. You ask for its status, with paid, overdue and draft as options, and whether the total is above 1,000 USD. It returns a probability for each status option and one for the yes-no question.

For newcomers and experts: If you are new to this, run the card's invoice example first and read the printed probabilities. Each number is how likely that option is, and the numbers for one question add up to one.

Underneath, the Qwen3.5-9B backbone and its vision encoder feed a small joint schema head. The head picks out the parts of the state that matter for each question, then scores every option of every question at once. The output is one logit per option, and a softmax per question gives the probabilities. A larger variant called Clef also exists.

You write a state and typed questions
The backbone reads the state
The joint head scores every option
You apply a softmax per question

Good to know:

• Question types: choice, score and noul, where noul returns the probability of true
• Output: a choice answer has the choice, a confidence and probabilities, and a score answer adds an expected score and a legend
• License: Apache-2.0
• Cost to run: no API key or paid service is named, only a GPU
• Data it reaches: the local example downloads the model and reads the record you build, and the card names no other access
• Not for: free-form text generation, which the card says it does not do

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 9.4B
• Weights: about 18.8 GB in BF16; about 4.7 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 36,799
• Likes: 919
• License: apache-2.0
• Based on: Qwen/Qwen3.5-9B
• Quantized versions: 63
• Fine-tunes: 15
• Tags: transformers, safetensors, qwen3_5, image-text-to-text, clef, cloudflare, systemone, decision-model, qwen3.5, post-train, image-text-to-typed-output, multimodal

Links

• Model: https://huggingface.co/Cloudflare/clef-flash
• Files: https://huggingface.co/Cloudflare/clef-flash/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Cloudflare/clef-flash

Then follow the usage in its model card. Nothing in this kit runs by itself.