---
title: "d3-mini"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b"
updated: "2026-11-12"
---

# d3-mini

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Answers choice, yes or no, and score questions about text, images and video in one call, returning a probability for each answer instead of generated text. For developers who route or triage requests.

d3-mini is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by vllm-sr

## About

### What it is

d3-mini is a decision model from vllm-sr, built on Qwen/Qwen3.5-4B and part of Decision 3.0. You give it an input and a set of questions, and it returns a probability for every possible answer. It does not write text back.

### Who it suits

Developers who need a quick, structured judgment on messy input, such as which team should take a message or how urgent it is. The input can be text or JSON, with images and videos added.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support engineers | Send each incoming message with questions about team, receipt and urgency | A damaged-delivery message is scored for which team handles it and how urgent it is |
| E-commerce | Shop developers | Attach a receipt image and ask what it lists | A cracked blender photo and receipt are checked against the order |
| Software | Backend developers | Add the model behind a router that picks a path for each request | A request is sent to returns, billing or technical based on the top probability |
| Evaluation | Model researchers | Compare decision quality against earlier Decision models | Run the same questions through two versions and compare the probabilities |

Skip it if you want a chat model that writes replies, because this one only scores the options you give it.

### Where to use it

- Python scripts that load it through the transformers library
- A GPU machine, since the card's speed numbers come from one AMD Instinct MI325X
- vLLM Semantic Router, for serving it to many requests at once
- Windows, macOS or Linux for downloading the files

What you get back

| Use case | Who | What they get back |
| --- | --- | --- |
| Routing | Support and ops teams | A probability for each team you list |
| Yes or no checks | Developers | A probability for yes and for no |
| Scoring | Analysts | A probability for each point on a scale you define |

### How to set it up

You need Python and pip, plus enough disk for the weights, which Hugging Face lists as about 9.1 GB in BF16 or about 2.3 GB at 4-bit as an estimate.

- Python with pip
- A GPU is advised, since the card reports its speeds on one
- The transformers version the card pins

1. Install the libraries the card lists.
2. Optionally add the package for fast linear-attention GPU kernels.
3. Load the model in Python with remote code allowed.

```bash
pip install "transformers==5.17.0" torch torchvision pillow opencv-python-headless safetensors accelerate
pip install flash-linear-attention  # optional: fast GPU kernels for the linear-attention layers
```

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("vllm-sr/d3-mini", trust_remote_code=True)
```

### How to use it

Load the model once, then call its system\_one method with the input text, any images, and a dictionary of questions. Each question has a type, instructions and the options to weigh.

| Tool | What it does |
| --- | --- |
| AutoModel.from\_pretrained | Loads the model from the Hugging Face repository |
| system\_one | Answers all your questions about one input in a single call |
| choice question | Picks among options you describe, with a probability for each |
| score question | Rates the input on a scale you define |

### Example

You pass a message saying a blender arrived cracked, plus the receipt image. You ask which team should handle it, whether the receipt lists the blender, and how the order was paid. You get a probability for every option of each question.

### For newcomers and experts

If you are new to this, think of it as a quick sorter rather than a chatbot. You describe the options, hand it a message or a picture, and it tells you how likely each option is. Start with the text-only example from the card.

Under the hood, it is a 4.54B-parameter model that includes a 0.33B vision encoder. Each question gets its own forward pass over the input, so several questions about one input are answered together. Videos are read at 2 frames per second. Batching in vLLM Semantic Router raised throughput by 2.7 times over AutoModel, per the card.

Send text, images or video → Add your questions and options → Each question gets its own pass → Read a probability per option

### Good to know

Median time per request on one AMD Instinct MI325X

| Label | Value |
| --- | --- |
| Text request | 18.1 ms |
| Request with an image | 112 ms |
| Request with a 10-second video | 336 ms |

- License: Apache 2.0
- Cost to run: none named, though the card's numbers come from a GPU
- Data it reaches: whatever input you pass, including files, links or base64 images, and it loads remote code from its repository
- Not for: writing text, because it returns probabilities for answers you define
- The card reports 52.6 on the Jev Decision Index 0.3.2 official text board

## README

````markdown
# d3-mini

Answers choice, yes or no, and score questions about text, images and video in one call, returning a probability for each answer instead of generated text. For developers who route or triage requests.

Made by vllm-sr on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: d3-mini is a decision model from vllm-sr, built on Qwen/Qwen3.5-4B and part of Decision 3.0. You give it an input and a set of questions, and it returns a probability for every possible answer. It does not write text back.

Who it suits: Developers who need a quick, structured judgment on messy input, such as which team should take a message or how urgent it is. The input can be text or JSON, with images and videos added.

```table
Title: Who uses it, and how
Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Send each incoming message with questions about team, receipt and urgency | A damaged-delivery message is scored for which team handles it and how urgent it is
E-commerce | Shop developers | Attach a receipt image and ask what it lists | A cracked blender photo and receipt are checked against the order
Software | Backend developers | Add the model behind a router that picks a path for each request | A request is sent to returns, billing or technical based on the top probability
Evaluation | Model researchers | Compare decision quality against earlier Decision models | Run the same questions through two versions and compare the probabilities
```

Skip it if you want a chat model that writes replies, because this one only scores the options you give it.

Where to use it:

- Python scripts that load it through the transformers library
- A GPU machine, since the card's speed numbers come from one AMD Instinct MI325X
- vLLM Semantic Router, for serving it to many requests at once
- Windows, macOS or Linux for downloading the files

```table
Title: What you get back
Use case | Who | What they get back
Routing | Support and ops teams | A probability for each team you list
Yes or no checks | Developers | A probability for yes and for no
Scoring | Analysts | A probability for each point on a scale you define
```

How to set it up: You need Python and pip, plus enough disk for the weights, which Hugging Face lists as about 9.1 GB in BF16 or about 2.3 GB at 4-bit as an estimate.

- Python with pip
- A GPU is advised, since the card reports its speeds on one
- The transformers version the card pins

1. Install the libraries the card lists.
2. Optionally add the package for fast linear-attention GPU kernels.
3. Load the model in Python with remote code allowed.

```bash
pip install "transformers==5.17.0" torch torchvision pillow opencv-python-headless safetensors accelerate
pip install flash-linear-attention  # optional: fast GPU kernels for the linear-attention layers
```

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("vllm-sr/d3-mini", trust_remote_code=True)
```

