Perplexity releases Decider v1.3 decision models under Apache license

Perplexity has released Decider v1.3 and Decider Flash v1.3, the successors to its earlier decision models (v1, v1.1, v1.2 and Flash v1.2). Flash v1.3 is a smaller model distilled from Decider v1.3. Both are available on Hugging Face under the Apache license, through OpenRouter and through the Perplexity Decisions API. The company says Decider is inspired by Jev, TypeSafe AI's System One Model. A blog post explains how the models are trained and evaluated and says how Perplexity uses them internally.
Perplexity defines a decision model as a general-purpose classifier. You give it an input and a set of questions, each with its possible answers, and for each question it returns a probability distribution over the answers. There are 3 question types: Yes / No, Multiple choice (custom multi-class labels) and Score (ordered levels). Listed uses include judging outputs for faithfulness, quality and safety; routing requests to smaller or larger models by difficulty; moderation and security, such as detecting harmful content, phishing and prompt injection in tool outputs; filtering and tagging large collections of content; and scoring search results for retrieval and reranking. The post argues that many of these tasks were previously handled by generative LLMs even though they do not need free-form text. Decision models, it says, sit between LLMs and task-specific classifiers: they return probabilities for several questions about the same input in a single forward pass, avoiding token-by-token generation and sharing computation across questions, and unlike task-specific classifiers they can take on new tasks through natural language prompts.
The models are built by adapting generative LLM backbones. A request has a shared context (the state) and a number of questions. Each question block lists its answer options, each tagged with a label token such as A, B or C, followed by a special <|marker|> token where the prediction is read out. A learned linear decision head maps the hidden state at that position to scores for the options, which become probabilities. The head is initialised from the base model's output layer, keeping only the rows for the option tokens. For training, Perplexity takes hundreds of public datasets (sentiment, natural language inference, intent detection, entity matching, moderation, fact checking, ratings and more) and converts each example into this format, with the target either the single correct option or a probability distribution over options.
v1.3 changes the attention design. The pretrained backbones use causal attention, but ablation studies showed that making the backbone's full-attention layers bidirectional improves performance, so v1.3 adopts it. That raised the question of how the state and questions should interact, and the team considered three patterns. In "everything sees everything" (v1.2) the state and all questions attend to each other, so computation over the state is shared but an answer can change depending on what else is asked. In "isolated questions" (v1.3) the state attends to all the questions while each question attends only to the state and its own tokens; questions can still influence one another indirectly through the state, but results are more stable. In the "fully cacheable" pattern the state attends only to itself, so it can be reused across requests with prompt caching. That one is not the default because letting the state see the questions matters a lot for several tasks, though a small fine-tuning can switch a model to it. Perplexity chose isolated questions for performance and stability.
Training runs in three stages for both sizes. The larger model, based on Qwen3.8-27B (as written in the post), is trained first with cross-entropy and then distilled into the smaller Qwen3.5-4B model. Stage one is a full fine-tune on large corpora, accepting only data that helps across the board and excluding any benchmark training splits. Stage two uses LoRA on data targeted at specific domains and tasks, to improve performance while retaining the backbone's general knowledge. The LoRA is merged back with a weight, to control drift and favour held-out metrics over in-domain gains. Stage three is a vision-specific step, also a LoRA merged with a weight. Some vision capabilities cost text performance, and because usage is mostly on text, Perplexity prioritises text metrics. For both text stages it averages the weights of three runs with different random seeds, which it says improves performance and robustness.
For the smaller model, the large one acts as teacher. Its predicted output distribution replaces gold labels, and the student minimises the KL divergence to it. Perplexity says this outperforms cross-entropy on the same data: cross-entropy does better on benchmarks that have dedicated training data but generalises less well to held-out data. The explanation is a hypothesis: distillation better transfers the teacher's confidence over non-gold alternatives, while cross-entropy encourages overfitting to benchmark-specific training distributions. To limit train-test contamination, the team removes any training samples that could overlap with any evaluation it uses, noting that some public training datasets contain large parts of evaluation datasets. It also says it runs extensive bias audits and removal.
The new locate feature extracts text from the state instead of choosing among options. A locate question gives a short label such as "location" or an instruction such as "Extract the city name where the job is located." The model returns the exact matching text with start and end character positions, or an empty list if nothing matches. Because the state is shared, one request can mix locate, classification and scoring questions, for example asking whether a job needs senior-level experience and extracting the required skills. Locate needed an extra training stage: a new <|locate|> token (initialised from the learned <|marker|> embedding, one per requested field), a span head and a LoRA adapter, with the original backbone and decision head frozen. The span head scores where spans start and end and which start-end pairs belong together, and predicts field-specific thresholds. It is trained with an adapted InfoNCE loss that pushes gold spans above the threshold and the threshold above all other spans; fields with no answer get only the second term, which teaches the model to return an empty list. Training covers named entity recognition, PII detection and extractive question answering, with field descriptions varied from short labels to detailed instructions. Merging the locate adapters into the backbone still causes some regression on decision requests, and Perplexity is testing more replay data and auxiliary objectives. For now the adapters stay unmerged and are activated only for locate requests.
The evaluation section begins by naming external benchmarks: the Hugging Face Decision Index, Vals AI's ClaimBench and the Artificial Analysis Decision Index. Perplexity says the models show strong performance across them, and adds that even leaderboards with privately held tasks can be gamed through repeated submission and iterative tuning on leaderboard feedback.
Key facts
- Perplexity released Decider v1.3 and the smaller distilled Decider Flash v1.3, available on Hugging Face under the Apache license, via OpenRouter and the Perplexity Decisions API.
- A decision model is a general-purpose classifier with 3 question types (Yes / No, Multiple choice, Score) that returns probabilities for several questions in a single forward pass instead of generating tokens.
- v1.3 moves to bidirectional attention with an 'isolated questions' pattern, better-curated data and a three-stage recipe; the larger model is based on Qwen3.8-27B and Flash on Qwen3.5-4B, as written in the post.
- Flash is trained by distillation (KL divergence to the teacher), which Perplexity says beats cross-entropy on the same data; the reason given is a hypothesis.
- New locate feature returns exact text spans with character positions for NER, PII and extractive QA, but its adapters stay unmerged because merging still regresses decision requests.
Why it matters
Perplexity argues that many classification jobs, such as judging outputs, routing, moderation and reranking, have been given to generative LLMs that do not need to write text. A decision model answers several questions about one input in a single forward pass and returns probabilities, so those jobs can run without token-by-token generation. The release is open under the Apache license and comes with unusually detailed training notes: attention patterns, the three-stage recipe, the distillation finding and the locate training.
Who it affects
Teams that use LLMs as judges, routers, content filters, taggers or rerankers, and developers who need entity or PII extraction, are the audience named in the post. Anyone who builds on Hugging Face or OpenRouter, or on the Perplexity Decisions API, can reach the models there. People who study classifier training will find the ablation and distillation notes useful.
How to use it
Both models are on Hugging Face under the Apache license, on OpenRouter, and in the Perplexity Decisions API. A request is an input (the state) plus one or more questions, each with its answer options. The question types are Yes / No, Multiple choice and Score, and the output is a probability distribution per question. A locate question describes what to find, either as a short label or as an instruction, and returns matching text with start and end character positions, or an empty list. One request can combine locate, classification and scoring questions. The post gives no pricing or latency figures in the text available here.
How solid is it
This is a first-party post from Perplexity, so the training claims are the company's own. Some are backed by ablations it ran, such as the gain from bidirectional attention. The distillation explanation is explicitly a hypothesis. The post names its external benchmarks (Hugging Face Decision Index, Vals AI's ClaimBench, Artificial Analysis Decision Index) and says performance is strong, but the visible text contains no benchmark scores or numeric evaluation results. It also does not say how Decider compares numerically with LLMs or other models. Perplexity itself notes that leaderboards with private tasks can still be gamed through repeated submission and iterative tuning.
Risks and caveats
Locate is not fully integrated: merging its adapters into the backbone still causes some regression on decision requests, so they are kept separate and activated only for locate requests. Vision gains can cost text performance, and Perplexity prioritises text because that is where most usage is. Cross-entropy training does better on benchmarks with dedicated training data but generalises less well, which is why contamination removal matters; the post says it removes training samples that could overlap with any evaluation it uses. The base model names are given as written in the post. The text available here does not describe Perplexity's internal use cases in detail.
“Decision models sit between LLMs and task-specific classifiers.”
— Perplexity, Decider blog post