On September 15, Typesafe released a model called Jev. It doesn't chat, doesn't write code—it only answers one question: Is this ticket urgent? Which team should it go to? A month later, at least 20 similar models had emerged. Cloudflare, OpenAI, Perplexity, Microsoft, AWS, and Tencent Cloud, one after another, peeled "decision-making" away from large models and turned it into a standalone product.

Lately, Perplexity quietly dropped a 27B model: pplx-decider-v1.1-27b

When I checked the model card, interesting thing is, the base turned out to be Qwen3.8-27B again

I've already written several pieces lately about modified versions of Qwen3.8-27B — quantized ones, distilled ones, ones running Agents, ones doing Computer Use. Now even Perplexity has jumped in. Qwen3.8-27B is really becoming the "common chassis" of the open-source world

But this Perplexity model is a bit different — it doesn't chat, it doesn't write code. It does exactly one thing: make judgments

Coincidentally, OpenAI released something that does the same job at DevDay not long ago, called the Decisions API

One is open-weight and self-deployable, the other is a hosted pay-as-you-go API — perfect for a side-by-side comparison

▸ First, the conclusion: what is this thing

Short version: it's a "decision model"

Feed in a piece of text or an image, along with a question and candidate options you've defined in advance, and it spits out a judgment result, a probability, and a confidence score directly — no lengthy essays in between

Think of it as an AI reviewer with lightning-fast hands

For example, feed in a support ticket like:

My Stripe integration keeps failing. Please help ASAP.

Then ask it: should this ticket go to billing, technical support, or sales?

The decision model won't start off with small talk like "That's a great question" — it directly gives you a choice plus a set of calibrated probabilities. Say technical_support takes the vast majority of the probability mass — the program can immediately route it without further ado

▸ How this decision-model track emerged

To understand why Perplexity made this, we need to go back about a month

In mid-September, TypeSafe AI released the closed-source Jev, introducing the concept of the "System One Model"

The idea: today's large models are all "System Two" — thinking slowly, spitting out tokens one by one, good for chat and writing, but awkward when plugged into software automation. If you just want it to judge whether an order should be refunded, it insists on writing you three paragraphs of analysis first, and you still have to pray it doesn't mangle the JSON

Jev's approach is to directly output a typed result in a single forward pass, paired with calibrated probabilities, so the program can treat it like an if-else right away

I previously wrote a piece specifically on "The Four Schools of Thought on LLM Decision-Making," which covered how the community went about recreating Jev using Qwen, and also wrote about Google using diffusion models for fast-thinking decisions

Over the past month, so many open-source projects recreating Jev have appeared that someone on Hugging Face made a dedicated leaderboard called the Jev Decision Index, which currently includes 111 open-source reproductions

Perplexity's binary-judgment type is called noul, a name identical to the one Jev uses, and its inference code's Python package is literally named autojev

In short, Perplexity has also joined the "open-source Jev reproduction" army — and came out on top right from the start

▸ What exactly makes v1.1 strong

pplx-decider is actually on its second version — v1 was released earlier, and v1.1 is an upgrade on the same base

The official numbers: Decision Index total score rose from 56.4 to 61.56, overtaking Jev by more than 3.5 points

The score gains mainly come from two changes:

• Removing the causal mask: all attention layers were changed from causal to noncausal, meaning each token can see both before and after context simultaneously — more suitable for judgment-style tasks than only looking forward. The model card specifically emphasizes that running default causal inference won't reproduce the official results
• More training data: the bulk comes from the open-source tasksource dataset collection, and the model card specifically credits this project

The architecture is also interesting — it replaces the original Qwen full-vocabulary lm_head with a separate decision head. The readout.safetensors file stores a BF16 matrix of shape [255, 5120], suggesting it can score up to 255 candidates in a single pass

The model also stores a calibration temperature. If you use the official DecisionModel.predict, it automatically multiplies this in for you. If you compute logits yourself, remember to multiply it only once, and normalize only across the valid candidates for the current question

My take: calibration matters more than the score itself

Anyone who's built business routing logic knows this: when the model says it's 90% confident, you only dare to set a threshold and auto-approve based on that if the real accuracy is actually close to 90%. Otherwise that probability is just decoration

v1.1 still loses to Jev on the Knowledge category — for judgment questions requiring a lot of world knowledge, it's still a bit lacking

▸ Leaderboard: first place on Decision Index 0.3

Perplexity's announcement says v1.1 scored the highest on the new version of the Hugging Face Decision Index

On the leaderboard, Perplexity Decider v1.1 scored 62.8, Fastino GLiDE no-thinking got 60.2, Jev itself got 60.1, and Torchcast Decision 27B got 59.9

Note that this 62.8 doesn't match the 61.56 in the model card, because the leaderboard switched evaluation suite versions — Jev's score also changed from 57.9 to 60.1. Just look at the relative ranking

