d3-turbo 27B

d3-turbo 27B is a 26.09-billion parameter dense decision model developed by vLLM Semantic Router as part of their Decision 3.0 family. Unlike standard autoregressive generative language models that produce token-by-token text completions, d3-turbo operates as a pure decision engine. It evaluates input data: text, structured JSON, images, or video frames: and returns calibrated probabilities across defined outputs, including categorical choices, binary booleans, continuous scores, bounding boxes, and temporal video tracks.

The release marks a significant departure from using heavy generative models for system-level classification, policy checking, and visual routing. Instead of parsing unreliable structured text or JSON schemas out of a generative pipeline, practitioners use d3-turbo to query inputs deterministically. The weights are distributed under the permissive Apache-2.0 license, making it a viable foundation component for on-premise inference architectures, low-latency API gateways, and automated agent pipelines.

For local deployment, this 26.09B parameter architecture bridges the gap between lightweight classification heads and oversized general-purpose LLMs. It delivers near-instant state evaluation across massive context windows up to 131,072 tokens. Because it evaluates query options without entering an autoregressive generation loop, it drastically cuts the compute overhead usually spent on generating boilerplate text.

At its core, d3-turbo uses a dense transformer architecture totaling 26.09 billion parameters, which includes an integrated 0.46-billion parameter vision encoder. The model builds on the architectural foundations of modern dense models like Qwen, but replaces standard causal token generation with multi-head classification and spatial-temporal grounding readouts.

A critical design feature is its single-pass state evaluation. In standard multi-question routing setups, conventional models re-encode the entire context for every query. In contrast, d3-turbo encodes the state context (such as a lengthy system prompt, a complex document, or video frames) once into memory. Subsequent queries: whether categorical choices, confidence scores, or spatial bounding boxes: are evaluated directly against the cached representation. In benchmarks, evaluating 255 questions against a single image or document takes roughly 2.12 seconds on server-grade hardware, whereas architectures that re-process context for every question take over 30 seconds.

The context window defaults to 32,768 tokens per query and expands to 131,072 tokens when initialized with long_context=True. Managing a 131k context window in a dense 26.09B model requires careful attention to key-value (KV) cache sizing, but because the model does not generate long output sequences, the KV cache footprint during the decode phase is non-existent. You only pay the memory cost of the prompt prefill and the answer-head readout.

Rather than generating prose, d3-turbo answers structured questions through native decision primitives:

• Categorical Selection (`choice`): Returns calibrated probability distributions over dynamic lists of choices. It handles complex intent routing, dynamic tool selection, and semantic dispatch in agentic systems without schema hallucination.
• Binary Verification (`yes/no`): Fast boolean validation for safety filters, hallucination detection, prompt-injection screening, and PII redacting.
• Numerical Scoring (`score`): Continuous ratings on arbitrary scales, useful for automated data curation, reward modeling, and evaluating RAG chunk relevance.
• Visual Grounding and Object Detection (`box`): Returns normalized bounding box coordinates alongside calibrated confidence metrics (achieving 0.90 accuracy at IoU 0.5) directly from natural language prompts.
• Temporal Video Tracking (`track`): Tracks objects across full video sequences at 1 to 2 updates per second, outputting coordinates, presence confidence, and tracking continuity without dedicated external tracking pipelines.

A notable feature is the ability to place images directly inside question definitions and individual options rather than solely within the system state. For example, a practitioner can pass a text log as context and present four visual UI options to determine where a user action occurred, with only the relevant question attending to the visual inputs.

To run d3-turbo 27B locally, hardware planning centers on hosting 26.09 billion parameters while allocating enough headroom for the prefill KV cache across large context windows.

In unquantized BF16 precision, the model weights occupy roughly 52.2 GB of VRAM. Accounting for CUDA runtime overhead and dynamic KV cache allocation, running full-precision inference requires a 64 GB to 80 GB setup, such as an NVIDIA A100/H100 or an AMD Instinct MI300X/MI325X.

For consumer hardware and developer workstations, quantization is necessary:

