Cloudflare clef-omni: A 30B Open-Source Decision Model That Generates No Text

Cloudflare clef-omni: A 30B Open-Source Decision Model That Generates No Text

Cloudflare has put clef-omni on Hugging Face: a 30B multimodal model under the Apache 2.0 license. It can't write haiku, or any sentence at all. You give it text, images, audio, or video, plus a set of typed questions, and it returns a probability for each candidate answer. This is Cloudflare's open-weight response to TypeSafe's Jev.

If you saw "Cloudflare open-sources a model" in your feed and thought a Llama competitor had arrived, you'll be disappointed. This is a decision model, not a chat model. I think it will be more useful in production than the chat models most people self-host, but there are two warnings from Cloudflare's own benchmark table that need to be stated up front: reasoning ability and RAG hallucination detection.

What Exactly Is clef-omni

According to the model card, it's a "30B-A3B Mixture-of-Experts multimodal model" that maps a state and a set of typed questions into decisions. You send context (JSON, a ticket, a screenshot, a 20-second video), plus 1 to 64 questions. Each question belongs to one of three types:

• noul: yes / no
• choice: pick one from N labeled options
• score: an ordered scale, such as "no impact / minor / major / critical"

The model does a single forward pass and returns a logit for every allowed option of every question. Because it never generates tokens, there's no JSON to parse, and no trailing comma will blow up your pipeline at 3 a.m.

Specs at a glance: the base is Qwen3-Omni-30B-A3B-Instruct (thinker only; speech output unused), 30B total parameters with 3B activated, support for text, JSON, images, audio, and video (sampled at 2fps), 64,000-token context, Apache-2.0 license, ID @cf/cloudflare/clef-omni on Workers AI, hosted at $0.15 per million input tokens with free output.

Cloudflare froze Qwen3-Omni's understanding backbone, trained LoRA adapters, and used label-smoothed cross-entropy with Brier score calibration. The model card adds a key component that replaces text generation: a small "joint schema head" that reads the backbone's final hidden state and scores all options of all questions together. Calibration is the part I care about most — if you're going to set a threshold like "0.85 confidence means this is phishing," those probabilities have to actually mean something.

What Is a Decision Model

A decision model is a class of architecture whose output form differs from a chat/LLM: rather than generating free text for an input, it maps "context + a set of predefined questions" into a probability distribution over each candidate answer. Typical tasks include intent classification, ticket routing, content moderation tagging, and tool selection — what these scenarios share is a limited and structured answer space, so directly outputting probabilities is more reliable than generating text and parsing it.

The traditional approach is to have a large model generate a JSON blob, then write rules or use another model to parse it into a structured decision. Any failure in that chain (extra explanation, trailing comma, field-name drift) causes silent failures in production. A decision model sidesteps the entire generate-then-parse step by scoring all questions and all options together in a single forward pass: no token generation, so no JSON to break. It can also be trained specifically for probability calibration on the task (e.g., with Brier scores), so that thresholds like "0.85 confidence" carry actionable meaning.

MoE, A3B, and What "30B-A3B" Means

Mixture-of-Experts (MoE) is a sparse variant of the Transformer: the feed-forward network is split into multiple "expert" sub-networks, only a few of which are activated on each forward pass, with a router network deciding which ones. So "30B-A3B" means the model has roughly 30 billion total parameters, but only about 3 billion are activated per token — inference compute is close to a 3B model, while knowledge capacity is on the order of 30B.

The impact on deployment cost is direct: MoE typically requires loading all expert weights onto the GPU, so VRAM requirements are still counted at 30B (the model card gives about 64 GB in bf16), but throughput and latency are closer to a small model. That's why clef-omni runs on an 80 GB card while a 24 GB consumer card can't fit it in bf16. LoRA (Low-Rank Adaptation) trains only a small set of low-rank adapter parameters while freezing the backbone, letting Cloudflare "calibrate" Qwen3-Omni's understanding into decision outputs at relatively low cost.

Clef and Jev: Why Cloudflare Did This

clef-omni is the third model in a family that is only ten days old. Cloudflare released Clef and Clef-flash on October 1 as its open-weight response to Jev; Jev is TypeSafe's decision model, released September 15. The Clef API is compatible with Jev — switching only requires changing the model ID.

