clef-flash Structured Output Optimized Model: 4GB+ VRAM, GGUF Builds

October 2, 2026October 3, 2026

At a Glance

Values determined by this site’s code when the information was collected. Dates are JST.

What we checked ourselves

• Gave the 20 decision questions we give every decision model to this model, running the publisher’s own code on a cloud GPU (NVIDIA L4) with its network cut off: 18 correct in Japanese and 18 in English.

Details and conditions are in “Our Own Measurements” below.

Specifications

• Parameters: 9B
• Architecture: Qwen3.5-9B (Gated DeltaNet + Mixture of Experts: MoE) with a vision encoder and a custom Joint schema head
• Context Length: Native 262,144 tokens (can be extended up to 1,010,000 tokens using techniques such as YaRN)

Performance

Below are internal measurement results conducted by the publisher using the “Decision Index 0.2.1" suite. For comparison, figures for the higher-tier model Clef, as well as Jev and Kev 9B, are excerpted and listed.

Decision Index Measurement Results

This table shows that Clef-Flash achieves an extremely high accuracy of 98.8% on BFCL, which measures tool-use capability as an agent, slightly outperforming the higher-tier Clef model. It also maintains a high standard of 91.8% on MMLU for general knowledge. Notably, it has low latency, with a p95 latency of 122.4ms, making it significantly faster than Clef (238.6ms) and Jev (536.0ms).

On the other hand, its RAGTruth score (measuring hallucinations) remains at 35.6%, which is significantly lower compared to Clef (79.4%) and Jev (76.5%). Additionally, in metrics such as intent classification (CLINC150+OOS), BBH, and MMLU-Pro which require reasoning, there are areas where it falls short of other models like Jev. While it excels in decision-making speed and specific tool-use accuracy, there are trade-offs regarding complex reasoning and hallucination suppression.

Workflow Evaluation

Accuracy measurement results from “Typesafe Evals", simulating actual business workflows, are as follows:

In practical tasks as well, it records 77.0% in exact action selection for Customer service, showing performance that slightly surpasses the higher-tier model. Although it trails higher-tier models in complex tasks like Invoice processing, it maintains practical accuracy.

Furthermore, according to measurements by the publisher of the base model Qwen3.5-9B, it possesses high vision-language processing capabilities, such as 78.4% on MMMU for image understanding and 85.7% on MathVista for solving math problems involving figures and graphs. Clef-Flash inherits these powerful vision and language capabilities while being optimized for structured decision-making outputs.

Strengths and Use Cases

Clef-Flash excels not at standard chat generating free-form text, but at structured decision-making where passing a “state" and a “multiple-choice question schema" returns the probabilities for all choices of each question in a single inference. As indicated by tags such as structured-output, classification, and image-text-to-typed-output, its greatest feature is that output parsing is unnecessary, making it suitable for business processes like classification, routing, and intent determination. Since inputs accept images and video frames in addition to strings and JSON, it also supports use cases such as reading and evaluating invoice images.

According to the model card, actual measurements on the Decision Index show high values such as 98.8 in BFCL (tool-calling accuracy) and 97.7 in the Home appliance simulator (case exact accuracy). In business workflow evaluations, it also outperforms the higher-tier Clef and Jev models with 77.0 in customer service action selection. In addition, its p95 latency is significantly lower than other models at 122.4ms, making it suitable for real-time routing and classification processing where speed is required. Since the base Qwen/Qwen3.5-9B is a model equipped with multimodal capabilities, support for 201 languages, and long-context processing up to 1,010,000 tokens, it is believed to inherit those foundations even when handling multilingual documents or long state descriptions.

How It Differs from Similar Models

As related models built upon the same Qwen3.5-9B, our site has introduced “LensVLM-9B", a vision-language model that compresses long text into images for processing and “MiMo-V2.6-Distill-Qwen-9B-GGUF". LensVLM-9B is a model tuned by Apple in the direction of compressing long documents into images to reduce token count, while MiMo-V2.6-Distill-Qwen-9B is distilled and SFT-trained by Xiaomi MiMo for coding and general-purpose agent tasks, with both assuming free-form text generation. In contrast, Clef-Flash significantly differs by eliminating free-form text generation itself and specializing in schema-aligned probability output, making it a derivative with a completely different directional use case despite sharing the same base model.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 9.4B parameters

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-10-03): llama.cpp: registered, vLLM: registered, MLX (mlx-lm): registered.

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. File sizes are measured from the converted build bartowski/Cloudflare_clef-flash-GGUF. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

