Valen-Decision-1.5-27B

Valen-Decision-1.5-27B is a specialized, dense 26.1B parameter decision model developed by Valen as a full fine-tune of Qwen3.8-27B. Built to serve as a fast "System One" judgment engine, the model fundamentally rethinks how language models handle structured choices. Instead of using standard autoregressive decoding to output text tokens, Valen-Decision processes inputs through custom scoring and grounding heads, returning calibrated softmax probabilities over candidate classes alongside spatial bounding boxes in a single forward pass.

This architecture directly addresses the operational bottlenecks of running generative LLMs for operational tasks like customer message triage, catalog moderation, and action tagging. Valen provides free hosted API access for its lighter 0.8B, 2B, and 4B checkpoints, but the flagship 27B model is strictly self-hosted. If you want the higher reasoning precision of the largest checkpoint, you must run Valen-Decision-1.5-27B locally on your own hardware. Released under an open Apache-2.0 license, it is distributed in native Transformers format, ONNX graphs, and GGUF binaries.

Valen-Decision-1.5-27B builds upon a dense 26.1B parameter transformer backbone inherited from Qwen3.8-27B, modified with block-bidirectional attention and dedicated readout heads. Because it is a dense architecture rather than a Mixture of Experts (MoE), every parameter is active during inference. While this requires allocating memory for the full weight set, dense execution provides predictable memory bandwidth saturation and stable execution times across varied batch sizes.

The core differentiator lies in how the model scores choices without token generation:

• Role-Based Candidate Projection: The model avoids vocabulary token generation entirely. Instead, the final hidden states are split into four distinct roles: mean-pooled context, mean-pooled instruction, mean-pooled candidate span, and a dedicated decision marker token. These roles are normalized and mapped via a shared projection to width 256.
• Dual Mixer Blocks: A set of residual MLP blocks mixes information across the four roles (expanding 4 to 16, then back to 4) followed by a channel-mixing MLP (expanding 256 to 1024, then back to 256) utilizing GELU activations. A linear readout layer outputs an unnormalized logit for each candidate.
• Grounding Bounding Box Head: Alongside classification probabilities, the architecture incorporates a spatial regression head capable of outputting coordinates for object and text grounding queries.
• Shared-State Batching: Multiple questions regarding the same underlying context share a single backbone forward pass. Candidate options and schemas are concatenated into one causal sequence, allowing ticket routing, sentiment scoring, and tag assignment to be computed simultaneously without reprocessing the prompt.

The model is distributed in multiple execution targets. Native PyTorch weights serve standard training and fine-tuning pipelines. For production deployment, Valen provides ONNX exports (FP32, a mixed Q8-MLP variant for CPU setups, and CUDA-FP16 for NVIDIA platforms) and GGUF quantization files compatible with llama.cpp runtimes.

Valen-Decision-1.5-27B is purpose-built for zero-generation, deterministic classification and routing where traditional generative models prove too slow, costly, or prone to formatting hallucinations.

• Automated Support Ticket Routing: Evaluate incoming customer communications across hundreds of potential intent buckets, priority tiers, and sentiment ratings in one evaluation step. Because output probabilities are normalized across provided candidates via softmax, teams can establish firm confidence thresholds before handing tickets over to human agents.
• Compliance and Content Moderation: Screen user-submitted text and metadata against regulatory predicates. The model evaluates whether a passage violates specific policy boundaries without generating explanatory filler tokens, returning clean binary or multiclass confidence metrics.
• Catalog and Metadata Screening: In production pipelines, the model checks textual item descriptions against compliance criteria, flags inconsistencies, and utilizes its grounding head to locate specific target entities or text regions within inputs.
• Structured Decision Interfaces: Traditional LLMs frequently break downstream software by emitting invalid JSON strings or conversational conversational preamble. Valen-Decision-1.5-27B sidesteps JSON parsers by design, delivering direct numerical probability distributions over candidate arrays directly to application logic.

