Clef

Clef

Cloudflare's 27B multimodal model that scores the allowed answers to typed questions about a text, JSON, image or video input, instead of writing free text.

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 is a 27B multimodal model from Cloudflare. You give it a situation and a list of questions that each have fixed answer options. It scores every option of every question in one pass, so you get probabilities instead of a written reply.

The situation can be text, JSON, images or video. Clef is post-trained from Qwen3.8-27B and adds a small head that scores all the options together.

Who it suits: It suits teams that need a model to make a structured decision, such as sorting a message or labeling a record, and want numbers they can act on. The card describes its API as compatible with Jev and SystemOne.

Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route messages to the right team | Choosing between billing and technical
Finance operations | Back-office teams | Classify records by status | Reading an invoice as paid, overdue or draft
Software | Backend developers | Add a decision step to a workflow | Checking whether a message sounds urgent
Data teams | Analysts | Label inputs against a fixed set of answers | Scoring a record on a named scale

Skip it if you need free-form writing, since this model does not generate text.

Where to use it:

• Python, with the model loaded through the repository's own helper file
• SGLang, which can serve it, with Docker on a single H200 shown in the card
• Any service that speaks the Jev or SystemOne request format
• Windows, macOS or Linux for the file download

Use case | Who | What they get back
Triage a message | Support teams | A probability for each team that could handle it
Classify a record | Operations teams | A probability for each allowed status
Yes or no checks | Developers | The probability that a statement is true

How to set it up: You need a few things in place first.

• Python with torch and transformers
• pillow, if you send images or video
• A large GPU, as the card was tested on one H200
• About 54.7 GB of disk for the BF16 weights, from the record

1. Download the repository with the hf command.
2. Load the model with the helper function in the repository.
3. Build a record with a state and your questions, then run it.

pip install -U huggingface_hub
hf download Cloudflare/clef

How to use it: You write a record with a state and a set of questions. Each question has a type, its instructions and, for a choice, the allowed options. The helper encodes the record, runs the model and returns one score per option. A softmax per question turns them into probabilities.

import sys

import torch
from huggingface_hub import snapshot_download

path = snapshot_download("Cloudflare/clef")
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)))

To serve it, the card shows a Docker command that starts SGLang on a single H200.

docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --ipc=host \
  lmsysorg/sglang:dev-clef \
  sglang serve \
    --model-path Cloudflare/clef \
    --host 0.0.0.0 \
    --port 30000

Tool | What it does
load_release_model | Loads the backbone and the scoring head from the downloaded folder
encode_record | Turns a state and its questions into model input
systemone | A Python function that answers a Jev or SystemOne style request

Example: You pass an invoice record from Acme with the question "What is the invoice status?" and the options paid, overdue and draft. You get back a probability for each option, plus one for the yes or no question about a total above 1000 USD.

For newcomers and experts: Think of Clef as a classifier you steer with questions, not a chatbot. Start by running the Python record from the card and reading the probabilities it prints. Change one option description and run it again.

Under the hood, a Qwen3.8-27B backbone with its vision encoder feeds a joint head. A small head on top of the backbone matches parts of the state to each question and ranks every option jointly. There is no sampling and no output parsing. The API returns a choice, a score or a yes or no probability per question, plus a confidence value.

Send a state and typed questions
The backbone reads the state
The joint head scores every option
You get a probability per option

Good to know:

• License: Apache 2.0
• Cost to run: none named, but the card was tested on one H200 and the BF16 weights are about 54.7 GB
• Data it reaches: it downloads files from Hugging Face, and the state and media you send run on your own machine
• Not for: free-form text generation, since the model only scores allowed options

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 27.4B
• Weights: about 54.7 GB in BF16; about 13.7 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 72,287
• Likes: 2,356
• License: apache-2.0
• Based on: Qwen/Qwen3.8-27B
• Quantized versions: 44
• Fine-tunes: 11
• Tags: transformers, safetensors, qwen3_5, image-text-to-text, clef, cloudflare, systemone, decision-model, qwen3.8, post-train, image-text-to-typed-output, multimodal

Links

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

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Cloudflare/clef

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