Decision 3.0: multimodal decisions and self-hosting cost
Decision 3.0 is vLLM Semantic Router’s family of open-weight models for bounded decisions. Supply text or JSON, optionally images or video, and define the allowed answers. The model returns probabilities for those answers, so an application can route a request, score a case or ask for review.
Content reviewed:
Open the Decision 3.0 model family ↗
Use this model
Local tools and guides
- Official installation and multimodal examples
Follow the tool’s installation and hardware requirements.
Use cases
- Route requests among a fixed set of teams or tools.
- Check image or video evidence against explicit questions.
- Score a proposed action with a defined rubric before executing it.
Which Decision 3.0 model should I start with?
The family includes the upgraded d3-turbo alongside d3, d3-flash, d3-mini, d3-nano, d3-lite and d3-edge. Test the smaller checkpoints on the same task and labels to compare accuracy and serving cost.
The two larger model cards document text, image and video inputs. Their parameter totals include a 0.46B vision encoder. Apache 2.0 permits use of the released weights under its terms; GPU capacity and operation are separate costs.
| Checkpoint | Exact parameters | Official weights |
|---|---|---|
| d3-turbo | 26.09B | vllm-sr/d3-turbo |
| d3 | 26.09B | vllm-sr/d3 |
| d3-flash | 8.39B | vllm-sr/d3-flash |
What changes with d3-turbo?
The 26.09B d3-turbo checkpoint reads the state once per request and answers multiple questions from it. It supports choice, yes/no, score, image or video-moment boxes and video tracking. The default per-question context is 32,768 tokens; local calls can opt into 131,072 with long_context=True. It returns decisions and probabilities without generating prose.
The publisher’s one-MI325X AutoModel comparison shows d3-flash faster for a single question, while Turbo benefits from several questions over the same evidence. Its 15.5× result uses 255 questions on one photo. The free API allows up to 64 questions, so that largest batching result describes self-hosting, not an ordinary hosted request.
Try the free Decision API before self-hosting
The publisher operates a free key-based API at decision.vllm-sr.ai. Since October 19, requests naming vllm-sr/d3 use d3-turbo as an alias; the returned model identifies Turbo. A local download of vllm-sr/d3 remains a separate checkpoint, so record both the requested name and resolved model when comparing runs.
POST /v1/systemone accepts state and questions. A Turbo choice needs at least two options. On this endpoint one failed question fails the whole request with 422 question_failed; /v1/decisions instead reports each question in place. Inspect the current models and /api/info for live limits, daily quotas and supported question types. Free access still has capacity limits, and self-hosting still incurs infrastructure costs.
curl https://decision.vllm-sr.ai/v1/systemone \
-H "Authorization: Bearer $DECISION_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"vllm-sr/d3-turbo","state":"A damaged parcel needs replacing.","questions":{"route":{"type":"choice","instructions":"Which team handles this?","criteria":{"returns":"Damaged deliveries","billing":"Payments"}}}}'Run Decision 3.0 with Transformers
The model cards provide a custom Transformers implementation and pin transformers==5.17.0, alongside PyTorch, torchvision, Pillow, OpenCV, safetensors and accelerate. Install the documented environment, inspect the repository code loaded by trust_remote_code=True, and pin a revision for repeatable tests.
Use system_one with a state and named questions. A choice question has instructions and criteria keyed by the allowed labels; noul handles yes/no, and score uses an ordered rubric. Read result["answers"] rather than expecting a generated chat response.
from transformers import AutoModel
model = AutoModel.from_pretrained(
"vllm-sr/d3-flash", trust_remote_code=True
)
result = model.system_one(
state="The parcel arrived broken. The buyer asks for a replacement.",
questions={
"route": {
"type": "choice",
"instructions": "Which team should handle this request?",
"criteria": {
"returns": "Damaged deliveries and replacements",
"billing": "Payments and invoices",
"review": "Insufficient evidence for a route"
}
}
}
)
print(result["answers"])How Decision 3.0 reads images and video
Add images or videos to the same request; each question receives the supplied media. The documented defaults read images at up to 1.6 megapixels and video at two frames per second, capped at 32 frames spread across the clip and up to 0.2 megapixels per frame.
These sampling rules matter for decisions about brief events or small details. Build test cases where the needed evidence is visible at the chosen resolution and frame sampling, and retain the media settings with each result. The original d3 and d3-flash perform a separate forward pass for each question. Turbo reuses the state across questions, changing the cost of asking many questions about one input.
What does self-hosting Decision 3.0 cost?
The official d3 and d3-flash model cards provide weights and self-deployment examples. Hugging Face lists no Inference Provider for either model. For third-party hosting, inference.sh lists browser and API access billed by GPU time per second; get its current dollar rate before budgeting. For self-hosting, budget GPU time and storage alongside the Apache-licensed weights.
For a cloud deployment, estimate monthly cost as the full instance hourly quote multiplied by billed hours, then add storage and other applicable charges. Divide that total by the number of accepted decisions, including retries and review costs, when comparing with an API.
Measure peak memory, concurrent requests, question count and media handling on the checkpoint and runtime you will use. The model cards give no minimum VRAM requirement or dollar-per-decision rate, so use those measurements to size your deployment.
How should I evaluate Decision 3.0?
The d3 card reports 65.45 on the public Jev Decision Index 0.3 suite, covering 140,178 requests; d3-flash reports 57.79. These are publisher runs on released weights. Separately, the d3 card lists 64.7 for the full Jev Decision Index 0.3.1. That aggregate, the 0.3 public suite and vision or video tests are different measurements.
The publisher measures latency on one AMD Instinct MI325X, one request at a time. For your serving configuration, check accuracy, probability calibration, latency and escalation rates on labeled cases, then measure concurrent throughput on the target hardware.
Decision 3.0 or Microsoft-Decision-1?
Decision 3.0 fits a deployment where you control weights and need images or video alongside text. Microsoft-Decision-1 offers a hosted text-only decision route in Foundry and through Azure on OpenRouter, with a documented input-token price. It removes the need to operate the weights yourself.
Compare the same labels and state, then account for local serving hours versus billed API input. Microsoft’s launch benchmarks and Decision 3.0’s Jev Index runs use different evaluations; compare performance on one shared set of labeled cases. Clef is another choice when a Workers AI endpoint or its open weights fit the application.
Before you use it
- Outputs score predefined answers; use a generative model when the task needs prose or code.
- Media sampling and the number of questions change the serving workload.
How to get started
Start with a labeled sample and the official local example, then measure errors, memory and latency under the workload you intend to serve.
Sources
Sources (6)
- d3-turbo model and serving measurements ↗
Source checked:
- Official hosted Decision API reference ↗
Source checked:
- inference.sh third-party d3-flash access listing ↗
Source checked:
- Official Decision 3.0 collection ↗
Source checked:
- d3 model card, implementation and Apache license ↗
Source checked:
- d3-flash model card and implementation ↗
Source checked: