# d3-turbo

> Source: https://aiwiki.ai/wiki/d3_turbo
> Updated: 2026-10-20
> Categories: AI Inference, AI Models, Multimodal AI, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "d3-turbo." aiwiki.ai, 20 Oct 2026. https://aiwiki.ai/wiki/d3_turbo
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

d3-turbo is a multimodal decision model in the Decision 3.0 family from the [vLLM](https://aiwiki.ai/wiki/vllm) Semantic Router team. It produces structured decisions and probabilities rather than free-form generated text.[2][7] Its published package contains a Qwen3.5-based backbone, a vision encoder and a separate answer readout. The package manifest identifies 26,086,635,760 loaded parameters, including the readout, while the hosted service describes it as a 27B model.[2][9]

## Model specifications

| Property | Published configuration |
| --- | --- |
| Model identifier | `vllm-sr/d3-turbo` |
| Family | Decision 3.0 |
| Backbone model type | `qwen3_5` |
| Text backbone parameters | 25,624,600,064 |
| Vision encoder parameters | 460,730,096 |
| Answer readout parameters | 1,305,600 |
| Text layers | 64 |
| Text hidden size | 5,120 |
| Full-attention interval | Every fourth text layer |
| Weight precision | [bfloat16](https://aiwiki.ai/wiki/bfloat16) backbone; float32 answer readout |
| Distribution | Downloadable weights and custom runtime on [Hugging Face](https://aiwiki.ai/wiki/hugging_face) |
| License | Apache-2.0 for the weights, readout and runtime |

The counts and license above come from the package manifest; architecture fields come from the model configuration.[2][3] The configuration's positional-embedding setting is not itself a promise about accepted request length. The decision configuration validates 32,768 tokens by default, and the runtime's `long_context=True` option raises its per-question cap to 131,072.[4][5]

## Inputs and decisions

A request provides a shared input called `state` and a dictionary of named questions. State can carry text or JSON, with images or videos supplied alongside it. Different questions can ask different things about the same input. The interface uses typed answer objects rather than a conversation transcript.[6][7]

| Question type | Meaning | Answer |
| --- | --- | --- |
| `choice` | Select among described alternatives | Selected option and a probability distribution |
| `noul` | Answer a yes/no question | Probability that the answer is yes |
| `score` | Evaluate an ordered rating scale | Expected level, probabilities and a level legend |
| `box` | Locate a described target | One bounding box and confidence |
| `track` | Follow a target through a video | Timestamped boxes, confidence and visibility values |

The choice and yes/no formats are defined by the answer-code contract; score and media responses are implemented by the runtime.[5][12] Image references can also appear in instructions or choices. The media-composition code keeps those images within the relevant question block rather than making every question see them.[13]

Choice and score outputs also include confidence. In the published runtime, their confidence is one minus the normalized Shannon entropy of the answer distribution. It measures how concentrated the probabilities are, not an independently measured guarantee that the selected answer is correct. The score is the probability-weighted mean of zero-based level indices.[5]

Box coordinates are fractions of image height and width, measured from the top-left corner. The service documentation describes box confidence as an estimate that overlap with the true box reaches an intersection-over-union threshold of 0.5. A box is returned even for an absent target, so a separate presence question is needed when absence is possible.[6]

## Shared-state execution

The runtime calls its shared-input execution path StateOnce. With `prefix_bidir` attention, the input is divided into a state block and a question block. Full-attention layers let state tokens attend within the state, while question tokens attend to that state and their own question. State tokens do not attend to questions. The runtime can therefore compute the state once and reuse its full-attention keys and values, recurrent states and convolution states for the request's question batches.[4][5]

The configuration alternates three linear-attention layers with one full-attention layer. Its text network has 64 layers, 24 attention heads and four key-value heads.[3] This is the architecture used by the released checkpoint, not a claim that any [Qwen3.5](https://aiwiki.ai/wiki/qwen3_5) checkpoint automatically behaves as a decision model.

The Transformers integration loads the decision runtime through `AutoModel` with `trust_remote_code=True`. Loading the backbone alone does not reproduce the decision interface: the repository also supplies the answer readout and decision configuration. The wrapper uses one execution device; `device_map="auto"` does not turn it into a general multi-device deployment.[7]

## Running the model

The Python entry point is `model.system_one(...)`. The following illustrates a text-only request with locally selected labels, without implying any particular prediction:[7]

```python
from transformers import AutoModel

model = AutoModel.from_pretrained(
    "vllm-sr/d3-turbo",
    revision="cfa0d41d253467e4742d5aedb46d4f0ef3b84b41",
    trust_remote_code=True,
)
result = model.system_one(
    state="The customer wants to change their delivery address.",
    questions={
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this request?",
            "criteria": {
                "delivery": "Delivery support",
                "payments": "Payment support",
            },
        }
    },
)
```

The pinned revision identifies a specific package snapshot. Its requirements specify Transformers 5.17.0.[8] Enabling remote model code executes repository-provided Python, so the code and dependencies require review before use.

The hosted Decision API accepts requests at `POST /v1/systemone`. Since October 19, 2026, its `vllm-sr/d3` identifier has been an alias for d3-turbo. At the October 20 check, model-specific limits allowed 64 questions, 16 images of up to 16 MiB each and 131,072 state characters. The service also listed one video of up to 60 seconds. Hosted request limits are separate from local model limits and can change.[6][9]

## Published evaluation

The model card reports the following results. The Jev estimates are the developers' estimates, not official leaderboard results.[1]

| Evaluation | d3-turbo | Comparison or qualification |
| --- | --- | --- |
| Jev Decision Index text | 70.2 | Author estimate; d3 official-board score 66.3 |
| Jev Decision Index vision | 72.9 | Author estimate; d3 official-board score 71.3 |
| Public text suite, official 0.3 kit | 71.7 | Developers measured d3 at 65.5 |
| Box accuracy at IoU 0.5 | 0.90 | Developers' Box test set |
| Box confidence AUROC | 0.96 | Developers' Box test set |
| Tracking success AUC, 1 / 2 updates per second | 0.79 / 0.80 | Developers' tracking clips |

The Jev methodology separates a public score from a full score that combines public tasks with private tests of related skills and new decision domains. Its public index applies chance correction and coverage penalties. Neither index is simply percentage accuracy across all questions.[10]

For one photo on one AMD Instinct MI325X, using AutoModel, the card reports these median request latencies:[1]

| Questions | d3-turbo | d3-flash |
| --- | --- | --- |
| 1 | 302 ms | 154 ms |
| 64 | 867 ms | 8.26 s |
| 255 | 2.12 s | 32.94 s |

The 15.5x comparison applies to the 255-question test, not every workload. The smaller d3-flash was faster for one question.[1] The repository's benchmark adapter defines latency as synchronized in-process wall time, including prompt rendering, tokenization and media preprocessing, but excluding model loading.[11] These measurements do not establish hosted-network latency or capacity under concurrent production traffic.

## Limits and data handling

This is a typed decision interface, not a general-purpose text-generation endpoint. An over-limit question is rejected rather than silently truncated, and runtime behavior depends on the supplied decision configuration.[4][5]

The free API states that requests and responses, including images and videos, may be logged and used for service operation, model training and evaluation. Its documentation advises against sending sensitive personal, confidential or regulated data. That hosted-service policy is separate from downloading the model and running it on an operator's own infrastructure.[6]

## References

1. vLLM Semantic Router Team. [d3-turbo model card](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/README.md). Revision `cfa0d41d253467e4742d5aedb46d4f0ef3b84b41`, accessed October 20, 2026.
2. vLLM Semantic Router Team. [d3-turbo package manifest](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/MODEL_MANIFEST.json). Accessed October 20, 2026.
3. vLLM Semantic Router Team. [d3-turbo model configuration](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/config.json). Accessed October 20, 2026.
4. vLLM Semantic Router Team. [d3-turbo decision configuration](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/decision_config.json). Accessed October 20, 2026.
5. vLLM Semantic Router Team. [d3-turbo runtime implementation](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/d3_runtime.py). Accessed October 20, 2026.
6. vLLM Semantic Router Team. [Decision API reference](https://decision.vllm-sr.ai/docs). Accessed October 20, 2026.
7. vLLM Semantic Router Team. [d3-turbo Transformers integration](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/modeling_d3.py). Accessed October 20, 2026.
8. vLLM Semantic Router Team. [d3-turbo runtime requirements](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/requirements.txt). Accessed October 20, 2026.
9. vLLM Semantic Router Team. [Decision API live model and service limits](https://decision.vllm-sr.ai/api/info). Accessed October 20, 2026.
10. Jev Decision Index maintainers. [Decision Index 0.3.2 methodology](https://assix-research-jev-decision-index.static.hf.space/methodology.html). Accessed October 20, 2026.
11. vLLM Semantic Router Team. [d3-turbo Decision Index adapter](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/d3_engine.py). Accessed October 20, 2026.
12. vLLM Semantic Router Team. [d3-turbo prompt and answer-code contract](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/d3_format.py). Accessed October 20, 2026.
13. vLLM Semantic Router Team. [d3-turbo media-composition implementation](https://huggingface.co/vllm-sr/d3-turbo/blob/cfa0d41d253467e4742d5aedb46d4f0ef3b84b41/d3_compose.py). Accessed October 20, 2026.