I think this leaderboard is designed quite thoughtfully:

• Total score = 20% public benchmarks + 50% private tests of similar capabilities + 30% private tasks in new domains
• The private portion is never disclosed, so you can't get a high score just by gaming the public questions
• The 37 public benchmarks are divided into five categories — Knowledge, Language, Retrieval, Tools, and Arts — all corrected with a random baseline, where 0 points means random guessing, and unanswered items count as wrong

In the category radar chart, Perplexity ranks first in both Language (62.3) and Retrieval (64.7), second in Tools, second in Knowledge, and third in Arts

Qwen3.8-27B dominates the front ranks of this leaderboard

Scroll down the list: Torchcast Decision 27B, Kev 27B, JEV-27B, Eikos 27B-FP8 Qwen3.8-27B LoRA, simple-jev Qwen3.8-27B, reflex Qwen3.8-27B... a long string of 27B models, quite a few with "Qwen3.8-27B" written directly in their names

Perplexity's own v1 model page shows that there are already 478 fine-tuned models based on Qwen3.8-27B

When one base model gets picked up by this many teams to do the same thing, and still manages to climb all the way past the closed-source original, that says its semantic understanding foundation is solid enough — and the 27B size happens to sit right at the "fits on a single card" sweet spot

▸ What hardware do you need for local deployment

• Python 3.12+
• One CUDA GPU — the weights alone need roughly 49 GiB, plus you need to leave room for inference working memory
• Total repo size: 52.2 GB

In terms of hardware, a single 80GB A100/H100, or a 96GB RTX PRO 6000, is the safer bet — the leaderboard itself was run on an RTX PRO 6000

24GB or 32GB consumer-grade cards simply can't fit the BF16 weights directly. The community has already made a quantized version of v1, and a quantized v1.1 is probably coming soon too

Mac users, hold off on getting excited — the official inference code is hardcoded for CUDA

One more small gotcha: the v1.1 model card states it requires "authenticated Hugging Face access." Log into your HF account before downloading, and if the page prompts you to request access, submit the request first

Official usage is as follows — after downloading the repo and installing the pinned dependencies in requirements.txt:

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 judgments, just switch type to noul — the v1 model card gives this example:

{"type": "noul", "instructions": "Does this message express urgency?"}

One easy pitfall: this checkpoint doesn't have a full-vocabulary lm_head, so you can't just drop it into vLLM and serve it as a regular Qwen model

The model card is explicit about this: if your inference framework requires a standard structure like Qwen3_5ForConditionalGeneration, you'll need to export a separate version, mapping row i of the decision head back to its corresponding token row in the vocabulary, while also preserving noncausal attention — otherwise you won't reproduce the scores

At this stage, it's simplest to just stick with the official inference code. The model card also notes that model.py was copied byte-for-byte from the training evaluation setup

▸ How to use it inside an Agent

The ideal place for a decision model to live is at the very front of an Agent pipeline, acting as a "triage desk"

The diagram below shows what I think is a typical usage pattern

When a user request comes in, the decision model first judges: simple questions get handed to a cheap small model, complex reasoning goes to the big model, if information lookup is needed it calls search, and high-risk cases get escalated directly to a human

It's only responsible for returning the choice result — the actual model calls, tool calls, and business actions are all executed by your program

How do you set the threshold? OpenAI's documentation has practical advice: tune it using your own labeled samples from your business, based on the cost of misjudgment — the cost of letting a high-risk request slip through versus mistakenly blocking a normal request is simply not the same

Besides routing, I think these scenarios would work smoothly too:

• Classifying support tickets, scoring urgency levels
• Content moderation, safety guardrails during Agent execution
• In RAG, judging whether a retrieved passage is actually relevant
• Checking whether a product photo shows damage — OpenAI's documentation already has a ready-made example for this

▸ Summary

Perplexity Decider can be seen as an open-weight, self-hostable decision model; OpenAI Decisions is a hosted API offering similar capability — the approaches are highly aligned, though the models, training data, and interface protocols are each independent

My recommendation:

• Teams with sensitive data, high call volumes, and 80GB+ GPUs on hand should seriously try Perplexity's offering — it's ranked first on the Decision Index and priced lower, and self-hosting brings down marginal cost further
• Teams that don't want to touch ops and need compliance backing should go straight to the OpenAI Decisions API — ZDR and HIPAA support are already baked in
• Individual hobbyists with only consumer-grade GPUs should either wait for a quantized version, or try the API first
• For knowledge-intensive judgments, such as moderation requiring a lot of specialized common sense, both should be tested against your own data first — v1.1's Knowledge score is still below Jev's

One more word on Qwen3.8-27B: the top ranks of the open-source Jev-reproduction leaderboard are almost entirely filled with various modified versions of it, and now even Perplexity has chosen it as the base model. This base model's vitality really speaks for itself.