Runs in Ollama, LM Studio and llama.cpp via a converted build.

The publisher ships safetensors, but bartowski/Cloudflare_clef-flash-GGUF provides a GGUF build you can use.

License — apache-2.0 (Commercial use allowed): Permits commercial use, modification and redistribution. Redistribution requires including the license and stating changes; includes a patent grant.

Compression: the IQ2_M build measures 3.01 bits per weight — about 19% the size of the original 16-bit weights, calculated by this site from the actual file sizes.

Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Values we measured ourselves on our server (no GPU) by actually reading and running this model’s files — not figures copied from the model card. How we measure, and the results for every model: Our Measurements.

Decision-Model Evaluation on Our Own Tasks

We gave this model the same 11 situations with 20 questions that we give every decision model (yes/no, named options and ordered levels; written by us, in Japanese and in English). llama.cpp cannot run this model’s decision head, so we ran the publisher’s own code (joint_schema_model.py and its SystemOne-compatible function) on a rented cloud GPU, inside a container with its network cut off. Each question states the rule to apply so that it has a single correct answer; our code decides right or wrong (yes when the probability of yes is 0.5 or more; for options and levels, the most probable one). These are not benchmark questions, and the result is not a general score of the model.

Conditions: Modal, NVIDIA L4 (peak VRAM 17.9GB), BF16, transformers 5.18.0, torch 2.14.1+cu130, publisher revision 17f0b0ad64. The time per decision is measured on that GPU from passing one situation (1 to 3 questions) to the publisher’s function until it returns; it is not a guide to the speed of your own GPU and cannot be compared with times measured on our CPU.

It got the same number right in Japanese and English (18 of 20).

Other rows are other decision models measured the same way (“reference” rows are models we measure for comparison). Methods differ by model, and each model is measured with its own quantization.

Times marked (GPU) were measured on a cloud GPU and the others on our CPU, so the times cannot be compared across those rows; the numbers of correct answers can.

Answer to Each Question

The full text of every situation and question, with the reason for each correct answer, is on Our Measurements.

Setup and Steps We Ran

Download (a separate container without a GPU, which does not run the publisher’s code): Python 3.12, pip install huggingface_hub, then these files of Cloudflare/clef-flash at revision 17f0b0ad64efb65d273590632833508766b2aae6 (no pickle weights):

chat_template.jinja
config.json
generation_config.json
joint_head.safetensors
joint_head_config.json
joint_schema_model.py
model-00001-of-00004.safetensors
model-00002-of-00004.safetensors
model-00003-of-00004.safetensors
model-00004-of-00004.safetensors
model.safetensors.index.json
processor_config.json
tokenizer.json
tokenizer_config.json

Run (GPU container, network blocked, model files read-only): Python 3.12, pip install torch transformers accelerate safetensors pillow torchvision. The full code we ran in the container (decision_remote.py); the questions are the same request bodies as above:

"""
Modal のコンテナの中で動く、意思決定モデルの配布元のコードによる評価(2026-10-02、ユーザーの判断「Clef を Modal で動かす」)。
lmw/lab/gpu_modal.py の decision_run から呼ばれる。**標準ライブラリだけを先頭で読み**、torch・transformers は関数の中で読む。

llama.cpp に判定の方式が無い意思決定モデル(Clef は判定ヘッド joint_head.safetensors を配布元の joint_schema_model.py で
読む)を、配布元の SystemOne 互換の関数(systemone)で動かす。このコンテナは**ネットワーク遮断・Modal の機能なし・
Volume は読み取り専用**で、配布元のコードはここでだけ import する(ダウンロードは remote_code_remote.download が
GPU の無い別のコンテナで行い、そちらでは import しない)。

問題(要求の本文)はホストが組んで渡す(lmw/lab/decision.py の request_body。llama.cpp で測るモデルと同じもの)。
正誤はホストのコード(decision.score)が判定する。ここでは応答をそのまま返し、1回の判定にかかった時間を測るだけ。
"""
import os
import platform
import sys
import time
from datetime import datetime, timezone

MOUNT = "/models"
PYTHON_VERSION = "3.12"
# 実行用のコンテナに入れるパッケージ(記事の手順にも同じ値を載せる)。Clef のカードの記載は torch 2.11・
# transformers 5.10.2 で、画像を読む処理(AutoProcessor)のために pillow・torchvision を入れる
RUN_PACKAGES = ("torch", "transformers", "accelerate", "safetensors", "pillow", "torchvision")