How to use it: Load the model once, then call its system_one method with the input text, any images, and a dictionary of questions. Each question has a type, instructions and the options to weigh.

```table
Tool | What it does
AutoModel.from_pretrained | Loads the model from the Hugging Face repository
system_one | Answers all your questions about one input in a single call
choice question | Picks among options you describe, with a probability for each
score question | Rates the input on a scale you define
```

Example: You pass a message saying a blender arrived cracked, plus the receipt image. You ask which team should handle it, whether the receipt lists the blender, and how the order was paid. You get a probability for every option of each question.

For newcomers and experts: If you are new to this, think of it as a quick sorter rather than a chatbot. You describe the options, hand it a message or a picture, and it tells you how likely each option is. Start with the text-only example from the card.

Under the hood, it is a 4.54B-parameter model that includes a 0.33B vision encoder. Each question gets its own forward pass over the input, so several questions about one input are answered together. Videos are read at 2 frames per second. Batching in vLLM Semantic Router raised throughput by 2.7 times over AutoModel, per the card.

```flow
Send text, images or video
Add your questions and options
Each question gets its own pass
Read a probability per option
```

Good to know:

```chart
Title: Median time per request on one AMD Instinct MI325X
Text request: 18.1 ms
Request with an image: 112 ms
Request with a 10-second video: 336 ms
```

- License: Apache 2.0
- Cost to run: none named, though the card's numbers come from a GPU
- Data it reaches: whatever input you pass, including files, links or base64 images, and it loads remote code from its repository
- Not for: writing text, because it returns probabilities for answers you define
- The card reports 52.6 on the Jev Decision Index 0.3.2 official text board

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Library: transformers
- Parameters: 4.5B
- Weights: about 9.1 GB in BF16; about 2.3 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 53,115
- Likes: 75
- License: apache-2.0
- Based on: Qwen/Qwen3.5-4B
- Quantized versions: 11
- Fine-tunes: 16
- Tags: transformers, safetensors, qwen3_5, feature-extraction, zero-shot-classification, decision-model, classification, system-one, multimodal, vision, video

## Links

- Model: https://huggingface.co/vllm-sr/d3-mini
- Files: https://huggingface.co/vllm-sr/d3-mini/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download vllm-sr/d3-mini
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[vllm-sr/d3-mini on Hugging Face](https://huggingface.co/vllm-sr/d3-mini)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| d3-mini (this page) | 53,115 | 75 | 4.5B | apache-2.0 | 2026-10-30 |
| [d3-flash](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce) | 103,577 | 114 | 8.4B | apache-2.0 | 2026-11-02 |
| [d3](https://mindket.com/p/df1392ef-31ed-47ea-9dd4-d4148bdc8625) | 10,037 | 293 | 26.1B | apache-2.0 | 2026-11-02 |
| [d3-nano](https://mindket.com/p/28987981-5b6c-44a7-86e5-287f8ec4336b) | 7,779 | 49 | 2.2B | apache-2.0 | 2026-11-02 |
| [d3-edge](https://mindket.com/p/33cf2059-d4c7-48c1-ae2e-04d63a9ada68) | 5,937 | 59 | 594M | apache-2.0 | 2026-11-02 |
| [d3-turbo](https://mindket.com/p/98d80d31-de45-4b9b-9ad7-ba14820f8211) | 4,186 | 133 | 26.1B | apache-2.0 | 2026-11-02 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-30
- First published: 2026-10-10
- Checked on Hugging Face: 2026-11-12
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open vllm-sr/d3-mini on Hugging Face](https://huggingface.co/vllm-sr/d3-mini)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/4e08c56c-92f6-4e07-8884-2cd16598fc8b)
- [Its page on Mindket](https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b)
