turintech/Clef-Artemis-GGUF

TurinTech models, built with Artemis

Cloudflare's Clef for typed decisions about text on a 16 GB GPU, or about images on a larger one. It answers typed questions with a probability for each answer, in one pass.

• 14.82 GB download for the default file, Clef-Artemis-IQ4_XS.gguf.
• Peak GPU memory 15.0 GiB for text and 17.4 GiB with images on an NVIDIA A100 80 GB; the original needs 49.9 GiB.
• Same answer as the original on 95.6% of 2,000 test decisions, against 87.6% for the closest public file by size, bartowski's IQ3_M (13.78 GB). These decisions also chose the file.

Run it

This is a decision model: send typed questions to llama-server's /v1/systemone endpoint, not to chat. Needs llama.cpp from 9 October 2026 or newer. Tested at commit 1e6f04a, and every file also on release b11572 (12 October 2026), which gave identical answers on a 100-decision check.

llama-server -hf turintech/Clef-Artemis-GGUF:IQ4_XS --port 8080 -c 16384 -ub 4096 -b 4096

Request example, images, Ollama and LM Studio

llama-server -m Clef-Artemis-IQ4_XS.gguf --port 8080 -c 16384 -ub 4096 -b 4096

Tested on an Apple M3 Max (36 GB) with llama.cpp Metal (b11617): every file here loads and answers with the command above.

Keep -ub 4096 -b 4096. At the default of 512, /v1/systemone rejects inputs longer than 512 tokens. That is true of every Clef GGUF, public ones included. -c 16384 stops the server from reserving memory for the full training context.

curl http://localhost:8080/v1/systemone -H 'Content-Type: application/json' -d '{
  "state": "My Stripe integration keeps failing. Please help ASAP.",
  "questions": {"urgency": {"type": "noul", "instructions": "Does this message express urgency?"}}
}'

The request and response follow the Jev/SystemOne format described on the original model card.

Questions, problems or a model to consider for a smaller version? Reply in our feedback thread.

Vision inputs

Add the vision projector from ggml-org/Clef-GGUF and raise the batch size, since several large images can exceed 4,096 tokens:

hf download ggml-org/Clef-GGUF mmproj-Clef-BF16.gguf --local-dir .
llama-server -m Clef-Artemis-IQ4_XS.gguf --port 8080 --mmproj mmproj-Clef-BF16.gguf -c 16384 -ub 8192 -b 8192

Send images as data URLs in a top-level images array of the /v1/systemone request. Our image results use the BF16 projector; the smaller Q8_0 projector from the same repo was not tested with these files.

Recommended Ollama package

echo "My Stripe integration keeps failing. Please help ASAP." | ollama run turintech/clef-artemis:14.8gb --ask "Does this message express urgency?"

This verified tag selects Clef-Artemis-IQ4_XS.gguf. Ollama 0.40.4 was tested; include "model": "turintech/clef-artemis:14.8gb" in the decision request to port 11434. The command runs the documented decision example; the explicit size tag selects the recommended file and is not an immutable revision.

LM Studio

The model is on the LM Studio Hub as turintech/clef-artemis. That entry loads it as a decision model with the settings above: a 16,384-token context and batch sizes of 4,096. Keep the @iq4_xs label when you download it, because without one LM Studio can pick a different file for your hardware:

lms get turintech/clef-artemis@iq4_xs --gguf
lms load turintech/clef-artemis

Then, with LM Studio's server running (port 1234 by default), send decision requests to /v1/systemone and name the model. The chat window and /v1/chat/completions do not run it as a decision model.

curl http://localhost:1234/v1/systemone -H 'Content-Type: application/json' -d '{
  "model": "turintech/clef-artemis",
  "state": "I was charged twice for the same order.",
  "questions": {"angry": {"type": "noul", "instructions": "Is the customer angry?"}}
}'

Tested on 25 October 2026 with LM Studio 0.4.26 (headless llmster 0.0.25-1) and its CPU llama.cpp engine 2.64.0 on Linux x86-64. Clef-Artemis-IQ4_XS.gguf was downloaded from Hugging Face, its SHA-256 matched, it loaded through a local copy of this Hub definition and /v1/systemone answered a yes/no and a choice question. That is a compatibility check: the numbers on this card come from llama-server.

Only text input was tested in LM Studio.

Choose this model

• Best for typed decisions on a 16 GB GPU for text, or a larger one with images.
• Consider another file when memory is tight: the Q2_K file needs 11.3 GiB but changed 4 confident answers. For the closest match, ggml-org's Q4_K_M (19.2 GB) gives the same answer 96.9% of the time.

Files

Every file we publish for this model. Sizes are download sizes, not memory.

• With llama.cpp or a Hugging Face pull, add the file's quant label as the tag: -hf turintech/Clef-Artemis-GGUF:IQ4_XS.
• The Ollama tag runs our package, which holds the same file: ollama run turintech/clef-artemis:<tag>.
• LM Studio's Hub entry turintech/clef-artemis offers every model file above, without the vision projector.

Without a tag, -hf and hf.co fetch Clef-Artemis-IQ3_M.gguf, not the default file, so always add the tag.

How the files compare

"Saved" is the file-size reduction versus the BF16 original. Variant links download the exact GGUF; full filenames are in the commands and checksums. File labels are size classes, explained under "File names, sizes and SHA-256 checksums" at the end of the card.

IQ3_M: Similar measured quality to Artemis IQ4_XS, with a smaller download. Q2_K: Smallest. Peak 11.3 GiB for text, so it should fit a 12 GB GPU for text.

"Same answer as the original" is how often a file picks the same option as the BF16 original on 2,000 test decisions. "Accuracy change" is the difference in accuracy against the original on the same cases, in points. "Confident answers changed" counts answers the original was more than 80% sure of that the file changed.

The usual public files, on the same tests: Q8_0 (ggml-org, 28.7 GB) gives the same answer 98.8% of the time, Q4_K_M (ggml-org, 19.2 GB) 96.9% and IQ3_M (bartowski, 13.78 GB) 87.6%. None of them changed a confident answer; of ours, the two smallest did (2 and 4 of about 2,000).

Results

Our default file against the public files nearest in size and the original, on 2,000 typed decisions from the test split. These decisions were also used to choose the file.

The public IQ3_M is a little smaller and further from the original. The public Q4_K_M is larger and closer. How it was tested.

Typed-decision accuracy on the card's selection panel, with the measured nearby-size alternatives and BF16 original. These comparisons informed file selection and do not establish performance on unseen inputs. Hardware, runtime and other evaluation panels are listed under How it was tested.

Evaluation details and limitations

How it was tested

Compatibility notes

This is a decision model. Run it on llama-server's /v1/systemone endpoint and keep -ub 4096 -b 4096, as in Run it. The llama.cpp and Ollama buttons under "Use this model" start it as a chat model without those settings, which is not a supported way to run it. The LM Studio button imports the file without those settings; use the Hub entry in LM Studio instead.

Recommendation notes

Download Clef-Artemis-IQ4_XS.gguf (14.82 GB, peak GPU memory 15.0 GiB for text on an NVIDIA A100) and start it with the settings below, then send requests as shown in Run it. It gives the same answer as the original on 95.6% of 2,000 test decisions and changed no answer the original was more than 80% sure of. Go smaller only if memory is tight: the two smallest files changed 2 and 4 such answers.

These files are per-tensor mixes, and their labels are size classes (see the file names table at the end). Use the exact filename or the :IQ4_XS tag; without a tag, app buttons may select a different file.

Size and quality trade-offs

Cloudflare/clef is 54.1 GB and needs 49.9 GiB of GPU memory, so an 80 GB data-centre card. The default file here is 14.82 GB, 73% smaller, and needs 15.0 GiB, so it should fit a single 16 GB GPU for text (measured on an NVIDIA A100). It gives the same answer as the original on 95.6% of 2,000 test decisions, has measured accuracy (72.0% against 72.1%), and changed no answer the original was more than 80% sure of.

