turintech/d1-3B-Artemis-GGUF

TurinTech models, built with Artemis

Liquid AI's d1-3B for typed decisions about text on a 4 GB GPU or a CPU, and about images with Liquid AI's projector. It answers typed questions with a probability for each answer, in one pass.

• 1.673 GB download for the default file, d1-3B-Artemis-Q4_K_M.gguf.
• Peak GPU memory 2.7 GiB for text on an NVIDIA RTX 3060 12 GB; 2.0 GiB of RAM on an AMD Ryzen 9 5900X.
• Mean KL to the original 0.00366 on 400 final-set decisions, run once after the choice, against 0.00949 for Liquid AI's Q4_K_M (1.674 GB).

Run it

This is a decision model: send typed questions to llama-server's /v1/systemone endpoint, not to chat. Needs llama.cpp b11483 or newer, the release that added d1-3B support (published 8 October 2026). Tested at commit 1e6f04a (b11540). On a CPU, release b11483 gave the same output as 1e6f04a for the example request below.

llama-server -hf turintech/d1-3B-Artemis-GGUF:Q4_K_M --port 8080 -c 16384 -ub 4096 -b 4096 -np 1

Download, request example, images, Ollama and LM Studio

Or download the exact file and start it:

hf download turintech/d1-3B-Artemis-GGUF d1-3B-Artemis-Q4_K_M.gguf --local-dir .
llama-server -m d1-3B-Artemis-Q4_K_M.gguf --port 8080 -c 16384 -ub 4096 -b 4096 -np 1

llama-server -m d1-3B-Artemis-Q4_K_M.gguf --port 8080 -c 16384 -ub 4096 -b 4096 -np 1

The numbers on this card were measured with these settings and one request slot (-np 1); other slot counts were not tested. -c 16384 stops the server from reserving memory for the full training context. The command has no -ngl: on an NVIDIA RTX 3060 it put all 31 layers on the GPU.

Save this request as request.json. A request has one state and named questions of three types: choice (pick one option), noul (yes or no) and score (a level on a scale):

{
  "state": "A coding agent was asked to delete temporary build files. It ran rm -rf ./build inside the project, then ran git push --force to the main branch.",
  "questions": {
    "action": {
      "type": "choice",
      "instructions": "What should the monitor do with this agent run?",
      "criteria": {
        "continue": "Let the agent carry on.",
        "flag": "Let it carry on but flag the run for later review.",
        "stop": "Stop the agent now."
      }
    },
    "review": {
      "type": "noul",
      "instructions": "A person should review this run."
    },
    "risk": {
      "type": "score",
      "instructions": "How risky were the agent's actions?",
      "criteria": [
        "Safe: read-only actions.",
        "Low: routine changes within the task.",
        "High: irreversible or out-of-scope changes."
      ]
    }
  }
}

Send it:

curl -s http://127.0.0.1:8080/v1/systemone -H 'Content-Type: application/json' -d @request.json | python3 -m json.tool

Output from this file on an NVIDIA RTX 3060 with llama.cpp b11540 built for CUDA:

{
    "model": "d1-3B-Artemis-Q4_K_M.gguf",
    "answers": {
        "action": {
            "type": "choice",
            "choice": "stop",
            "probabilities": {
                "continue": 0.1142894072266347,
                "flag": 0.10225450924347625,
                "stop": 0.783456083529889
            },
            "confidence": 0.6751841252948335
        },
        "review": {
            "type": "noul",
            "noul": 0.9363200421263398
        },
        "risk": {
            "type": "score",
            "score": 1.8868376569206433,
            "legend": {
                "0": "Safe: read-only actions.",
                "1": "Low: routine changes within the task.",
                "2": "High: irreversible or out-of-scope changes."
            },
            "probabilities": {
                "0": 0.02149732402944982,
                "1": 0.0701676950204574,
                "2": 0.9083349809500929
            },
            "confidence": 0.8302564853809644
        }
    },
    "usage": {
        "input_tokens": 236,
        "output_tokens": 0
    }
}

noul is the probability of yes, and score is the expected level. On a CPU the same build gives the same answers, with probabilities differing by up to 0.0051.

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

Images

Only the text model is compressed. For images, download Liquid AI's projector and add --mmproj, then put an images list of data URLs (data:image/png;base64,...) next to state and questions in the request. This pairing passed a smoke test only:

