How Much To Run AI
Open weights

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 ↗
Decision 3.0 takes state and optional media, scores fixed choices, and leaves action thresholds to the application
Decision 3.0 workflow: evidence, fixed-choice probabilities and routing policy.

Use this model

Local tools and guides

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.

CheckpointExact parametersOfficial weights
d3-turbo26.09Bvllm-sr/d3-turbo
d326.09Bvllm-sr/d3
d3-flash8.39Bvllm-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.

Free hosted request using an API credential stored on your server
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.

Minimal local choice request, adapted from the official model card
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)

Calculators