The first release went over poorly. According to Traictory's writeup, in the Hacker News thread (614 points, 214 comments), someone estimated at roughly 300 tokens per call that a million decisions would cost about $12.60 on Jev and about $72 on Clef. Clef charges $0.24 per million tokens, versus $0.042 for Jev — nearly six times more expensive. Another person wrote "public benchmarks are easy to cheat." On r/LocalLLaMA, people argued that Cloudflare benchmarked against a weaker open-source variant of Jev.

Eight days later, Cloudflare dropped Clef-flash from $0.09 to $0.038 (already below Jev), moved Clef's inference to SGLang for a 1.7x to 2.0x median speedup, and released clef-omni. Clef itself stayed at $0.24. My guess is someone at Cloudflare read those posts.

Benchmark Comparison: Look at the Ugly Rows First

All the data below is self-reported, from Cloudflare's internal runs of the Decision Index 0.2.1 suite. No one has independently reproduced it yet.

clef-omni does well on intent classification and routing tasks (BANKING77, CLINC150), beating Jev by a wide margin. On anything requiring multi-step reasoning (GPQA, BBH, MMLU-Pro), Jev leads by 12 to 31 points.

The row I care about most is RAGTruth. Clef scores 79.4 on detecting hallucinations in RAG output, while clef-omni drops to 42.0. If you were planning to use clef-omni as a cheap "is this answer supported by the retrieved documents" checker, use regular Clef instead. I'd guess adding audio and video paid the price here, but Cloudflare doesn't explain the drop.

In workflow evaluations, clef-omni is below Clef on every row: exact action for invoice processing is 60.2 vs 64.7, customer service is 71.6 vs 76.3. It also trails Jev (61.8 and 76.0).

Brier Score and Probability Calibration

The Brier score is a metric for the quality of probabilistic predictions: for each prediction, compute (predicted probability − actual outcome)² and average them; 0 is perfect and lower is better. It penalizes both "wrong direction" (calling a true thing false) and "overconfidence" (saying 0.99 when only 0.6 actually hit). Compared with accuracy, which only looks at whether the answer was correct, the Brier score cares more about whether the probabilities themselves are trustworthy.

This is why calibration is life-or-death for a decision model. When you set "confidence ≥ 0.85 means auto-tag as phishing" in production, what actually matters isn't whether the model classifies correctly, but whether its 0.85 really corresponds to about 85% accuracy. Uncalibrated models are often systematically overconfident, making thresholds meaningless. Cloudflare uses label-smoothed cross-entropy with Brier score calibration precisely so the output probabilities can be consumed directly by business thresholds, rather than layering another rule on top.

Handling Audio and Video in One Call: Latency and Cost

Cloudflare wants you to stop chaining models. Instead of running Whisper for transcription and then a separate image captioner, just send the clip and ask. The blog gives figures of about 130 ms median for text-only decisions, about 150 ms for images, and about 1.5 seconds for a 21-second video with sound, all within a single API call.

A changelog published the same day says about 20 ms for text and about 300 ms for the same 21-second clip. Those two numbers can't be the same measurement. I'd guess it's server-side compute versus end-to-end, but Cloudflare doesn't say, so budgeting on the slower one is safer.

On cost, the Workers AI docs list audio at about 780 tokens per minute, and video at up to about 15,400 tokens per minute at the highest resolution (about 8,600 at 480p). At $0.15 per million, a minute of highest-resolution video with sound works out to about a quarter of a cent — cheap enough that you could scan every clip a user uploads.

Check the hosting limits before you start: at most 4 images, 4 audio clips, and 2 videos per request; a single video up to 60 seconds; a single audio clip up to 300 seconds; 16 MiB combined for audio and video. Remote URLs are not accepted either — media must be base64-embedded in the request.

Another caveat comes from Digital Applied: OpenRouter's catalog currently lists only text and image inputs for clef-omni. If you need audio or video, go directly through Workers AI.

Calling clef-omni on Workers AI

In a Worker it's a single env.AI.run call:

const result = await env.AI.run("@cf/cloudflare/clef-omni", {
  model: "clef-omni",
  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"],
    },
  },
});

