---
title: "d3-flash"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce"
updated: "2026-11-12"
---

# d3-flash

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

A 9B model that answers several choice, yes or no and score questions about text, images or video in one call, returning a probability for every answer instead of generated text. For routing and decision tasks.

d3-flash 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-flash is the 9B multimodal decision model of Decision 3.0, built for vLLM Semantic Router. You hand it an input and a set of questions, and it answers all of them in one call. Each answer comes back as a probability for every option, and no text is generated.

### Who it suits

Developers who need to sort, check or rate inputs automatically, such as incoming messages or documents with images. It fits systems that want a fast, scored decision rather than a written reply.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support engineers | Route each request to the right team and flag urgency | Score a damaged-delivery message for team, receipt and urgency |
| E-commerce | Order-handling teams | Check an attached receipt image against a claim | Ask whether the receipt lists the product |
| AI infrastructure | Teams running vLLM Semantic Router | Use it as the decision model in a routing setup | Send each request's questions to the model and read the probabilities |
| Operations | Workflow builders | Turn free-form input into choices, yes or no answers and ratings | Rate how urgent an incoming request is |

You can skip it if you want written answers, chat or summaries. It returns probabilities, not text.

### Where to use it

- Python on Windows, macOS and Linux, through the transformers library
- vLLM Semantic Router, which the card names as its serving setup
- GPU servers, where the card measured speed on a single AMD Instinct MI325X

| Use case | Who | What they get back |
| --- | --- | --- |
| Routing a request | Support and ops teams | A probability for each team you list |
| Yes or no checks | Developers | A probability for yes and for no |
| Rating on a scale | Workflow builders | A probability for each level you define |
| Questions about images or video | Product teams | Answers that take attached images or clips into account |

### How to set it up

You need Python and the packages below. A GPU speeds it up.

- Python on Windows, macOS or Linux
- The pip packages from the quickstart
- Optionally, flash-linear-attention for fast GPU kernels

1. Install Python if you do not have it.
2. Install the packages with the commands below.
3. Load the model with transformers in your script.

```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
```

```bash
pip install -U huggingface_hub
hf download vllm-sr/d3-flash
```

### How to use it

Load the model, then call system\_one with the input as state and a questions dictionary. Each question has a type, instructions and criteria. The result holds the answers with their probabilities.

```python
import json

from huggingface_hub import hf_hub_download
from transformers import AutoModel

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

# Text
result = model.system_one(
    state="The order arrived damaged yesterday. The customer has a receipt and asks for a replacement today.",
    questions={
        "route": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "returns": "Refunds, replacements and damaged deliveries",
                "billing": "Payments, invoices and charges",
                "technical": "Product setup and faults"
            }
        },
        "receipt": {
            "type": "noul",
            "instructions": "Does the customer have a receipt?"
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgent is this request?",
            "criteria": [
                "Routine",
                "Soon",
                "Today"
            ]
        }
    },
)
print(json.dumps(result["answers"], indent=2))
```

For images, add an images argument holding file paths, web links, PIL objects or base64 strings. Videos accept file paths, links, base64 strings or arrays of frames.

| Tool | What it does |
| --- | --- |
| system\_one | Answers all your questions about one input in a single call |
| choice question | Picks among options you describe in criteria |
| yes or no question | Returns a probability for each side |
| score question | Rates the input on the levels you list |

### Example

You send a message saying a delivered order arrived damaged and the customer has a receipt, with three questions. One asks which team should handle it, one asks about the receipt and one rates urgency. Back come probabilities for every option of each question.

### For newcomers and experts

Think of it as a quick sorter. You give it something to look at and a few questions with fixed answers, and it tells you how likely each answer is. Start by running the text example and reading the printed answers.

The model is 8.39B parameters, including a 0.46B vision encoder. Every question gets its own pass through the model over the input, which is why no text generation is needed. Timings on a single AMD Instinct MI325X: 19.2 ms median for text only, 166 ms when an image is attached, 371 ms when a 10-second clip is attached. Videos are read at 2 frames per second.

Send text, JSON, images or video → Add choice, yes or no and score questions → One call runs a pass per question → Get a probability for every answer

Median latency on one AMD Instinct MI325X, in milliseconds

| Label | Value |
| --- | --- |
| Text request | 19.2 ms |
| Request with an image | 166 ms |
| Request with a 10-second video | 371 ms |

### Good to know

- Images can be PNG, JPEG or WebP, and videos can be MP4, WebM, MOV or MKV, several per request.
- Loading uses trust\_remote\_code, which runs code that ships with the model, so read it first.
- With vLLM Semantic Router the card reports 95 requests per second on one MI325X.
- License: Apache-2.0.
- Cost to run: none named. The card lists a free demo and uses an AMD GPU for its own timings.
- Data it reaches: files from Hugging Face, plus any text, images, videos or URLs you pass in.
- Not for: writing text, since it returns probabilities without generating text.

## README

````markdown
# d3-flash

A 9B model that answers several choice, yes or no and score questions about text, images or video in one call, returning a probability for every answer instead of generated text. For routing and decision tasks.

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-flash is the 9B multimodal decision model of Decision 3.0, built for vLLM Semantic Router. You hand it an input and a set of questions, and it answers all of them in one call. Each answer comes back as a probability for every option, and no text is generated.