The separate train-split results are labelled held-out in the tables. Their independence from calibration and variant selection has not been verified for every file.

Test results informed candidate selection, so they do not independently measure performance on new inputs. Read them alongside the separate train-split results and public-file comparisons. Agreement measures whether a compressed model keeps the original's answers, including its mistakes. The typed-decisions accuracy figures compare answers with teacher-generated labels.

Every file was compared with the BF16 original and with the public builds, all at identical llama.cpp settings, on:

• 2,000 typed decisions (questions with a fixed answer type: yes/no, pick one, a score) from the test split of LocalLLaMA/typed-decisions: 400 cases with about five questions each,
• 1,000 further decisions from the dataset's train split, reported separately below,
• a 300-item stratified sample of the public Decision Index benchmarks (MMLU, MMLU-Pro, ARC, WinoGrande, HellaSwag, ANLI, BANKING77, CLINC150, When2Call). This is a sample for comparing builds, not a Decision Index score,
• 330 image questions from CV-Bench, RealWorldQA and BLINK, with the same vision projector for every file,
• option shuffling and repeat runs.

Measured with llama.cpp 1e6f04a at the settings above, every file on one NVIDIA A100 80 GB. Public files: ggml-org/Clef-GGUF (d2aa75c) and bartowski/Cloudflare_clef-GGUF (9d3b28a).

The confident-change row counts text answers; on images the Artemis Q2_K file also changed 1. For every file, shuffling the answer options changed no answers and a repeat run gave identical answers. Clef answers a request's questions jointly, so sending them one per request changes 12.8% of the original's own decisions; every number here uses the same request shape. Small differences in this sample should not be treated as general improvements.

Results on other hardware

Same files on other hardware

The same files on two more machines, text checks only, with llama.cpp 1e6f04a (CUDA) and -c 16384 -ub 4096 -b 4096 --parallel 2. Each file is compared with the original run on the same machine. Peak GPU memory is the server process's own allocation as nvidia-smi reports it.

NVIDIA GB10 (DGX Spark)

The GB10 has 128 GB of memory shared by the CPU and GPU. The original ran fully on the GPU with a peak of 49.6 GiB.

Compared with the A100, same answer moves by at most 0.2 points (held-out 0.5), accuracy change by at most half a point, and peak memory is 0.2 to 0.3 GiB lower. The Artemis Q2_K file changed 5 confident answers here against 4 on the A100, and the public IQ3_M changed 1 against 0.

NVIDIA RTX 5090 32 GB

The original does not fit in 32 GB, so it ran with 35 of its 65 layers on the GPU and the rest in system memory. Every other file ran fully on the GPU.

Compared with the A100, same answer moves by at most 0.4 points (held-out 1.2), accuracy change by at most half a point, and peak memory is 0.1 to 0.2 GiB higher. The Artemis Q2_K file changed 5 confident answers here against 4 on the A100.

Memory

Peak GPU memory of llama-server on an NVIDIA A100 80 GB with the settings above: text (-ub 4096 -b 4096) and with the BF16 vision projector loaded (-ub 8192 -b 8192).

So for text, the 14.8 GB file should fit a 16 GB GPU with about 1 GiB to spare; with images it needs more.

Agreement with the original

The agreement numbers from the tables above, in one fixed layout with the protocol behind each table.

Protocols and standard tables

• Same answer as BF16: the share of decisions where the file picks the same answer as the BF16 original, mistakes included. Higher is closer.
• Mean KL to BF16: KL divergence between the original's and the file's answer probabilities, as the protocol describes. Lower is closer.
• Accuracy: the share of decisions that match the panel's labels. Accuracy change: the file's accuracy minus the original's, in points.
• Confident answers changed: answers the original gave with more than 80% probability that the file changed. Lower is closer.

n/a means the card's tables or our run records do not have that value.

Protocol a100-text-20261012

NVIDIA A100 80 GB, 12 October 2026.