def installed_packages() -> list[str]:
    from importlib import metadata
    seen = {}
    for dist in metadata.distributions():
        name = dist.metadata["Name"]
        if name and name.lower() not in seen:
            seen[name.lower()] = f"{name}=={dist.version}"
    return sorted(seen.values(), key=str.lower)

def _keep(answer: dict) -> dict:
    return {k: answer[k] for k in ("type", "choice", "noul", "score", "probabilities", "confidence") if k in answer}

def _log(t0: float, message: str) -> None:
    print(f"[decision {time.time() - t0:6.0f}s] {message}", flush=True)

def run(job: dict) -> dict:
    """
    job: {"dir", "module", "loader", "answer", "warmup": 要求, "requests": {lang: [[状況の id, 要求], ...]}}。
    戻り値は記録の一部({"results", "gpu", "vram_*", "transformers", "torch", "packages", ...})。
    """
    import torch
    import transformers
    os.environ["HF_HUB_OFFLINE"] = "1"
    os.environ["TRANSFORMERS_OFFLINE"] = "1"
    t0 = time.time()
    path = os.path.join(MOUNT, job["dir"])
    gpu = torch.cuda.get_device_name(0)
    _log(t0, f"GPU: {gpu}・transformers {transformers.__version__}・torch {torch.__version__}")
    # 配布元のコード。このコンテナ(ネットワーク遮断)でだけ読む
    sys.path.insert(0, path)
    module = __import__(job["module"])
    model, processor = getattr(module, job["loader"])(path, device="cuda")
    answer = getattr(module, job["answer"])
    torch.cuda.synchronize()
    load_sec = round(time.time() - t0)
    vram_loaded = torch.cuda.memory_allocated()
    _log(t0, f"読み込み {load_sec}秒・VRAM {vram_loaded / 1024 ** 3:.1f}GB")
    torch.cuda.reset_peak_memory_stats()
    answer(model, processor, job["warmup"])  # 1回目は時間を測らない
    results: dict = {}
    for lang, items in job["requests"].items():
        out = {}
        for task_id, body in items:
            torch.cuda.synchronize()
            started = time.perf_counter()
            resp = answer(model, processor, body)
            torch.cuda.synchronize()
            out[task_id] = {"answers": {qid: _keep(a) for qid, a in (resp.get("answers") or {}).items()},
                            "ms": round((time.perf_counter() - started) * 1000, 1),
                            "input_tokens": (resp.get("usage") or {}).get("input_tokens")}
        results[lang] = out
    _log(t0, "全ての状況を解き終えました")
    return {"results": results, "gpu": gpu, "vram_total": int(torch.cuda.get_device_properties(0).total_memory),
            "vram_loaded": int(vram_loaded), "vram_peak": int(torch.cuda.max_memory_allocated()),
            "load_sec": load_sec, "dtype": "bfloat16", "transformers": str(transformers.__version__),
            "torch": str(torch.__version__), "python": platform.python_version(), "packages": installed_packages(),
            "measured_at": datetime.now(timezone.utc).isoformat()}

Packages installed in the run container:

accelerate==1.15.0
aiohappyeyeballs==2.6.1
aiohttp==3.12.7
aiosignal==1.3.2
annotated-doc==0.0.5
anyio==4.15.1
attrs==25.3.0
cbor2==5.7.0
certifi==2026.7.22
click==8.5.0
cuda-bindings==13.4.3
cuda-pathfinder==1.8.3
cuda-toolkit==13.0.3.0
filelock==4.0.9
frozenlist==1.6.0
fsspec==2026.9.0
grpclib==0.4.8
h11==0.16.0
h2==4.2.0
hf-xet==1.6.0
hpack==4.1.0
httpcore==1.0.9
httpx==0.28.1
huggingface_hub==1.33.0
hyperframe==6.1.0
idna==3.20
Jinja2==3.1.6
markdown-it-py==4.2.0
MarkupSafe==3.0.3
mdurl==0.1.2
mpmath==1.3.0
multidict==6.4.4
networkx==3.7
numpy==2.5.3
nvidia-cublas==13.1.1.3
nvidia-cuda-cupti==13.0.85
nvidia-cuda-nvrtc==13.0.88
nvidia-cuda-runtime==13.0.96
nvidia-cudnn-cu13==9.24.0.43
nvidia-cufft==12.0.0.61
nvidia-cufile==1.15.1.6
nvidia-curand==10.4.0.35
nvidia-cusolver==12.0.4.66
nvidia-cusparse==12.6.3.3
nvidia-cusparselt-cu13==0.8.1
nvidia-nccl-cu13==2.30.7
nvidia-nvjitlink==13.4.92
nvidia-nvshmem-cu13==3.4.5
nvidia-nvtx==13.0.85
packaging==26.3
pillow==12.3.0
pip==25.1.1
propcache==0.3.1
protobuf==6.31.1
psutil==7.2.2
Pygments==2.21.0
PyYAML==6.0.3
regex==2026.9.29
rich==15.0.0
safetensors==0.8.0
setuptools==84.0.0
shellingham==1.5.4
sympy==1.14.0
tokenizers==0.23.2
torch==2.14.1
torchvision==0.29.1
tqdm==4.70.1
transformers==5.18.0
triton==3.8.0
typer==0.27.2
typing_extensions==4.16.0
uv==0.7.19
wheel==0.45.1
yarl==1.20.0