• FP16 / BF16 (Unquantized): Requires 60 GB to 64 GB total VRAM. Best run on dual RTX 3090/4090 GPUs (48 GB pooled via tensor parallelism or model offloading, though large contexts will spill) or a unified memory workstation (Apple Silicon with 64 GB+ RAM).
• Q8_0 (8-bit quantization): Requires ~32 GB VRAM for weights, ~38 GB total for comfortable context operation. Fits on a dual RTX 3090/4090 setup or an Apple M-series Mac with 48 GB to 64 GB unified memory.
• Q4_K_M (4-bit quantization): Requires ~16.5 GB VRAM for weights, ~20 GB to 24 GB total with a 32k context buffer. This is the sweet spot for single-card consumer setups.

• Best GPU for d3-turbo 27B (Single Consumer Card): A single NVIDIA GeForce RTX 3090 or RTX 4090 (24 GB VRAM) running a Q4_K_M quantization. This fits the base weights and leaves enough headroom for 32,768 tokens of context.
• Best Multi-GPU Setup: Dual RTX 3090 or RTX 4090 GPUs running tensor parallelism via vLLM. This allows running Q8_0 or near-lossless INT8 configurations with full 131k context capability.
• Apple Silicon: Mac Studio or MacBook Pro equipped with an M3/M4 Max or Ultra chip and at least 36 GB to 64 GB of unified memory.

If you are figuring out how to run 26.09B model on consumer GPU setups, note that the best quantization for d3-turbo 27B is Q4_K_M. It retains decision calibration accuracy on Jev Decision Index evaluations while lowering memory requirements by more than 60 percent compared to BF16.

Because d3-turbo is developed natively within the vLLM ecosystem, the official vLLM serving stack provides the most optimized path.

Deploying via vLLM using a single GPU:

1vllm serve vllm-sr/d3-turbo \
2  --tensor-parallel-size 1 \
3  --gpu-memory-utilization 0.95 \
4  --max-model-len 32768

For rapid local testing, standard Ollama or llama.cpp runtimes supporting dense Qwen-family derivatives can host the GGUF variants. However, to leverage native multi-question state caching and visual tracking APIs, using the vLLM engine or Hugging Face Transformers AutoModel runtime is recommended.

When measuring d3-turbo 27B performance, evaluating throughput using standard "d3-turbo 27B tokens per second" metrics can be misleading. Because the model does not autoregressively generate output text, its latency profile consists almost entirely of prompt processing (prefill) time and a single forward pass for the answer readout. On an RTX 4090 at Q4_K_M, a 4,000-token prompt prefill completes in 80 to 120 milliseconds, with decision head readout returning in under 15 milliseconds.

When evaluating d3-turbo 27B hardware requirements against alternative architectures, the model occupies a unique niche in the local AI model 26.09B parameters 2026 landscape.

Standard Qwen 2.5 causal models are built for text generation. When used for routing or classification, Qwen 2.5 32B must process the prompt and then generate strings (such as JSON blocks or choice tokens). This introduces sampling latency, non-zero failure rates due to malformed output formats, and requires post-processing logic. Furthermore, Qwen 2.5 32B requires 20 GB of VRAM at 4-bit, pushing close to single-GPU limits when paired with long context. While Qwen 2.5 14B is lighter (around 10 GB at 4-bit), its zero-shot classification calibration and visual-spatial reasoning do not match d3-turbo. Choose d3-turbo if you need deterministic probabilities, bounding boxes, or sub-second routing across multi-branch agent pipelines.

Dedicated 8B parameter routing models consume less memory (5 GB to 6 GB at 4-bit) and run comfortably on entry-level hardware like the RTX 4060 or 4070. However, 8B models struggle with complex document context windows beyond 16k tokens and lack unified visual bounding box or temporal tracking capabilities. If your workflow involves multimodal inputs, complex tool-selection logic across massive system prompts, or multi-question evaluations on a single document, d3-turbo 27B justifies the higher VRAM investment.