• Reference: ggml-org's published BF16 GGUF Clef-BF16.gguf (54.1 GB) from ggml-org/Clef-GGUF, which our files were built from
• Panel test: typed-decisions test split (all 400 cases); dataset: LocalLLaMA/typed-decisions; split: test; cases: 400; decisions: 2000; text SHA-256: 4f294f218ea1da27f3efef936359389c62ea4d3973a41457732990f1d31b647c
• Panel heldout: typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card); dataset: LocalLLaMA/typed-decisions; split: train; cases: 200; decisions: 1000; text SHA-256: 46a58d63edfd86e23229c78afe8b72307bb4ca9fb0e8df180cabb3c67ec9dcd5 (whole train parquet; the 200-case subset has no hash of its own)
• Panel decision_index: Decision Index sample: 300 items, 30 from each of MMLU, MMLU-Pro, ARC-Easy, ARC-Challenge, WinoGrande, HellaSwag, ANLI, BANKING77, CLINC150+OOS and When2Call (seed 20261010); not a Decision Index score; dataset: multiple: cais/mmlu, TIGER-Lab/MMLU-Pro, allenai/ai2_arc, allenai/winogrande, Rowan/hellaswag, facebook/anli, nvidia/When2Call, plus BANKING77 and CLINC150 from GitHub; split: test or validation per source; cases: 300; decisions: 300; text SHA-256: 9cb4301cc7d7d96dde9663263c53020912ad628201e5609ab2d65bf16ebb652e
• Tool: llama-server /v1/systemone, which returns a probability for every allowed answer; all of a case's questions in one request
• llama.cpp build: b11540 (commit 1e6f04a75e91da4bb66b5248f3fd4bdeff169d41)
• Command: llama-server -m <file.gguf> -c 16384 -ub 4096 -b 4096 --parallel 2 -ngl 99 (flags as recorded) with our decision suite, two workers
• Hardware: one NVIDIA A100 80 GB per file
• Settings: 16,384-token context, batch 4,096, two slots, all layers on the GPU
• Measured by: TurinTech measured every file in these tables, including ggml-org's Q8_0 and Q4_K_M and bartowski's IQ3_M, with the same build and settings
• Selection: the test results informed the choice of files, so they are not an independent test
• Source on this card: the table column "Acc. Δ"; the table rows "Same answer as BF16", "Typed-decision accuracy", "Changed answers where BF16 was over 80% sure", "Held-out: same answer as BF16", "Held-out accuracy", "Decision Index sample: same answer as BF16", "Decision Index sample accuracy"
• Comparison files: ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q8_0.gguf, SHA-256 537d3c88008b8a4bcdf12d9b79f1e3161fbe02f530b84048bb8f16461b01ddb3; ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q4_K_M.gguf, SHA-256 9997675e4c9e9016273372b5fdedbdda7ad14285bc722949e4b9daca62bf3822; bartowski: bartowski/Cloudflare_clef-GGUF at 9d3b28af7cfe, Cloudflare_clef-IQ3_M.gguf, SHA-256 4977cdedb8784ed414ae03e17ff0ee33f1be1d6bc89370114ebcbc6c5f818975

Protocol a100-text-20261012, panel test (typed-decisions test split (all 400 cases)):

Protocol a100-text-20261012, panel heldout (typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card)):

Protocol a100-text-20261012, panel decision_index (Decision Index sample: 300 items, 30 from each of MMLU, MMLU-Pro, ARC-Easy, ARC-Challenge, WinoGrande, HellaSwag, ANLI, BANKING77, CLINC150+OOS and When2Call (seed 20261010); not a Decision Index score):

Protocol a100-images-20261012

NVIDIA A100 80 GB, image questions, 12 October 2026.