Evaluating a local AI model with 26.1B parameters in 2026 requires balancing memory bandwidth, VRAM capacity, and runtime selection. Because the model skips autoregressive token generation, Valen-Decision-1.5-27B performance is governed by prompt processing and single-pass forward latency rather than continuous token-by-token generation speeds.

Memory requirements depend on target quantization and runtime format:

• FP16 / BF16 (Native PyTorch / ONNX CUDA-FP16): Requires approximately 53 GB to 55 GB of VRAM. Running unquantized requires dual 24 GB GPUs (with pipeline or tensor parallelism) or a dedicated enterprise accelerator such as an NVIDIA A100 or H100 (80 GB).
• Q8_0 / Q8-MLP: Consumes roughly 28 GB to 30 GB. Suitable for a workstation with dual RTX 3090/4090 GPUs, an RTX 6000 Ada, or Apple Silicon machines configured with 36 GB or more of unified memory.
• Q4_K_M (Recommended GGUF Quantization): Requires approximately 16 GB to 18 GB of VRAM. This is the best quantization for Valen-Decision-1.5-27B on consumer hardware, fitting comfortably on a single 24 GB GPU with enough headroom for context caching and OS overhead.

The best GPU for Valen-Decision-1.5-27B in a single-card setup is an NVIDIA GeForce RTX 4090 (24 GB) or an RTX 3090 (24 GB) using Q4_K_M GGUF or 4-bit weights. On these GPUs, a single forward pass completes in roughly 40ms to 90ms depending on context length, allowing high-throughput routing at dozens of decisions per second.

For Mac users, an Apple Silicon M3 Max or M4 Max with 48 GB, 64 GB, or 128 GB of unified memory runs the Q8_0 or FP16 models smoothly via llama.cpp or GGUF-compatible engines.

If you are planning how to run this 26.1B model on consumer GPUs with 16 GB of VRAM (such as an RTX 4080), you will need more aggressive 3-bit quantization (Q3_K_M), or you must offload several layers to system RAM, which introduces a substantial latency penalty.

• GGUF via llama.cpp / Custom Runtimes: For lowest memory footprint on consumer hardware, utilize the provided GGUF checkpoints. If you manage models using Ollama, you can import the GGUF file via a custom Modelfile to run the model locally as an HTTP service.
• ONNX Runtime: Practitioners running NVIDIA servers often opt for the cuda-fp16 ONNX export using the Valen Python SDK or onnxruntime-gpu. It removes PyTorch framework overhead and relies on direct CUDA execution providers.
• Valen-Decision-1.5-27B Tokens Per Second: While standard LLMs are benchmarked on text generation tokens per second, Valen-Decision processes input tokens and terminates on the decision head readout. On an RTX 4090, input ingestion speeds typically reach 2,500 to 4,000 prompt tokens per second during the forward evaluation phase before returning the final probabilities.

Understanding where Valen-Decision-1.5-27B fits requires comparing it to standard generative models of comparable weight class.

• Valen-Decision-1.5-27B vs Qwen2.5-32B-Instruct: Qwen2.5-32B is a general-purpose instruction model. When tasked with categorization or routing, Qwen2.5 must read the prompt, begin autoregressive token generation, output a JSON schema, and close the syntax tags. This introduces latency (often 300ms to 1200ms depending on output length) and risks malformed formatting or semantic drift. Valen-Decision-1.5-27B completes the assessment in a fraction of that time in a single pass, outputting raw float probabilities. However, Qwen2.5-32B remains necessary if your application requires open-ended conversational replies, text rewriting, or multi-paragraph synthetic generation.
• Valen-Decision-1.5-27B vs Gemma-2-27B: Google's Gemma-2-27B offers exceptional reasoning for its parameter scale, but extracting reliable log-probabilities over arbitrary dynamic classes requires complex logit masking over vocabulary tokens. Valen-Decision addresses this natively: its dedicated candidate-mixing head evaluates relative choice probabilities across any arbitrary set of supplied strings without tokenization artifacts interfering with candidate scoring.

Choose Valen-Decision-1.5-27B if you are building programmatic workflows, classifier agents, moderation filters, or low-latency routing microservices where deterministic structured probabilities are preferred over conversational text generation.