Who it suits: Developers who need to sort, check or rate inputs automatically, such as incoming messages or documents with images. It fits systems that want a fast, scored decision rather than a written reply.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support engineers | Route each request to the right team and flag urgency | Score a damaged-delivery message for team, receipt and urgency
E-commerce | Order-handling teams | Check an attached receipt image against a claim | Ask whether the receipt lists the product
AI infrastructure | Teams running vLLM Semantic Router | Use it as the decision model in a routing setup | Send each request's questions to the model and read the probabilities
Operations | Workflow builders | Turn free-form input into choices, yes or no answers and ratings | Rate how urgent an incoming request is
```

You can skip it if you want written answers, chat or summaries. It returns probabilities, not text.

Where to use it:

- Python on Windows, macOS and Linux, through the transformers library
- vLLM Semantic Router, which the card names as its serving setup
- GPU servers, where the card measured speed on a single AMD Instinct MI325X

```table
Use case | Who | What they get back
Routing a request | Support and ops teams | A probability for each team you list
Yes or no checks | Developers | A probability for yes and for no
Rating on a scale | Workflow builders | A probability for each level you define
Questions about images or video | Product teams | Answers that take attached images or clips into account
```

How to set it up: You need Python and the packages below. A GPU speeds it up.

- Python on Windows, macOS or Linux
- The pip packages from the quickstart
- Optionally, flash-linear-attention for fast GPU kernels

1. Install Python if you do not have it.
2. Install the packages with the commands below.
3. Load the model with transformers in your script.

```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
```

```bash
pip install -U huggingface_hub
hf download vllm-sr/d3-flash
```

How to use it: Load the model, then call system_one with the input as state and a questions dictionary. Each question has a type, instructions and criteria. The result holds the answers with their probabilities.

```python
import json

from huggingface_hub import hf_hub_download
from transformers import AutoModel

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

# Text
result = model.system_one(
    state="The order arrived damaged yesterday. The customer has a receipt and asks for a replacement today.",
    questions={
        "route": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "returns": "Refunds, replacements and damaged deliveries",
                "billing": "Payments, invoices and charges",
                "technical": "Product setup and faults"
            }
        },
        "receipt": {
            "type": "noul",
            "instructions": "Does the customer have a receipt?"
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgent is this request?",
            "criteria": [
                "Routine",
                "Soon",
                "Today"
            ]
        }
    },
)
print(json.dumps(result["answers"], indent=2))
```

For images, add an images argument holding file paths, web links, PIL objects or base64 strings. Videos accept file paths, links, base64 strings or arrays of frames.

```table
Tool | What it does
system_one | Answers all your questions about one input in a single call
choice question | Picks among options you describe in criteria
yes or no question | Returns a probability for each side
score question | Rates the input on the levels you list
```

Example: You send a message saying a delivered order arrived damaged and the customer has a receipt, with three questions. One asks which team should handle it, one asks about the receipt and one rates urgency. Back come probabilities for every option of each question.

For newcomers and experts: Think of it as a quick sorter. You give it something to look at and a few questions with fixed answers, and it tells you how likely each answer is. Start by running the text example and reading the printed answers.

The model is 8.39B parameters, including a 0.46B vision encoder. Every question gets its own pass through the model over the input, which is why no text generation is needed. Timings on a single AMD Instinct MI325X: 19.2 ms median for text only, 166 ms when an image is attached, 371 ms when a 10-second clip is attached. Videos are read at 2 frames per second.

```flow
Send text, JSON, images or video
Add choice, yes or no and score questions
One call runs a pass per question
Get a probability for every answer
```

```chart
Title: Median latency on one AMD Instinct MI325X, in milliseconds
Text request: 19.2 ms
Request with an image: 166 ms
Request with a 10-second video: 371 ms
```

Good to know:

- Images can be PNG, JPEG or WebP, and videos can be MP4, WebM, MOV or MKV, several per request.
- Loading uses trust_remote_code, which runs code that ships with the model, so read it first.
- With vLLM Semantic Router the card reports 95 requests per second on one MI325X.
- License: Apache-2.0.
- Cost to run: none named. The card lists a free demo and uses an AMD GPU for its own timings.
- Data it reaches: files from Hugging Face, plus any text, images, videos or URLs you pass in.
- Not for: writing text, since it returns probabilities without generating text.

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Library: transformers
- Parameters: 8.4B
- Weights: about 16.8 GB in BF16; about 4.2 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 103,577
- Likes: 114
- License: apache-2.0
- Based on: Qwen/Qwen3.5-9B
- Quantized versions: 17
- Fine-tunes: 15
- 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-flash
- Files: https://huggingface.co/vllm-sr/d3-flash/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-flash
```

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

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

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

## 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-flash (this page) | 103,577 | 114 | 8.4B | apache-2.0 | 2026-11-02 |
| [d3-mini](https://mindket.com/p/4e08c56c-92f6-4e07-8884-2cd16598fc8b) | 53,115 | 75 | 4.5B | apache-2.0 | 2026-10-30 |
| [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.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Bluesky · asura · 2026-10-12](https://bsky.app/profile/asura.dev/post/3mxoqzvvzys27): The vLLM team steps into the ring Multimodal jev-like from the semantic router team

## 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-11-02
- 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-flash on Hugging Face](https://huggingface.co/vllm-sr/d3-flash)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce)
- [Its page on Mindket](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce)