• Reference: ggml-org's Clef-BF16.gguf with ggml-org's BF16 vision projector mmproj-Clef-BF16.gguf
• Panel images: 330 image questions: CV-Bench (60), RealWorldQA (60), BLINK validation (210, 14 subtasks x 15), images capped at 1.6 MP (seed 20261012); dataset: CV-Bench, RealWorldQA, BLINK-Benchmark/BLINK; split: BLINK validation; cases: 330; decisions: 330; text SHA-256: 46d96d8d9556847a4fd2aecfa930fc47accc15995b0d1f0d83928dee413cf5b1
• Tool: llama-server /v1/systemone with the vision projector, which returns a probability for every allowed answer
• llama.cpp build: b11540 (commit 1e6f04a75e91da4bb66b5248f3fd4bdeff169d41)
• Command: llama-server -m <file.gguf> --mmproj mmproj-Clef-BF16.gguf -c 16384 -ub 8192 -b 8192 --parallel 2 -ngl 99 (flags as recorded) with our decision suite, two workers
• Hardware: one NVIDIA A100 80 GB per file
• Settings: 16,384-token context, batch 8,192, two slots, all layers on the GPU, the same projector for every file
• Measured by: TurinTech measured every file in this table with the same build, settings and projector
• Source on this card: the table rows "Images: same answer as BF16", "Image accuracy"
• Notes: the card's Q2_K entry for changed confident image answers ("+1 image" inside a text cell) is not repeated here
• Comparison files: ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q8_0.gguf, SHA-256 537d3c88008b8a4bcdf12d9b79f1e3161fbe02f530b84048bb8f16461b01ddb3; ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q4_K_M.gguf, SHA-256 9997675e4c9e9016273372b5fdedbdda7ad14285bc722949e4b9daca62bf3822; bartowski: bartowski/Cloudflare_clef-GGUF at 9d3b28af7cfe, Cloudflare_clef-IQ3_M.gguf, SHA-256 4977cdedb8784ed414ae03e17ff0ee33f1be1d6bc89370114ebcbc6c5f818975

Protocol a100-images-20261012, panel images (330 image questions: CV-Bench (60), RealWorldQA (60), BLINK validation (210, 14 subtasks x 15), images capped at 1.6 MP (seed 20261012)):

Protocol gb10-20261013

NVIDIA GB10, 13 October 2026.

• Reference: Clef-BF16.gguf run on the same machine, fully on the GPU
• Panel test: typed-decisions test split (all 400 cases); dataset: LocalLLaMA/typed-decisions; split: test; cases: 400; decisions: 2000; text SHA-256: 4f294f218ea1da27f3efef936359389c62ea4d3973a41457732990f1d31b647c
• Panel heldout: typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card); dataset: LocalLLaMA/typed-decisions; split: train; cases: 200; decisions: 1000; text SHA-256: 46a58d63edfd86e23229c78afe8b72307bb4ca9fb0e8df180cabb3c67ec9dcd5 (whole train parquet; the 200-case subset has no hash of its own)
• Tool: llama-server /v1/systemone, which returns a probability for every allowed answer; all of a case's questions in one request
• llama.cpp build: b11540 (commit 1e6f04a75e91da4bb66b5248f3fd4bdeff169d41)
• Command: llama-server -m <file.gguf> -c 16384 -ub 4096 -b 4096 --parallel 2 -ngl 99 -t 20 (flags as recorded) with our decision suite, two workers
• Hardware: one NVIDIA GB10 (128 GB unified memory)
• Settings: 16,384-token context, batch 4,096, two slots, one file at a time, text checks only
• Measured by: TurinTech measured every file in this table on the same machine; each file is compared with the original run there
• Selection: the test results informed the choice of files, so they are not an independent test
• Source on this card: the table columns "Same answer as BF16", "Accuracy change", "Confident answers changed", "Held-out: same answer"
• Comparison files: ggml-org: ggml-org/Clef-GGUF, Clef-Q8_0.gguf; ggml-org: ggml-org/Clef-GGUF, Clef-Q4_K_M.gguf; bartowski: bartowski/Cloudflare_clef-GGUF, Cloudflare_clef-IQ3_M.gguf

Protocol gb10-20261013, panel test (typed-decisions test split (all 400 cases)):

Protocol gb10-20261013, panel heldout (typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card)):

Protocol rtx5090-20261013

NVIDIA RTX 5090, 13 October 2026.