result.answers comes back keyed by the same IDs: the probability for urgent, the chosen item and per-option probabilities for team, and the probability-weighted score for severity. Or use curl against https://api.cloudflare.com/client/v4/accounts/$CLOUDFLARE_ACCOUNT_ID/ai/run/@cf/cloudflare/clef-omni with a bearer token and the same body.

Running clef-omni Locally with transformers

First, get a lot of VRAM. The model card says the backbone needs about 64 GB of GPU memory in bfloat16, tested on a single H200 with torch 2.11 and transformers 5.10.2. Plan around an 80 GB card; a 24 GB consumer card won't fit it in bf16.

pip install "torch==2.11.*" "transformers==5.10.2" huggingface_hub pillow av

pillow handles images, av handles audio and video. Then copy the sample code from the model card: download the snapshot, insert the path into sys.path, import collate_records, encode_record, and load_release_model from joint_schema_model, build a record, encode it, batch it, run the model under torch.inference_mode(), and softmax the logits per question to get probabilities.

One thing must be pointed out: that code does sys.path.insert(0, path) and then imports joint_schema_model from the downloaded repo — effectively executing Python from the Hugging Face snapshot, the same trust decision as trust_remote_code=True, just without the flag to warn you. Read joint_schema_model.py before running it, and pin to a version with revision="<commit-sha>" so the code can't change under your feet.

Why Loading Open-Source Models Carries Code-Execution Risk

A Hugging Face repo is not just weight files — it can also contain custom modeling code. When a model architecture isn't natively supported by transformers, loading it requires executing the Python inside the repo; that's what trust_remote_code=True is for — it explicitly warns you that you're about to run third-party code. The risk: repo contents can be updated by the author, so code under the same version number or branch name can change without your knowledge, introducing arbitrary code execution.

revision="<commit-sha>" locks content to a specific commit SHA, making the loading behavior reproducible and auditable. The example in this article does sys.path.insert and then imports joint_schema_model from the local snapshot, which is effectively implicit remote code without the obvious warning flag, so human review is even more important. Best practice: pin the revision, read every imported module, and run it for the first time in an isolated environment or sandbox.

Should You Use clef-omni

My take: if you're doing ticket routing, upload tagging, content moderation, or helping an agent decide which tool to call, and part of your input is screenshots, voice messages, or short videos, then clef-omni is the most practical open-source option right now. Apache 2.0, calibrated probabilities, no output to parse, about a quarter of a cent per minute of video.

But if your decisions require genuine reasoning, or you need to check RAG answers for hallucinations, the public numbers tell you to look elsewhere. Also, "open source" here means open weights: a Cloudflare PM confirmed to The Register that the training data is not public.

I'd rather know why Cloudflare is actually doing this. Its blog says it uses Clef internally to detect spam in document repos, phishing in plugin libraries, PII scanning, and malicious domains. In other words, a CDN and security company decided classification is infrastructure and didn't want to rent it from TypeSafe.

So what do you think: is Cloudflare training its own models because hosting someone else's model is a commodity business with no moat, or because its security products need a classifier it controls? And has anyone actually swapped Jev for Clef in production?

One-line Summary

Cloudflare open-sources clef-omni: a 30B multimodal decision model that outputs probabilities, not text — strong at classification, weak at reasoning.

Paragraph Summary

Cloudflare released clef-omni on Hugging Face, an Apache 2.0 30B-A3B Mixture-of-Experts multimodal decision model. It doesn't generate text; instead it takes text, JSON, images, audio, or video plus 1 to 64 typed questions (noul, choice, score) and returns probabilities for each candidate answer, so there's no JSON to parse. It beats Jev by a wide margin on intent classification and routing, but trails by 12 to 31 points on multi-step reasoning tasks like GPQA, BBH, and MMLU-Pro, and RAGTruth hallucination detection drops from Clef's 79.4 to 42.0 — use regular Clef for RAG checks. Audio and video are handled in a single call, and hosted pricing is $0.15 per million input tokens, making it extremely cheap. Local deployment needs about 64 GB of VRAM, and the sample code executes Python from the downloaded repo, so pin the revision and review the code.