---
title: "d3"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/df1392ef-31ed-47ea-9dd4-d4148bdc8625"
updated: "2026-11-12"
---

# d3

> 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 or video in one call, returning a probability for each answer instead of text. A 27B decision model for developers building routing and triage.

d3 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 is the 27B decision model in the Decision 3.0 line from the vLLM Semantic Router project. You give it an input, which can be text or JSON with optional images and videos, plus the questions to answer. It replies with a probability for each option and writes no text.

### Who it suits

Developers who need fast, structured decisions such as routing a request, labelling it or scoring it.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Customer support | Support teams | Route tickets to the right team | A damaged-delivery message goes to returns |
| E-commerce | Operations teams | Check a receipt image against an order | Does the receipt list the blender |
| Content moderation | Trust and safety teams | Score how urgent an item is | A queue sorted by urgency |
| Software | Platform developers | Pick a model or path before a request runs | A router that sends easy questions to a small model |

You can skip it if you want long written answers, since it returns probabilities and no generated text.

### Where to use it

- Python, through Hugging Face Transformers
- vLLM Semantic Router, which the card says serves it at speed
- A GPU machine, since the card's timings use an AMD Instinct MI325X

| Use case | Who | What they get back |
| --- | --- | --- |
| Choice question | Developers | A probability for each option, such as returns, billing or technical |
| Yes or no question | Developers | A probability for yes and for no |
| Score question | Developers | A probability for each level, such as routine, soon or today |

### How to set it up

- Python and pip on your computer
- A GPU with enough memory for a 27B model
- The pinned transformers version shown below

1. Install the Python packages.
2. Optionally add the fast kernels for the linear-attention layers.
3. Load the model in Python with remote code allowed, which runs code from the model repository.

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

### How to use it

Load the model, then call system\_one with the input as state and your questions as a 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", 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))
```

### Example

You pass a customer message about a damaged blender and ask which team should handle it. d3 returns a probability for returns, billing and technical, and the returns option should lead.

### For newcomers and experts

If you are new, run the text example as written and read the probabilities it prints. Change the message and see which option wins.

If you know the field, the card says each question gets its own forward pass over the input, so several questions share one call. It reports median latencies of 54.4 ms for text, 290 ms with an image and 500 ms with a 10-second video on one AMD Instinct MI325X.

Text, JSON, images or video → Choice, yes or no, and score questions → One forward pass per question → A probability for every answer

Median latency in ms on one AMD Instinct MI325X

| Label | Value |
| --- | --- |
| Text request | 54.4 ms |
| Request with an image | 290 ms |
| Request with a 10-second video | 500 ms |

### Good to know

- License: Apache 2.0
- Cost to run: your own GPU hardware, and the card says a free trial exists
- Data it reaches: the text, images and videos you give it
- Not for: writing text, since it returns probabilities only
- Remote code: loading needs trust\_remote\_code, so read the repository first

## README

````markdown
# d3

Answers choice, yes-or-no and score questions about text, images or video in one call, returning a probability for each answer instead of text. A 27B decision model for developers building routing and triage.

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 is the 27B decision model in the Decision 3.0 line from the vLLM Semantic Router project. You give it an input, which can be text or JSON with optional images and videos, plus the questions to answer. It replies with a probability for each option and writes no text.

Who it suits: Developers who need fast, structured decisions such as routing a request, labelling it or scoring it.

```table
Industry | Who uses it | How they use it | Example
Customer support | Support teams | Route tickets to the right team | A damaged-delivery message goes to returns
E-commerce | Operations teams | Check a receipt image against an order | Does the receipt list the blender
Content moderation | Trust and safety teams | Score how urgent an item is | A queue sorted by urgency
Software | Platform developers | Pick a model or path before a request runs | A router that sends easy questions to a small model
```

You can skip it if you want long written answers, since it returns probabilities and no generated text.

Where to use it:

- Python, through Hugging Face Transformers
- vLLM Semantic Router, which the card says serves it at speed
- A GPU machine, since the card's timings use an AMD Instinct MI325X

```table
Use case | Who | What they get back
Choice question | Developers | A probability for each option, such as returns, billing or technical
Yes or no question | Developers | A probability for yes and for no
Score question | Developers | A probability for each level, such as routine, soon or today
```

How to set it up:

- Python and pip on your computer
- A GPU with enough memory for a 27B model
- The pinned transformers version shown below

1. Install the Python packages.
2. Optionally add the fast kernels for the linear-attention layers.
3. Load the model in Python with remote code allowed, which runs code from the model repository.

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

How to use it: Load the model, then call system_one with the input as state and your questions as a 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", 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))
```