• Reference: Clef-BF16.gguf run on the same GPU with 35 of 65 layers on the GPU (-ngl 35 -lm none)
• Panel test: typed-decisions test split (all 400 cases); dataset: LocalLLaMA/typed-decisions; split: test; cases: 400; decisions: 2000; text SHA-256: 4f294f218ea1da27f3efef936359389c62ea4d3973a41457732990f1d31b647c
• Panel heldout: typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card); dataset: LocalLLaMA/typed-decisions; split: train; cases: 200; decisions: 1000; text SHA-256: 46a58d63edfd86e23229c78afe8b72307bb4ca9fb0e8df180cabb3c67ec9dcd5 (whole train parquet; the 200-case subset has no hash of its own)
• Tool: llama-server /v1/systemone, which returns a probability for every allowed answer; all of a case's questions in one request
• llama.cpp build: b11540 (commit 1e6f04a75e91da4bb66b5248f3fd4bdeff169d41)
• Command: llama-server -m <file.gguf> -c 16384 -ub 4096 -b 4096 --parallel 2 --fit off -ngl 99 -t 32 (BF16: -ngl 35 -t 128 -lm none) with our decision suite, two workers
• Hardware: one NVIDIA RTX 5090 32 GB
• Settings: 16,384-token context, batch 4,096, two slots, one file at a time, text checks only
• Measured by: TurinTech measured every file in this table on the same GPU; each file is compared with the original run there
• Selection: the test results informed the choice of files, so they are not an independent test
• Source on this card: the table columns "Same answer as BF16", "Accuracy change", "Confident answers changed", "Held-out: same answer"
• Comparison files: ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q8_0.gguf, SHA-256 537d3c88008b8a4bcdf12d9b79f1e3161fbe02f530b84048bb8f16461b01ddb3; ggml-org: ggml-org/Clef-GGUF at d2aa75cb425a, Clef-Q4_K_M.gguf, SHA-256 9997675e4c9e9016273372b5fdedbdda7ad14285bc722949e4b9daca62bf3822; bartowski: bartowski/Cloudflare_clef-GGUF at 9d3b28af7cfe, Cloudflare_clef-IQ3_M.gguf, SHA-256 4977cdedb8784ed414ae03e17ff0ee33f1be1d6bc89370114ebcbc6c5f818975

Protocol rtx5090-20261013, panel test (typed-decisions test split (all 400 cases)):

Protocol rtx5090-20261013, panel heldout (typed-decisions train split, 200 cases outside the first 64 x 512-token imatrix calibration window (labelled "held-out" on the card)):

File names, sizes and SHA-256 checksums

File names

File names end in a standard llama.cpp quant label, so llama.cpp, Ollama and LM Studio can pick a file by tag. Each file is a per-tensor mix of quant types, so the label is a size class: the smallest standard llama.cpp quant whose typical bits per weight are at least the file's. The general.file_type field inside the files reads Q4_K_M, the base type given to llama-quantize; the table shows the tensor types each file holds.

The earlier names were removed from the repository on 26 October 2026; the files under the names above hold the same bytes.

File checksums

Custom versions

We also make fine-tuned and further optimised versions on request: tuned on specific decisions and data, built for the target hardware (CPU servers, laptops, Apple Silicon, edge devices), or compressed from a private model. Book a call with TurinTech.

About and licence

Clef is Cloudflare's 27B decision model. The model accepts text (and optionally images) with a set of typed questions, and it returns a probability for every allowed answer in a single pass, instead of generating text. See the original model card.

This is an independent TurinTech conversion, not affiliated with or endorsed by Cloudflare. The files are standard GGUF and run on stock llama.cpp. For images, use the vision projector from ggml-org/Clef-GGUF (see below). Changes from the original: the weights are converted to GGUF and quantized for llama.cpp. See NOTICE.

Apache-2.0 (see LICENSE and NOTICE), the same as Cloudflare/clef, which is post-trained from Qwen/Qwen3.8-27B.

When serving these files to others, for example through an API, an inference provider or OpenRouter, we'd appreciate a mention of TurinTech (turintech.ai) as the source of the quantization.

These files keep improving.