d3

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.

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.

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.

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

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:

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.