---
title: "Clef"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/8652058d-b621-4dbf-8633-3e2f09e4d552"
updated: "2026-11-12"
---

# Clef

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Clef is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Cloudflare

## 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.

```sh
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.

```python
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.

```bash
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

## README

````markdown
# 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.

```table
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

```table
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.

```sh
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.

```python
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.

```bash
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
```

```table
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.

```flow
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:

```sh
pip install -U huggingface_hub
hf download Cloudflare/clef
```

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

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[Cloudflare/clef on Hugging Face](https://huggingface.co/Cloudflare/clef)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Clef (this page) | 72,287 | 2,356 | 27.4B | apache-2.0 | 2026-11-10 |
| [Clef-Flash](https://mindket.com/p/614c30ba-f6b2-46dd-bb0e-4bad233d1941) | 36,799 | 919 | 9.4B | apache-2.0 | 2026-11-10 |
| [Cloudflare clef GGUF](https://mindket.com/p/5a8d263f-fc69-47da-8bd1-a3ea72a252e2) | 18,354 | 36 | 27B | apache-2.0 | 2026-10-06 |
| [clef-flash-4bit](https://mindket.com/p/f2c928d8-4190-4b0e-b8c5-534296134c5f) | 3,524 | 40 | 9.4B | apache-2.0 | 2026-10-08 |
| [Clef-LoRA-for-Qwen3.8-27B-GGUF](https://mindket.com/p/62efdbd6-4717-4196-92c5-113501a64eed) | 311 | 6 | 668M | apache-2.0 | 2026-10-05 |
| [Qwen3.8-27B-pi](https://mindket.com/p/8adc35eb-a424-4e6e-99cc-f4ae26715a1a) | 1,857 | 87 | 27.8B | apache-2.0 | 2026-09-30 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · felix089 · 2026-10-08](https://news.ycombinator.com/item?id=50007993): Show HN: Jevman – AI decision models play Pac-Man: Openai just launched their decisions endpoint, cloudflare launched clef the other week, and many more jev alternatives are out there. We wanted to put the popular ones to the test and thought Pac-Man is a good benchmark for simple and fast decision making. So we let jev 1.13, kev, clef, clef…
- [Bluesky · Chema Alonso · 2026-10-30](https://bsky.app/profile/chemaalonso.com/post/3mz2xh3vbf22y): El lado del mal - Cómo evitar fugas de documentos con un "DLP AI" para ficheros de imágenes con Cloudflare Workers AI y Clef www.elladodelmal.com/2026/10/como... \#Cloudflare \#Clef \#DLP \#Workers \#WorkersAI \#Fugadedatos \#IA \#AI
- [Hacker News · dmytton · 2026-10-14](https://news.ycombinator.com/item?id=50087289): AI agent behavior drift analysis with Cloudflare Clef
- [Bluesky · Pingoru.io · 2026-10-29](https://bsky.app/profile/pingoru.bsky.social/post/3myz5a3dewk2z): 🟠 Berget AI is reporting a Partial Outage since 11:10 UTC "Cloudflare/clef-flash is down" Affects: Cloudflare/clef-flash Live timeline → https://pingoru.io/providers/berget-ai/incidents/12447236 \#BergetAI \#BergetAIDown
- [Hacker News · ersatz\_username · 2026-10-14](https://news.ycombinator.com/item?id=50089639): Show HN: SPEV: Open Weight, Omnimodal Decision Model Trained for Turn Detection: Where Jev and other Jev-style models like OpenAI's Decisions and Cloudflare's Clef are multimodal, supporting text or images in, decision out, SPEV natively supports audio and video inputs. These native capabilities allow SPEV to reason directly from audio without the lossy speech to text…
- [Bluesky · @hochchristoph.bsky.social · 2026-10-28](https://bsky.app/profile/hochchristoph.bsky.social/post/3myxdpybg2k2c): I'm currently playing around with Laravel AI SDK \& Cloudflare Workers AI using their Clef/Clairic models. Here's what you need if you want to use Clef as a drop-in replacement for Jev: gist.github.com/CHH/caf49e34...
- [Hacker News · murderszn · 2026-10-03](https://news.ycombinator.com/item?id=49947690): Cube Rule food classifier using Cloudflare Clef classification model
- [Bluesky · Pingoru.io · 2026-10-27](https://bsky.app/profile/pingoru.bsky.social/post/3myuqamamwa22): 🟠 Berget AI is reporting a Partial Outage since 17:05 UTC "Cloudflare/clef-flash is down" Affects: Cloudflare/clef-flash Live timeline → https://pingoru.io/providers/berget-ai/incidents/12443721 \#BergetAI \#BergetAIDown
- [Hacker News · trollied · 2026-10-05](https://news.ycombinator.com/item?id=49968012): Cloudflare Clef Open Weights
- [Bluesky · Sai Prakash · 2026-11-05](https://bsky.app/profile/sylonzero.bsky.social/post/3mzkt5cnaiu26): 5 of the 9 most interesting models of Sep–Oct don't generate text at all: decision models (Cloudflare Clef, Strands Decider, Liquid d1, Laya) return calibrated choices in milliseconds. Plus Mercury 2.5's diffusion speed, Fireworks Ember-1, Reflection Beam, Mistral Large 4 and Kolibri.
- [Hacker News · jedisct1 · 2026-11-07](https://news.ycombinator.com/item?id=50403607): A Jev that can ask Opus for help gives Opus accuracy at 4x lower cost: I use swival.dev where a decision model (Cloudflare's Clef running locally is free and works great) is used for automatic model selection, but also to complete a task, just like the LLM. It gives confidence scores on the reliability of the LLM output, is used instead of the LLM, even mid-task when…
- [Bluesky · call\_user\_func · 2026-11-05](https://bsky.app/profile/throwable.bsky.social/post/3mzk6uz65qc2d): 📦 meirdick/laravel-cf-workersai v1.3.0 Cloudflare Workers AI provider for the Laravel AI SDK: text, embeddings, reranking, images, speech, transcription, Clef decisions and Clairic typed extraction, with AI Gateway routing. 🔗 https://github.com/meirdick/laravel-cf-workersai

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-10
- First published: 2026-09-30
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Cloudflare/clef on Hugging Face](https://huggingface.co/Cloudflare/clef)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/8652058d-b621-4dbf-8633-3e2f09e4d552)
- [Its page on Mindket](https://mindket.com/p/8652058d-b621-4dbf-8633-3e2f09e4d552)