Example: You pass a customer message about a damaged blender and ask which team should handle it. d3 returns a probability for returns, billing and technical, and the returns option should lead.

For newcomers and experts: If you are new, run the text example as written and read the probabilities it prints. Change the message and see which option wins.

If you know the field, the card says each question gets its own forward pass over the input, so several questions share one call. It reports median latencies of 54.4 ms for text, 290 ms with an image and 500 ms with a 10-second video on one AMD Instinct MI325X.

```flow
Text, JSON, images or video
Choice, yes or no, and score questions
One forward pass per question
A probability for every answer
```

```chart
Title: Median latency in ms on one AMD Instinct MI325X
Text request: 54.4 ms
Request with an image: 290 ms
Request with a 10-second video: 500 ms
```

Good to know:

- License: Apache 2.0
- Cost to run: your own GPU hardware, and the card says a free trial exists
- Data it reaches: the text, images and videos you give it
- Not for: writing text, since it returns probabilities only
- Remote code: loading needs trust_remote_code, so read the repository first

## On Hugging Face, 13 November 2026

- Task: zero shot classification
- Library: transformers
- Parameters: 26.1B
- Weights: about 52.2 GB in BF16; about 13 GB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 10,037
- Likes: 293
- License: apache-2.0
- Based on: Qwen/Qwen3.8-27B
- Quantized versions: 22
- Fine-tunes: 3
- 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
- Files: https://huggingface.co/vllm-sr/d3/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
```

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 on Hugging Face](https://huggingface.co/vllm-sr/d3)

## 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 (this page) | 10,037 | 293 | 26.1B | apache-2.0 | 2026-11-02 |
| [d3-flash](https://mindket.com/p/9f4e35f9-58d2-4c23-bfde-20d3530ef7ce) | 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-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
- [Bluesky · @qdrddr.bsky.social · 2026-10-26](https://bsky.app/profile/qdrddr.bsky.social/post/3mysoc73ldc2p): \#vLLM semantic \#router \#Decision 3.0 \#model. On the \#Jev Decision Index v0.3.2, it scores 66.3 points. Text + Image \#OpenSource Apache 2.0 \#SLM \#LLM \#AI
- [Bluesky · UndergroundAI · 2026-10-14](https://bsky.app/profile/undergroundai66.bsky.social/post/3mxubk4xf2v2l): ⚡ Das Trend-Modell d3 auf HuggingFace 🛠️ Das von vllm-sr entwickelte Modell verzeichnet aktuell starke Aktivität und steigende Beliebtheit in… 🚀 Entdecke diesen und weitere KI-Geheimtipps bei Underground AI. 👉 https://underground-ai.bolt.app/ \#OpenSource \#KuenstlicheIntelligenz
- [Bluesky · input · 2026-10-29](https://bsky.app/profile/feed.igeek.gamer-geek-news.com.ap.brid.gy/post/3myyqf3xmcj72): 📰 \*\*vLLM Semantic Router Releases d3-ultra: A 27B Open Multimodal Decision Model\*\* vLLM Semantic Router released d3-ultra, a 27B open-weight multimodal decision model. It reads text, images and video once, then returns probabilities for every answer, scoring 87.2 on the team’s SR... 📰 Source …
- [Bluesky · gen-ai-news · 2026-10-28](https://bsky.app/profile/gen-ai.news/post/3mywqxtesph2a): d3-ultra is a 27B open-weight model that processes text, image, and video together in one pass, outputting probability distributions instead of single answers. It scored 87.2 on the SR-Text benchmark. Does open-weight multimodal routing make specialized routing infrastructure ...
- [Bluesky · input · 2026-10-27](https://bsky.app/profile/feed.igeek.gamer-geek-news.com.ap.brid.gy/post/3mytoyughc7e2): 📰 \*\*vLLM Semantic Router Releases d3-ultra: A 27B Open Multimodal Decision Model\*\* vLLM Semantic Router released d3-ultra, a 27B open-weight multimodal decision model. It reads text, images and video once, then returns probabilities for every answer, scoring 87.2 on the team’s SR... 📰 Source …

## 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 on Hugging Face](https://huggingface.co/vllm-sr/d3)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/df1392ef-31ed-47ea-9dd4-d4148bdc8625)
- [Its page on Mindket](https://mindket.com/p/df1392ef-31ed-47ea-9dd4-d4148bdc8625)