hf download LiquidAI/d1-3B-GGUF mmproj-d1-3B-Q8_0.gguf --revision bb1e436ea78eb96a3f1acb6da865f70c2fbeb563 --local-dir .
llama-server -m d1-3B-Artemis-Q4_K_M.gguf --mmproj mmproj-d1-3B-Q8_0.gguf --port 8080 -c 16384 -ub 4096 -b 4096 -np 1

Recommended Ollama package

echo "A coding agent was asked to delete temporary build files. It ran rm -rf ./build inside the project, then ran git push --force to the main branch." | ollama run turintech/d1-3b-artemis:q4_k_m --ask "A person should review this run."

This verified tag selects d1-3B-Artemis-Q4_K_M.gguf and prints yes 94%. Ollama 0.40.9 was tested; add "model": "turintech/d1-3b-artemis:q4_k_m" to request.json and send it to Ollama's port (11434 by default). The package sets the card's 16K context (num_ctx 16384). The explicit tag selects the recommended file and is not an immutable revision.

Apps and Ollama

The llama.cpp button under "Use this model" starts it as a chat model, which is not a supported way to run it. The LM Studio button imports the file without the context and batch settings above; use the Hub entry in LM Studio instead. Otherwise use llama-server and /v1/systemone as above, or the Ollama package.

Instead of the package, the file can be imported into Ollama from a Modelfile with a 16K context:

hf download turintech/d1-3B-Artemis-GGUF d1-3B-Artemis-Q4_K_M.gguf --local-dir .
printf 'FROM ./d1-3B-Artemis-Q4_K_M.gguf\nPARAMETER num_ctx 16384\n' > Modelfile
ollama create d1-3b-artemis -f Modelfile
echo "A coding agent was asked to delete temporary build files. It ran rm -rf ./build inside the project, then ran git push --force to the main branch." | ollama run d1-3b-artemis --ask "A person should review this run."

The last command prints yes 94%; for /v1/systemone, use "model": "d1-3b-artemis". In our tests with Ollama 0.40.9 on the Vulkan backend of an NVIDIA RTX 3060, the package pulled from ollama.com (24 October 2026) and the imported file (23 October) gave the same answers as llama-server on the same machine (stop, yes, level 2), with probabilities within 0.0034. Requests were sent one at a time; concurrent requests through Ollama were not tested. Ollama's CUDA backend was not tested: the test machine's NVIDIA driver (535) is older than that backend requires. The numbers on this card were measured with llama-server; Ollama sets its own batch size, so the probabilities can differ slightly.

LM Studio

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

lms get turintech/d1-3b-artemis@q4_k_m --gguf
lms load turintech/d1-3b-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/d1-3b-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. d1-3B-Artemis-Q4_K_M.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.

d1-3B needs a recent llama.cpp engine in LM Studio: engine 2.64.0 loaded it, and engine 2.54.0 refused it with unsupported decision model type: lfm2-d1. If you see that error, update the llama.cpp engine in LM Studio's runtime settings.

Only text input was tested in LM Studio.

Choose this model

• Best for typed decisions about text on a 4 GB GPU or a CPU.
• Consider another file when the answer must stay the same when the options are reordered: shuffling changed 10.56% of answers for this file and 6.11% for Liquid AI's Q4_K_M, which also agrees slightly more often (94.00% against 93.75%).

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/d1-3B-Artemis-GGUF:Q4_K_M.
• The Ollama tag runs our package, which holds the same file: ollama run turintech/d1-3b-artemis:<tag>.
• LM Studio's Hub entry turintech/d1-3b-artemis offers every model file above, without the importance matrix or the vision projector.

Images need Liquid AI's projector as well; memory with it was not measured.

How the files compare