How to Get It

Clef-Flash is distributed in safetensors format as Cloudflare/clef-flash. The license is apache-2.0, and it is stated that gating (agreeing to terms of use) is not required.

The model card shows acquisition via huggingface_hub and loading using the bundled joint_schema_model.py (custom code) as follows:

from huggingface_hub import snapshot_download

path = snapshot_download("Cloudflare/clef-flash")

It is stated that verification was performed using torch 2.11, transformers 5.10.2, and a single H200 GPU. pillow is also required when using image and video inputs. Note that it uses a unique inference path (Joint schema head) loaded via the code included with the card, rather than the standard text generation pipeline.

Quantized and Converted Variants

File sizes of each build:

• Available builds in bartowski/Cloudflare_clef-flash-GGUF: IQ2_M 3.3GB / Q2_K 3.4GB / IQ3_XXS 3.9GB / Q3_K_S 4.0GB / IQ3_XS 4.0GB / Q3_K_M 4.2GB / Q3_K_L 4.3GB / IQ3_M 4.5GB / IQ4_XS 4.9GB / Q4_0 5.1GB / Q4_K_S 5.1GB / IQ4_NL 5.4GB / Q4_K_M 5.4GB / Q4_1 5.5GB / Q4_K_L 5.8GB / Q5_K_S 6.0GB / Q5_K_M 6.4GB / Q6_K_S 7.0GB / Q6_K 7.3GB / Q6_K_L 7.5GB / Q8_0 8.9GB / BF16 16.7GB
• Available builds in mlx-community/clef-flash-4bit: MLX 4bit 5.5GB

In addition, 6 converted build(s) from other uploaders exist on Hugging Face; this site lists only builds from the model’s publisher or established quantization maintainers.

This section is appended automatically by Local Model Watch when a converted build of this model appears after publication. Memory figures are estimated from the size of the distributed files. What the quantization names mean: glossary.

Related Articles

• LensVLM-9B Vision-Language Model: 4GB+ VRAM, GGUF Builds
• MiMo-V2.6-Distill-Qwen-9B-GGUF: Our Test Answers, 12GB+ VRAM
• clef Vision-Language Model: 80GB+ VRAM
• clef Structured Decision-Making Model: 80GB+ VRAM

What to Read Next

• Find models by VRAM (This model runs from the 4GB tier) → Other models that run on a 8GB GPU
• Engines that run this model → llama.cpp / Ollama / vLLM
• What IQ2_M, Q5_K_M, Q8_0 mean and where to get this model → GGUF format guide and models / MLX format guide and models / Quantization and model-format glossary
• Learn about the publisher → Alibaba (Qwen): models, licenses and articles
• Other models for the same task → Other vision-language models

Sources

• https://huggingface.co/Cloudflare/clef-flash
• https://huggingface.co/Qwen/Qwen3.5-9B

Update History

• 2026-10-02: Added converted builds to “Quantized and Converted Variants”: bartowski/Cloudflare_clef-flash-GGUF, mlx-community/clef-flash-4bit
• 2026-10-02: Updated the hardware requirements table with the actual file sizes of bartowski/Cloudflare_clef-flash-GGUF.
• 2026-10-02: Changed the title to show what the article covers (VRAM requirements, file list, etc.).
• 2026-10-03: Added our own measurements: decision-model evaluation on our fixed tasks.