Perplexity's pplx-decider-v1.1-27b: Open-Weight Decision Model Beats Jev, Runs Locally

Perplexity has quietly released pplx-decider-v1.1-27b , a 27B-parameter decision model built on the Qwen3.8-27B base. Unlike chat or coding models, this model performs only one function: given a text or image input and a predefined set of questions with candidate options, it outputs a judgment — choice, probability, confidence, or score — without any verbose explanation. It is positioned as a drop-in replacement for hand-written if-else logic in software automation.

Core Capability Comparison

The article presents a detailed feature comparison between Perplexity's model and OpenAI's Decisions API (currently in public preview, model gpt-6-luna, endpoint POST /v1/decisions):

Yes/No judgment : Perplexity uses noul (outputs probability of "yes"); OpenAI uses predicate (outputs probability condition holds)

Single choice : Both use choice Graded scoring : Perplexity uses score; OpenAI uses score (weighted average of level probabilities)

Input modalities : Both support text and images

Output : Perplexity returns option, probability, score; OpenAI returns option, probability, confidence, score

Delivery : Perplexity offers open weights, self-hostable, also has API; OpenAI is hosted API only

Price (per 1M input tokens) : Perplexity $0.02; OpenAI $0.10 (no output, cache, or storage fees)

Origin of the Decision Model Trend

The decision-model paradigm traces back to TypeSafe AI's closed-source Jev (mid-September), which introduced the "System One Model" concept: a single forward pass that emits typed, calibrated probabilities directly usable as if-else branches, avoiding the token-by-token generation of "System Two" LLMs. The open-source community rapidly produced replicas — Hugging Face's Jev Decision Index now lists 111 open reproductions. Perplexity's model adopts Jev's terminology ( noul for binary, Python package autojev) and joins this replication wave, achieving the top score on the Decision Index leaderboard.

Benchmark: Decision Index 0.3

The Decision Index combines 20% public benchmarks, 50% private same-capability tests, and 30% private novel tasks (never published). Scores are baseline-corrected so 0 = random guessing. Perplexity's v1.1 scores 62.8 on the latest leaderboard (v1.0: 56.4), surpassing Jev (60.1), Fastino GLiDE no-thinking (60.2), and Torchcast Decision 27B (59.9). The model card reports a slightly different total (61.56) due to evaluation-suite version differences; relative ranking is consistent.

Category Scores (Decision Index 0.3)

Knowledge : Jev 51.4, v1.0 40.9, v1.1 48.18

Language Understanding : Jev 62.0, v1.0 63.5, v1.1 69.45

Retrieval Classification : Jev 55.4, v1.0 54.9, v1.1 61.26

Tools : Jev 75.1, v1.0 79.3, v1.1 78.88

Arts (Aesthetic Taste) : Jev 37.7, v1.0 39.4, v1.1 44.66

Total : Jev 57.9, v1.0 56.4, v1.1 61.56

Architecture Changes Driving v1.1 Gains

Non-causal attention : The model replaces causal masking with full bidirectional attention (every token sees past and future), which the model card states is essential — default causal inference cannot reproduce official scores.

More training data : Heavy use of the open-source tasksource dataset collection, explicitly acknowledged in the model card.

Dedicated decision head : The original Qwen lm_head (full vocabulary) is swapped for a separate readout.safetensors matrix of shape [255, 5120] (BF16), allowing scoring up to 255 candidates per forward pass.

Calibration temperature : A learned temperature is stored in the model; the official DecisionModel.predict applies it automatically. Manual logit users must multiply once and renormalize only over valid candidates for the current question.

The author emphasizes that calibration is more valuable than raw scores : reliable probabilities enable threshold-based auto-routing (e.g., only auto-approve when model confidence matches empirical accuracy).

Local Deployment Requirements

Python 3.12+

One CUDA GPU; weights alone ~ 49 GiB (BF16), repository total 52.2 GB .

Recommended: single 80GB A100/H100 or 96GB RTX PRO 6000 (leaderboard runs on RTX PRO 6000).

Consumer 24/32GB cards cannot hold BF16 weights; quantized versions of v1 exist, v1.1 quantization expected soon.

Mac unsupported — inference code hard-codes CUDA.

Requires authenticated Hugging Face access (login, possibly request access).

Usage Example (Official Inference Code)

import sys
from pathlib import Path
from huggingface_hub import snapshot_download

checkpoint = Path(snapshot_download(
    "perplexity-ai/pplx-decider-v1.1-27b"
))
sys.path.insert(0, str(checkpoint / "source" / "src"))

from autojev.model import DecisionModel, answer

model = DecisionModel(checkpoint, device="cuda")
question = {
    "type": "choice",
    "instructions": "Which team should handle this request?",
    "criteria": {
        "billing": "Charges and refunds",
        "support": "Technical integration errors",
        "sales": "Questions about buying a product",
    },
}
row = {
    "state": "My integration keeps failing. Please help.",
    "question": question
}
probabilities = model.predict([row])[0]
print(answer(question, probabilities))

For yes/no, change type to noul and provide an instructions string (e.g., "Does this message express urgency?").

Common Pitfall

The model lacks a full-vocabulary lm_head, so it cannot be dropped into vLLM or other frameworks expecting Qwen3_5ForConditionalGeneration . To use such frameworks, one must export a converted checkpoint mapping the decision-head rows back to vocabulary tokens while preserving non-causal attention. The author recommends sticking with the official model.py (byte-copied from training/eval) for now.

OpenAI Decisions API Details

Single model: gpt-6-luna; dedicated endpoint /v1/decisions; claimed ~10x faster than Responses API.

Request: model, input (shared evidence: text or image messages), questions (list of independent questions, each with its own type).

Response per question: choice, per-option probabilities, confidence, and for score type a weighted average of level probabilities (e.g., levels "cosmetic/workaround/blocking" with probs 0.1/0.7/0.2 → score 1.1).

Images only as base64 data URLs (no URLs or file_id), max 128 per request.

Multiple independent questions per request allowed; dependent questions require separate calls.

Each question may return refusal without affecting others.

OpenAI recommends adding an other catch-all option to route uncovered inputs to human queues.

Pricing: $0.10 / 1M input tokens; zero data retention (ZDR) and HIPAA supported; data residency in US and EU.

Boundary: for custom JSON generation or explanations, use Responses API Structured Outputs; for tool calls, use function calling.

Key API Differences

Binary type: noul (Perplexity) vs predicate (OpenAI).

Options container: criteria dict (Perplexity) vs choices array (OpenAI).

Scoring: score with levels (OpenAI) vs score (Perplexity).

Image encoding, response structure, and authentication differ — not a simple endpoint swap.

Agent Integration: Triage at the Front Door

The ideal placement is the first step in an agent pipeline: incoming requests are classified — simple queries → cheap small model, complex reasoning → large model, retrieval needed → search tool, high-risk → human. The decision model only returns the routing choice; actual model/tool invocation and business actions are executed by the surrounding program. Thresholds should be tuned on labeled business data, weighing cost of false positives vs. false negatives.

Other suitable scenarios:

Support ticket categorization and urgency scoring.

Content moderation and safety guardrails during agent execution.

RAG relevance judgment for retrieved passages.

Visual inspection (e.g., product damage detection — example in OpenAI docs).

Recommendations by Team Profile

Data-sensitive, high-volume, 80GB+ GPU teams : Perplexity model — Decision Index #1, lower per-token cost, self-hosted marginal cost near zero.

No-ops, compliance-ready teams : OpenAI Decisions API — ZDR, HIPAA, managed scaling.

Consumer-GPU hobbyists : Wait for quantized versions or use APIs first.

Knowledge-intensive judgments (e.g., specialized domain review): Both models trail Jev on Knowledge (v1.1: 48.18 vs Jev 51.4); test on proprietary data before committing.

The leaderboard's top ranks are dominated by Qwen3.8-27B derivatives (Torchcast Decision 27B, Kev 27B, JEV-27B, Eikos 27B-FP8 Qwen3.8-27B LoRA, simple-jev Qwen3.8-27B, reflex Qwen3.8-27B, etc.), and Perplexity's own model page shows 478 fine-tunes of Qwen3.8-27B. This confirms Qwen3.8-27B as the de facto "public chassis" for open decision models — its semantic depth and 27B single-GPU sweet spot make it uniquely fertile for this task.