"Saved" is the file-size reduction versus the BF16 original, whose size here is its text model as a BF16 GGUF, 5.40 GB (Liquid AI's d1-3B-BF16.gguf); the vision projector is a separate download for both. The other columns come from the final set: 400 test decisions that played no part in choosing the file. "Same answer" is how often the file picks the same option as the original. "Acc. Δ" is the accuracy change against the original in percentage points, measured against the dataset's synthetic teacher labels. "Conf. changes" counts answers the original was more than 80% sure of (126 of the 400) that the file changed. The variant link downloads the exact GGUF. The label is a size class, explained under "File names, sizes and SHA-256 checksums" at the end of the card.

Results

Our file against Liquid AI's Q4_K_M and the original on the final set: 400 test decisions from 80 cases, run once after the 320-case full set chose the file.

Its answers move more when the options are shuffled: 10.56% changed, against 6.11% for Liquid AI's Q4_K_M. How it was tested.

Mean KL divergence of each file's answer probabilities from the original's, on the final set: 80 test cases (400 decisions) run once, after this file was chosen. Lower is better; the original is the reference and is not plotted. At the same size, this file's mean KL is 39% of Liquid AI's Q4_K_M's, but its answers are more sensitive to option order. See How it compares.

How it compares

How it compares

Typed decisions from the test split of LocalLLaMA/typed-decisions, with every file on the same llama.cpp build and settings. The final set is 80 cases (400 decisions) run once, after this file was chosen. The full set is 320 other cases (1,600 decisions); it chose this file from three finalists, so its results are exposed to that selection. "Same answer as original" measures how often the original's top answer is kept, including its mistakes. The dataset is public and may overlap with the original model's training data.

Final set: 80 cases, 400 decisions, 126 of them answered by the original with more than 80% probability.

Full set: 320 cases, 1,600 decisions, 484 of them answered by the original with more than 80% probability. These cases chose this file.

Same answer as original does not separate the two files on the final set (one decision fewer of 400); on the full set, which chose this file, it is higher. For accuracy, the paired 95% intervals against the original and against Liquid AI's Q4_K_M include zero on both sets, which does not show that the files are equally accurate. Answers are more sensitive to option order: on the final set the paired interval against Liquid AI's Q4_K_M excludes zero.

Brackets are 95% percentile intervals from a paired bootstrap over cases: 2,000 resamples, and 10,000 for option shuffling. Hard-label NLL and Brier score against the teacher labels were also measured: for this file and both Liquid AI files, the paired 95% intervals against the original include zero on both sets.

Evaluation details and limitations

How it was tested

Test data and exposure

The test split of LocalLLaMA/typed-decisions asks typed questions about a state: pick one option (choice), yes or no (noul), or a level on a scale (score), about five questions per case, labelled by a teacher model. Before any compressed file was scored, the test cases were drawn once, stratified by workflow: 64 quick cases, 320 full cases that include the quick ones, and 80 final cases disjoint from both. The quick cases screened early builds, the full set chose this file from three finalists by lowest mean KL, and the final set ran once, after that choice, on this file, the original and the two Liquid AI files. Calibration and the search that produced the finalists used only the train split, and no case ID or normalised state appears in both splits. The same test split was used to evaluate TurinTech's earlier decision-model releases. The dataset is public and may be in the original model's training data.

Runtime and metrics

llama.cpp b11540 (commit 1e6f04a), built with CUDA 12.2, on one NVIDIA RTX 3060 12 GB, with -c 16384 -ub 4096 -b 4096 -np 1, all layers on the GPU and 12 CPU threads, sending all of a case's questions in one request. The original is the BF16 GGUF conversion of the text model, with tensors byte-identical to Liquid AI's d1-3B-BF16.gguf. Liquid AI's files are d1-3B-Q8_0.gguf and d1-3B-Q4_K_M.gguf from LiquidAI/d1-3B-GGUF revision bb1e436, checked by SHA-256.

• Mean KL to original: for each decision, the sum over options of p_original × ln(p_original / p_file), averaged over decisions.
• Same answer as original: the share of decisions where the file's most probable option is the original's.
• Confident answers changed: decisions where the original's top probability is above 0.8 and the file picks another option.
• Answers changed by option shuffling: each of 120 final-set and 480 full-set decisions asked again with its options in three random orders (360 and 1,440 answers), and the share whose top answer changes.

For every file, repeated requests gave identical answers, and asking each question in its own request gave the same answers as asking all of a case's questions together. The largest per-workflow accuracy drop against the original is 0.25 points on the full set, a tie between agent_trace_observability (interval -2.25 to +1.75) and security_incidents (interval -1.50 to +1.00), and 2.00 points on the final set (customer_service, interval -6.00 to +2.00). This card makes no speed claims: every run used one shared desktop GPU.

Decision Index sample (public, previously scored)

A 300-item sample of public benchmarks read as decisions: MMLU, ARC-Easy, ARC-Challenge, WinoGrande, HellaSwag, ANLI, BANKING77, CLINC150 with out-of-scope queries, MMLU-Pro and When2Call. These items are public and have been scored before, and the original model may have seen them, so this is a profile, not held-out evidence and not a Decision Index score. The 86 items with 10 or more options come from BANKING77, CLINC150 and MMLU-Pro.

Images

With Liquid AI's mmproj-d1-3B-Q8_0.gguf, a smoke test sent four image questions (a colour, a count, a shape and a two-cat photo), each with a text-only twin, plus a control with a changed image. This file and the original both answered all four images and the control correctly, the image changed the answer against its text-only twin in all four pairs, and this file's top answer matched the original's on all nine requests. This says the image path works; it does not measure vision quality. Video was not tested.

Conversion check

The BF16 GGUF this file was quantized from was compared with Liquid AI's own Transformers code on 20 test cases (100 decisions), against a gate of at least 98% same top answer and mean KL at most 0.005. With a bf16 reference on GPU it failed the agreement gate at 97% (mean KL 0.0011); two of the three differing decisions were exact ties in the bf16 reference. A second comparison, declared after the first failed, used an fp32 reference on CPU and passed at the threshold, 98% (mean KL 0.00085).

Calibration and the file

The file was quantized with llama.cpp llama-quantize (b11540) from that BF16 conversion, using an importance matrix computed with llama-imatrix over state and question text, without labels, from the train split of LocalLLaMA/typed-decisions (revision 468b146). The importance matrix is published in this repository as d1-3B-Artemis-imatrix.gguf_file; it is not a model file. The GGUF header names that file and the dataset in quantize.imatrix.file and quantize.imatrix.dataset, holds no local path, and reads TurinTech in general.quantized_by. The evaluations above ran on an earlier header of this file with byte-identical tensors.

Memory

Peak GPU memory of llama-server on an NVIDIA RTX 3060 12 GB with llama.cpp 1e6f04a and the settings above, all layers on the GPU: the highest nvidia-smi sample, taken about once a second, over the full-set, final-set and Decision Index runs (Liquid AI's Q8_0 was not in the Decision Index run).

The default file should fit a 4 GB GPU for text. On a CPU alone (AMD Ryzen 9 5900X, the same build with no GPU visible), the server's peak resident memory was 2.0 GiB with the command in Run it and the example request; it counts the parts of the memory-mapped file that were read. Host memory over a longer session, and memory with the vision projector loaded, were not measured.

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 rtx3060-1e6f04a-20261023

One NVIDIA RTX 3060, 23 October 2026.

• Reference: BF16 GGUF conversion of LiquidAI/d1-3B revision 051bcc464b01b9f92942b364d9586b0ef5912432 (llama.cpp 1e6f04a converter), tensors identical to Liquid AI's d1-3B-BF16.gguf; GGUF SHA-256 6fe16f9fa0e940502883780d0f6f6daca5d01247dd34cc2579a1178453b9e3ff
• Panel final: Final set: LocalLLaMA/typed-decisions test split, 80 reserved cases run once after the file was chosen; dataset: LocalLLaMA/typed-decisions; split: test; cases: 80; decisions: 400; text SHA-256: 4f294f218ea1da27f3efef936359389c62ea4d3973a41457732990f1d31b647c (SHA-256 of the whole test-split file)
• Panel full: Full set: LocalLLaMA/typed-decisions test split, 320 cases that chose the file; dataset: LocalLLaMA/typed-decisions; split: test; cases: 320; decisions: 1,600; text SHA-256: 4f294f218ea1da27f3efef936359389c62ea4d3973a41457732990f1d31b647c (SHA-256 of the whole test-split file)
• Panel decision_index: Decision Index sample, all 300 items (public, previously scored; a profile, not a Decision Index score); dataset: MMLU, ARC-Easy, ARC-Challenge, WinoGrande, HellaSwag, ANLI, BANKING77, CLINC150 with out-of-scope queries, MMLU-Pro, When2Call; split: per source benchmark; cases: 300; decisions: 300; text SHA-256: 9cb4301cc7d7d96dde9663263c53020912ad628201e5609ab2d65bf16ebb652e
• Panel decision_index_10plus: Decision Index sample, the 86 items with 10 or more options (BANKING77, CLINC150, MMLU-Pro); dataset: BANKING77, CLINC150, MMLU-Pro; split: per source benchmark; cases: 86; decisions: 86
• Tool: llama-server /v1/systemone, which returns a probability for every allowed answer (d1 scores one prompt per question, options in the given order); all of a case's questions in one request
• llama.cpp build: b11540 (commit 1e6f04a75e91da4bb66b5248f3fd4bdeff169d41), CUDA 12.2
• Command: llama-server -m <file.gguf> -c 16384 -ub 4096 -b 4096 --parallel 1 -ngl 99 -t 12 with our decision suite as the client, one worker
• Hardware: one NVIDIA RTX 3060 12 GB
• Settings: 16,384-token context, batch 4,096, one slot, all layers on the GPU, 12 CPU threads, no projector
• Measured by: TurinTech measured every file in these tables, including Liquid AI's Q8_0 and Q4_K_M, with the same build, settings and GPU. Our numbers were measured on an earlier header of the published file with the same tensors
• Selection: the 320-case full set chose the file; the 80-case final set was run once, after the choice
• Source on this card: the table columns "Same answer as original", "Accuracy", "Acc. Δ", "Confident answers changed", "Same answer as original, 300 items", "Accuracy, 300 items", "Same answer as original, 86 items", "Accuracy, 86 items with 10+ options", "Mean KL to original"
• Comparison files: Liquid AI: LiquidAI/d1-3B-GGUF at bb1e436ea78e, d1-3B-Q8_0.gguf, SHA-256 2f0942d5a5f64cf69c3356d2be439b71644b1f0eb3a580912a5a0179eeaba77d; Liquid AI: LiquidAI/d1-3B-GGUF at bb1e436ea78e, d1-3B-Q4_K_M.gguf, SHA-256 16aff27ea2eefdc32b9897f43854a5d3170c1dc8dccb9c756905af30a4e22402

Protocol rtx3060-1e6f04a-20261023, panel final (Final set: LocalLLaMA/typed-decisions test split, 80 reserved cases run once after the file was chosen):

Protocol rtx3060-1e6f04a-20261023, panel full (Full set: LocalLLaMA/typed-decisions test split, 320 cases that chose the file):

Protocol rtx3060-1e6f04a-20261023, panel decision_index (Decision Index sample, all 300 items (public, previously scored; a profile, not a Decision Index score)):

Protocol rtx3060-1e6f04a-20261023, panel decision_index_10plus (Decision Index sample, the 86 items with 10 or more options (BANKING77, CLINC150, MMLU-Pro)):

File names, sizes and SHA-256 checksums

File names

The file name ends in a standard llama.cpp quant label, so llama.cpp, Ollama and LM Studio can pick the file by tag. The file is a per-tensor mix of quant types with no type making up 90% of the bytes, so the label is a size class: the smallest standard llama.cpp quant whose typical bits per weight are at least the file's. Over the whole file and all 2,697,198,592 weights it has 4.96 bits per weight, against 4.97 for Liquid AI's Q4_K_M on the same count. The general.file_type field inside the file also reads Q4_K_M.

File checksums

Liquid AI's vision projector, for images: mmproj-d1-3B-Q8_0.gguf from LiquidAI/d1-3B-GGUF revision bb1e436, 583,109,728 bytes, sha256 2505920ce464b7c54acd8b7b74a931c0c671f06d0c8833760b2fbceeb253e92a.

About and licence

d1-3B is a 3B decision model by Liquid AI, built on LFM2.5-VL-3B. 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 Liquid AI. The file is standard GGUF and runs on stock llama.cpp. For images, use Liquid AI's vision projector (see Images). Changes from the original: the text model is converted to GGUF and quantized for llama.cpp; the vision projector is not included and not changed. See NOTICE.

LFM Open License v1.0, the licence Liquid AI releases d1-3B under (licence); see LICENSE and NOTICE. Section 5 of the licence does not license commercial use by an organisation that exceeds its threshold, defined as annual revenue of USD 10 million or more.

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.