Clef-flash

Clef-flash is a 9.41B parameter dense decision model built by Cloudflare and released under the Apache 2.0 license. Unlike standard autoregressive large language models that generate free-form text token by token, Clef-flash evaluates an arbitrary input state alongside a schema of typed questions to output calibrated probabilities in a single forward pass. Post-trained from Qwen3.5-9B, the model eliminates the parsing failures, nondeterminism, and high latency typical of prompt-engineered chat models used for classification and routing.

As a local AI model 9.41B parameters 2026 release, Clef-flash establishes an efficient runtime pattern for agentic architectures. Cloudflare designed the model to serve as a fast classifier that determines execution paths, evaluates condition thresholds, and routes context to downstream tools. By computing discrete logits for pre-defined question schemas rather than generating string tokens, Clef-flash delivers median inference latencies around 38.8 ms under dedicated GPU acceleration, making it an attractive engine for high-throughput local pipelines.

Deploying Clef-flash locally gives teams complete data privacy and predictable latency for decision tasks. For engineers building autonomous systems, the model fits between observation ingestion and tool execution, replacing fragile string extraction layers with direct categorical probabilities.

Clef-flash uses a dense transformer architecture totaling 9.41B parameters, built upon the Qwen3.5-9B base checkpoint. Standard LLMs feed output embeddings back through a causal language modeling head sequentially. Clef-flash departs from this mechanism by pairing the frozen or fine-tuned backbone with a dedicated joint schema head.

The joint schema head is a compact transformer module that processes the final hidden states generated by the 9.41B backbone. When a request is submitted, the model encodes both the input state (such as raw text, structured JSON records, or system logs) and a schema of target questions into the context window. The schema head routes contextual representations from the input state directly to the question definitions, calculating logits for every declared option simultaneously.

Key technical characteristics include:

• Total Parameters: 9.41B dense parameters
• Base Checkpoint: Qwen3.5-9B
• Context Window: 24,576 tokens
• Output Mechanism: Non-autoregressive joint schema scoring head (single forward pass)
• Inference Latency: 38.8 ms median (hardware dependent)
• Protocol Compatibility: Jev and SystemOne /v1/systemone schema format
• License: Apache 2.0

Because the model does not run an autoregressive decode loop, its computational profile mirrors the prefill phase of an LLM. Once the 24,576-token context window is ingested and processed through the dense layers, the head computes output probabilities immediately via a per-question softmax. This prevents KV-cache inflation during token generation and maintains deterministic execution times.

Clef-flash handles classification, scoring, and routing workloads where agents must evaluate structured or unstructured context against strict schemas. Supported schema primitives include boolean checks (noul questions), multi-class categorical selection (choice questions), and continuous numerical evaluations (score questions).

Primary local workloads include:

• Agentic Routing and Tool Gating: Determining which specialist agent or external tool should handle an incoming payload. Clef-flash can inspect conversational state or stack traces and output categorical confidence scores across dozens of routing targets in one pass.
• Data Triage and Security Classification: Automated inspection of high-volume incoming data, such as support tickets, error logs, or network events. Systems can classify inputs against sensitivity rubrics (such as PII detection, abuse tagging, or vulnerability levels) without text parsing overhead.
• Structured JSON Validation and State Extraction: Evaluating whether an unvalidated JSON object conforms to business invariants or meets downstream execution requirements before passing it to production databases.
• Human-in-the-Loop Thresholding: Establishing programmatic criteria for agent decisions. Because Clef-flash outputs calibrated probabilities per option, software engineers can enforce hard thresholds (for example, triggering autonomous execution only when classification confidence exceeds 0.95, and routing to human review otherwise).

When you run Clef-flash locally, system resource planning centers entirely on model weight residency and prompt ingestion throughput, rather than autoregressive generation speeds.

Memory requirements depend on the chosen precision and how much of the 24,576-token context window your pipeline populates:

• 16-bit (BF16 / FP16): ~19 GB to 20 GB VRAM. Requires a 24 GB card such as an RTX 3090, RTX 4090, or professional workstation GPU.
• 8-bit Quantization (Q8_0 / INT8): ~11 GB to 12.5 GB VRAM. Fits cleanly on 16 GB GPUs such as the RTX 4080 or AMD Radeon RX 7800 XT.
• 4-bit Quantization (Q4_K_M): ~6.5 GB to 7.5 GB VRAM. Runs on mainstream 8 GB and 12 GB consumer graphics cards.

