In short
- pplx-decider is a 27B decision model from Perplexity, fine-tuned from Qwen3.8-27B, on Ollama as of 17 October 2026 — it returns calibrated probabilities instead of generating text.
- The 17GB download means a 24GB GPU or 32GB+ Mac is the realistic floor; the 4B pplx-decider-flash covers smaller machines.
- Run it with
ollama run pplx-decider --ask, or via Ollama's /v1/systemone endpoint with up to 64 questions per request. - Best fits: routing, triage, grading against a rubric, and gating agent steps — anywhere you currently parse a chat model's prose to make a binary call.
- Perplexity reports 85.7% across 11 public benchmarks, ahead of Jev (84.5%) and the Qwen3.8-27B base (74.8%) — vendor numbers, but the gap over the base is the interesting part.
There's a new model on Ollama that you can't chat with — and that's the point. pplx-decider is a 27B decision model from Perplexity, fine-tuned from Qwen3.8-27B, and it's on Ollama as of today (17 October 2026). You give it a state — text, JSON, or images — plus a set of typed questions, and it returns a calibrated probability for every answer in a single forward pass. No output tokens, no prose, no parsing. If you've ever written a regex to extract "yes" from a chat model's answer, this is the model that makes that go away.
What pplx-decider is
pplx-decider is a 27B model from Perplexity, fine-tuned from Qwen3.8-27B — the same base family as the Qwen chat models many of us already run. The fine-tune changes the job entirely: instead of generating text, the model scores options and returns probabilities.
The inputs are flexible. The "state" you want judged can be plain text, a JSON object or array, or images — the page's examples are screenshots, receipts and forms. On top of that state, you define typed questions, and the model returns a probability for every answer to every question at once.
It's Apache 2.0 licensed, and it has a smaller sibling: pplx-decider-flash, a 4B version with the same request format and image support, at about one seventh the size. We'll come back to that, because for many people reading this, flash may be the more practical of the two.
Sizes, memory and the hardware you'll need
There's one variant on Ollama: 27b, a 17GB download. The :latest and :27b tags point at the same file, with a 256K context window and text-plus-image inputs.
The rule of thumb we've used before holds here: a model needs roughly its file size in RAM or VRAM, plus room for context. So budget 17GB+ for the weights alone. That rules out most laptops and the 8–12GB gaming GPUs a lot of us started with. Realistic targets:
- A 24GB GPU — RTX 3090/4090 class, where the weights fit with room for a decent context
- A 32GB+ Mac — the usual unified-memory route for 27B-class models
- A homelab box with plenty of system RAM — CPU inference works, just slower
One caveat on that 256K window: it's generous, but a full 256K of context adds significant KV-cache memory on top of the 17GB of weights. If you're feeding it long documents or batches of images, don't cut your memory budget too fine.
If 17GB is too much for your hardware, pplx-decider-flash is the escape hatch. The page says only "about one seventh of the size" — its exact download size isn't stated, so check the flash page before assuming it fits your machine. But a 4B model at that ratio is clearly in a different, much smaller class than the 27B.
There's also a performance quirk worth understanding before you benchmark it. Because pplx-decider produces zero output tokens, latency is a single forward pass. The usual "tokens per second" framing doesn't apply — what matters is prompt-processing speed, how fast your machine chews through the input. That's a different bottleneck than the one most local-AI benchmarks measure.
How to run it locally
Ollama is the documented route. The model's page gives no instructions for llama.cpp, LM Studio, vLLM or anything else, so treat Ollama as the supported path for now. When a model only documents one engine, that decision is made for you — and it's consistent with the pattern we've noted before that engine choice often comes before model choice.
Pull it, then run it:
ollama pull pplx-decider
ollama run pplx-decider
The interesting part is the --ask flag. The simplest form:
ollama run pplx-decider --ask "Is a refund being requested?" < ticket.txt
For multiple-choice questions, define named options with --choice:
ollama run pplx-decider --ask "Which team should handle this?" \
--choice billing="Payments and refunds" \
--choice technical="Outages and errors" < ticket.txt
For ordered scoring, give it levels:
ollama run pplx-decider --ask "How urgent is this?" \
--level "Routine" \
--level "Soon" \
--level "Immediate" < ticket.txt
The state can also follow the model name directly instead of coming from stdin.
The API
For anything programmatic, decision models use Ollama's /v1/systemone endpoint. Put the text to judge in state, your questions in questions, and Ollama builds the prompt for you. Up to 64 named questions per request, with answers returned in the same order. Images go in as optional base64-encoded PNG, JPEG or WebP, shared by all questions.
There are three question types:
- choice — pick from named options, with a description per option (or
nullto let the name describe itself) - noul — a true/false probability
- score — 2 to 10 ordered levels, lowest first, returning a probability-weighted level
The page's cURL example shows all three at once:
curl http://localhost:11434/v1/systemone -d '{
"model": "pplx-decider",
"state": "Our app crashes on launch for every user since this morning'\''s update. Please fix it now.",
"questions": {
"urgent": {"type": "noul", "instructions": "Is this support request urgent?"},
"team": {
"type": "choice",
"instructions": "Which team should handle this request?",
"criteria": {
"billing": "Payments, invoices, and refunds",
"technical": "Outages, errors, and configuration",
"sales": "Plans and upgrades"
}
},
"severity": {
"type": "score",
"instructions": "How severe is the customer impact?",
"criteria": ["No impact", "Minor", "Major", "Critical"]
}
}
}'
And the documented response, verbatim — note the output_tokens: 0:
{
"model": "pplx-decider",
"answers": {
"urgent": {"type": "noul", "noul": 0.994},
"team": {
"type": "choice", "choice": "technical",
"probabilities": {"billing": 0.002, "technical": 0.996, "sales": 0.002},
"confidence": 0.994
},
"severity": {
"type": "score", "score": 2.975,
"legend": {"0": "No impact", "1": "Minor", "2": "Major", "3": "Critical"},
"probabilities": {"0": 0.001, "1": 0.002, "2": 0.017, "3": 0.98},
"confidence": 0.975
}
},
"usage": {"input_tokens": 338, "output_tokens": 0}
}
For Python, the page points at TypeSafe's official SDK, aimed at your local Ollama. The SDK requires an API key but Ollama ignores it, so any value works:
pip install typesafe-sdk
export TYPESAFE_BASE_URL=http://localhost:11434
export TYPESAFE_API_KEY=ollama
export TYPESAFE_DEFAULT_MODEL=pplx-decider
If you're new to Ollama itself, our Ollama engine guide covers the install and setup.
What it's good for — and what it can't do
The page frames four jobs, and they're all variations on the same idea — turning fuzzy input into a structured decision:
- Route a request — define destinations and when each applies; get the chosen destination plus each destination's probability
- Check a condition — a yes/no question in; true or false with probabilities out
- Grade an answer — a rubric of levels in; the probability-weighted level out
- Gate an agent step — a condition plus the agent's proposed action in; go or no-go out
That last one is the angle local AI builders should notice. If you're running agents at home, the scariest failure mode is an agent step that should have been stopped. A dedicated model that takes "should this action proceed?" and returns a calibrated go/no-go is a genuinely useful primitive — and it runs on your own hardware, with nothing leaving the house.
The limits are worth stating plainly:
- It doesn't generate text. No summaries, no drafting, no conversation. If you need prose, you need a chat model alongside it.
confidenceis easy to misread. It runs 0–1 and shows how strongly the probabilities favour one answer. It is not the chance the answer is right. A model can be confidently wrong; this field won't tell you.- The evaluation numbers are Perplexity's own. The page reports 85.7% across 11 public benchmarks, ahead of Jev (84.5%) — the other decision model the page benchmarks against, and whose API pplx-decider is compatible with — and its Qwen3.8-27B base (74.8%). Vendor numbers, so treat them accordingly. The gap over its own base model is the interesting part, though, since it isolates what the fine-tune added.
How it fits alongside what you already run
pplx-decider is a complement to your chat model, not a replacement. Here's how the options stack up for a decision-making job:
| Option | Size | Memory | Strength | Weakness |
|---|---|---|---|---|
| pplx-decider | 27B | 17GB download | Vision + decision, 85.7% in Perplexity's eval | Needs a serious machine |
| pplx-decider-flash | 4B | ~1/7 the size | Same format and image support, most of the accuracy | Less headroom on hard calls |
| Chat model (e.g. Qwen3.8-27B) | 27B | Similar | Generates text too | 74.8% on the same eval, and you have to parse its prose |
The pattern should feel familiar. Guard models like llama-guard3 and the granite guardians already do a narrow version of this — safety yes/no on a prompt. pplx-decider generalises the idea to any question you care to define: routing, urgency, rubric grading, agent gating.
Because it's fine-tuned from Qwen3.8-27B, the memory profile matches other 27B-class models you may already run — if a 27B fits on your machine today, this will too. And per decision, it's cheap: one forward pass with no output tokens, versus prompting a chat model and waiting for it to generate an answer you then have to parse.
If you'd rather compare against the base model directly, Qwen3.8-27B is callable through the Inpherio API:
Worth trying this weekend
Pull it if you build agents, triage flows, or anything that currently parses a chat model's text to make a yes/no call — that's exactly the gap it fills, and the typed question format is a real improvement over prompt-fiddling.
Skip it if you wanted a new chat model. It genuinely doesn't generate, and no amount of prompting will change that.
Try flash first if your hardware is modest — same API, same image support, a fraction of the footprint.
And if you have a 24GB GPU or a 32GB+ Mac sitting idle, decision models are a plausible hosting candidate: a single forward pass per request with no long generations to serve. Worth a look if earning from idle kit appeals:
Questions people ask
Can pplx-decider write text or chat?
No. It returns calibrated probabilities for the answers to questions you define, in a single forward pass. It produces zero output tokens — if you need text generated, use a chat model alongside it.
How much RAM or VRAM do I need for pplx-decider?
The Ollama download is 17GB, so budget at least that for the weights in RAM or VRAM, plus extra for context (the window is 256K). A 24GB GPU or a 32GB+ Mac is the realistic floor; the 4B pplx-decider-flash is the option for smaller machines.
How do I run pplx-decider in Ollama?
ollama pull pplx-decider, then ollama run pplx-decider --ask "your question" < your-input.txt. Programmatically, use Ollama's /v1/systemone endpoint with a state field and up to 64 named questions.
What's the difference between pplx-decider and pplx-decider-flash?
pplx-decider-flash is the 4B version: same request format and image support, most of the 27B model's accuracy, at about one seventh of the size.
Does pplx-decider work with images?
Yes. It accepts base64-encoded PNG, JPEG or WebP images alongside text or JSON — screenshots, receipts and forms are the examples given — and all questions in a request share the same images.
Models in this post — live on Inpherio
Have a GPU, a Mac or a spare PC?
Let it earn while you sleep.
Run open models for people who need them. You set the price and keep everything but the 15% fee.
Become a hostBuilding with AI?
Every open model, one API.
OpenAI-compatible. Priced by the people who run the hardware.
Start free See the marketplaceRead “pplx-decider on Ollama: Perplexity's 27B model that never writes a word” at https://inpherio.co.uk/blog/pplx-decider-on-ollama-perplexity-s-27b-model-that-never-writes-a-word