The best GPU for Clef-flash depends on your target concurrency. For standalone developer setups or low-concurrency pipelines, an Nvidia GeForce RTX 4090 (24 GB) is the top consumer option. It runs the full BF16 checkpoint in VRAM with sufficient overhead to handle the complete 24,576 context window without offloading.

For budget-conscious developers asking how to run 9.41B model on consumer GPU hardware with 12 GB or 8 GB VRAM, an RTX 4070 (12 GB) running an 8-bit or 4-bit quantization delivers excellent latency. On Apple Silicon, an M3 Max or M4 Max system with 36 GB or more of unified memory runs the model unquantized with minimal latency overhead.

For the vast majority of local production deployments, Q4_K_M is the best quantization for Clef-flash. Because the model operates as a categorical classifier via its joint schema head, the slight weight degradation of a medium 4-bit k-quantization rarely shifts the argmax decision or significantly warps the calibrated softmax distribution. If your application relies on high-precision probability calibration near tight boundary cutoffs (such as 0.98 vs 0.99), run the model in FP8 or native BF16.

Standard evaluations measure "Clef-flash tokens per second" as a baseline, but that metric can be misleading. Traditional models generate 30 to 90 tokens per second out of the decode phase. Clef-flash does not decode output tokens: it runs one forward pass and halts.

Clef-flash performance is therefore measured in prefill speed and end-to-end request latency:

• RTX 4090 (BF16): 35 ms to 55 ms per request on states under 2,048 tokens.
• RTX 4070 (Q4_K_M): 45 ms to 70 ms per request on moderate prompt sizes.
• Apple M4 Max (Metal): 60 ms to 95 ms per request.

Ollama and llama.cpp provide direct routes to serve the model locally using the native /v1/systemone format. To run the model inside high-throughput serving stacks, SGLang offers direct backend integration:

1docker run --gpus all \
2  --shm-size 32g \
3  -p 30000:30000 \
4  -v ~/.cache/huggingface:/root/.cache/huggingface \
5  --ipc=host \
6  lmsysorg/sglang:dev-clef \
7  sglang serve \
8    --model-path Cloudflare/clef-flash \
9    --host 0.0.0.0 \
10    --port 30000

Once running, you can dispatch structured JSON payloads directly to the decision endpoint:

1curl http://localhost:30000/v1/systemone \
2  -H 'Content-Type: application/json' \
3  -d '{
4    "model": "Cloudflare/clef-flash",
5    "state": "Database connection pool exhausted on worker node 4.",
6    "questions": {
7      "severity": {
8        "type": "choice",
9        "instructions": "Determine incident severity level",
10        "criteria": {
11          "critical": "Service is actively degraded",
12          "warning": "Warning threshold reached but functional",
13          "info": "Informational state"
14        }
15      }
16    }
17  }'

Evaluating Clef-flash vs alternative setups highlights trade-offs in architecture and inference efficiency.

• Clef-flash vs Jev (Typesafe AI): Jev pioneered the modern decision model format with a 32,768-token window, but it operates predominantly as an API service. Clef-flash is fully open-source under Apache 2.0, allowing local execution without egress costs or latency variability. While Jev provides proprietary tuning across specific commercial enterprise datasets, Clef-flash gives practitioners complete control over local weights and fine-tuning.
• Clef-flash vs Standard Qwen3.5-9B Instruct: Deploying standard Qwen3.5-9B to output JSON through tool-calling or constrained decoding (such as outlines or guidance) takes significantly more compute. Autoregressive JSON decoding requires generating dozens of structural tokens, pushing response times to 300-800 ms. Clef-flash executes the classification in 38.8 ms via its dedicated schema head, saving GPU cycles and eliminating structural syntax errors entirely.
• Clef-flash vs Clef (27.4B): Cloudflare's larger 27.4B sibling offers slightly higher accuracy on edge-case reasoning across complex criteria, but requires an RTX 6000 Ada or multi-GPU rig for unquantized serving. Clef-flash delivers nearly comparable routing accuracy on common agent tasks while fitting inside consumer 8 GB to 16 GB hardware profiles.