Perplexity's Decisions API: Models That Output Probabilities, Not Text

Perplexity's Decisions API returns calibrated probabilities instead of text — joining TypeSafe's Jev in a brand-new category: decision models. Three vendors launched deciders on the same day. Here's the benchmark fine print and what it means for your routing layer.

Key takeaways

• Perplexity's Decisions API (launched Oct 1, 2026) is powered by pplx-decider-v1-27b — open weights (Apache 2.0), fine-tune of Qwen3.8-27B, 262K-token context. Hosted API: $0.04/M input tokens, output free.
• You send text + a typed schema (yes/no, choice, score); it returns calibrated probabilities per option. No parsing, no regex, no fragile JSON repair.
• Benchmarks (vendor panel): 85.71% overall vs Jev's 84.51% — a strong same-tier rival, not a coronation. No independent rerun exists yet.
• Same-day launches: Cloudflare's Clef/Clef-flash and AWS Strands Decider 2B. The category is filling in fast — build your routing layer against a typed schema, not one vendor.
• Bottom line: if your stack uses an LLM to "decide" anything, you have a brittle middle layer. Run the decider in shadow mode first, define abstention bands, and price the human-review tier before promising automation.

On October 1, 2026, Perplexity opened a Decisions API powered by pplx-decider-v1-27b — a 27-billion-parameter model that, instead of generating text, returns calibrated probabilities over a fixed set of answers: yes or no, this team or that team, a ranked score. No parsing, no regex, no fragile JSON repair. (AI Weekly)

This column covered the category five days ago with TypeSafe's Jev. Perplexity's launch makes it a category — and the fine print is where the useful lessons are.

What the Decisions API actually is

A decision model is not a smaller chatbot. Perplexity's Hugging Face model card defines the interface: you send text (or text plus images) and a typed schema describing the questions to answer. Each question has a type — `noul` for yes/no, `choice` for multiple choice, `score` for ordered ranking — plus instructions and criteria. The model returns one probability per allowed option. No free text to parse. (Hugging Face)

Perplexity's own example is a support-ticket router: "My Stripe integration keeps failing. Please help ASAP." goes in with criteria for `billing`, `technical_support`, and `sales` — and the model returns the owning team with a calibrated probability per option. A separate `noul` question measures urgency. That example names the target workload precisely: classification, routing, triage, and scoring at volume.

The model is a fine-tune of Qwen3.8-27B released as open weights under Apache 2.0, with a 262,144-token context window. The hosted API costs $0.04 per million input tokens with free output. Perplexity's docs show responses under two seconds for short prompts, stretching toward 23 seconds near the input ceiling — a quiet way of saying: keep your decision contexts small. (AI Weekly)

Three decider launches in one day

Perplexity didn't launch into an empty field. On the same day, Cloudflare shipped Clef and Clef-flash, and AWS's Strands Labs released Strands Decider 2B — three launches aimed at the same classification-and-routing use cases Jev has been serving. (AI Weekly)

The practical signal: the category is filling in fast. There's now an open-weight 27B option, a 2B option from AWS, and two models from Cloudflare. Build your routing layer against a typed schema, not against one vendor's model.

The benchmark fine print

Perplexity reports pplx-decider-v1-27b at 85.71% overall on an 11-benchmark panel of 7,210 samples — edging out Jev at 84.51% and its own Qwen base at 74.76%. The widest gap is on RAGTruth (using retrieved content faithfully): 88.80% vs Jev's 77.27%. It also leads on FinancialPhraseBank, TabFact, and Circa. (Hugging Face)

Read the fine print before quoting those numbers. They come from Perplexity's own panel, measured through the Perplexity API. The full table is published on the model card, but there's no independent rerun behind the headline figure. Treat the numbers as the vendor's, not a third party's.

Jev still leads on several of the eleven tests, including WinoGrande (90.70% vs 83.30%) and BBH (94.27% vs 82.80%). The honest reading: a strong decider in the same tier as Jev, not a coronation. Both beat the Qwen base by roughly 10 points — a meaningful gap over the old pattern of prompting a chat model to "reply with JSON." (AI Weekly)

What this means for your business

If your stack uses an LLM to "decide" anything — route a ticket, classify an email, score a lead — you likely have a brittle middle layer where a general model generates text and your code parses it. Every team that's shipped such a pipeline knows the failure list: the model explains instead of answering, the JSON breaks, a prompt tweak silently changes behavior elsewhere.

The Decisions API attacks that layer directly: typed inputs in, calibrated probabilities out, no parsing step to maintain. Three practical consequences:

Thresholds become a business decision, not an engineering hack. Calibrated probabilities let you write rules like "route automatically above 0.90, human review between 0.70 and 0.90, abstain below 0.70." That's how you put a decision model into production responsibly: define the abstention band, keep humans accountable for high-impact calls, validate calibration per segment — not one global threshold and hope.

And the threshold is a staffing model as much as a number: if 15–20% of your volume lands below 0.70, the human queue floods and your SLA dies. Price the abstention tier before you promise the automation. (Complete AI Training)

Classification gets much cheaper. At $0.04/M input tokens with free output, a million short tickets costs on the order of ten dollars in model spend at typical prompt sizes — before the human review tier, which will dominate the budget. Compare that with sending every ticket to a full-size chat model and parsing the reply. Reserve expensive frontier models for steps needing real reasoning or generation; run the classification layer on a dedicated small model.

The self-host math is heavy. Apache 2.0 open weights are a real path to vendor independence — but the model card requires Python 3.12+ and a CUDA GPU with roughly 49 GiB just for weights plus working memory. Running a 27B prefill pass for a simple classification is expensive overkill. (SignalHigh) For most teams the hosted API is the rational start — with the typed schema kept vendor-neutral, so you can swap in a smaller decider or your own fine-tune later. One caveat: schema portability is not calibration portability. Every swap means re-validating thresholds against your own labeled data.

Two adoption notes for operations leaders

Run it in shadow mode. Keep your existing parse-based layer live, run the decider alongside it, and diff the disagreements before you cut over.

Answer the data questions first. The hosted API means your tickets and emails — with their PII — leave your network. Settle data-retention and processing questions before the engineering ones. And treat the criteria text as production logic: "Integration errors" and "Charges and refunds" are now config that routes real work — version it and review changes like code.

Watch latency. Under two seconds for short prompts is fine for real-time routing; up to 23 seconds near the 262K-token ceiling is not. Decision contexts should be short by design — the relevant ticket, the relevant snippet, the defined options. Feeding whole conversation histories into a decider is using the wrong layer. (Medium)

The bottom line

The bigger story is the layer itself. Agents need exactly this underneath them: cheap, typed decision-making between the bigger models' reasoning steps — provided you log the inputs, schema versions, and probabilities so the decisions stay auditable.

Three launches in one day say vendors are converging on the same pattern. If you're automating operations, standardize the decision layer first: it's where probabilities meet policy, and where the ROI arithmetic is easiest to check — once you've measured your error costs and your abstention rate.

Find out where AI can pay for itself in your operations — start with our free AI audit.

FAQ

What is Perplexity's Decisions API?

An API (launched Oct 1, 2026) powered by pplx-decider-v1-27b, an open-weights decision model. Instead of generating text, it returns calibrated probabilities over a fixed set of answers (yes/no, choice, score) defined by a typed schema — built for classification, routing, triage, and scoring at volume.

How is it different from TypeSafe's Jev?

Same category, same tier. Perplexity's vendor panel scores it 85.71% vs Jev's 84.51% across 11 benchmarks — but Jev leads on several individual tests (WinoGrande, BBH), and there's no independent rerun of either vendor's numbers. Perplexity's edge: open weights (Apache 2.0) and a 262K-token context window.

How should we deploy a decision model responsibly?

Three steps: define abstention bands (auto-route above 0.90, human review 0.70–0.90, abstain below), run in shadow mode alongside your existing layer and diff disagreements before cutover, and price the human-review tier — if 15–20% of volume needs review, that's your real budget line.

Should we self-host the open weights?

Probably not at first: ~49 GiB of GPU memory just for weights, and a 27B prefill pass is overkill for simple classification. Start with the hosted API ($0.04/M input, output free), keep the schema vendor-neutral, and re-validate thresholds against your own labeled data on every swap.

Sources

• aiweekly.co — Perplexity Open-Sources 27B Decider, Edges Jev on 11-Test Panel
• huggingface.co — perplexity-ai/pplx-decider-v1-27b
• medium.com — Perplexity Decider v1 27B: A 250K-Context Decision Model
• completeaitraining.com — Perplexity Releases a Low-Cost Model for Probability-Based Decisions
• centritude.com — Perplexity Decider 27B: Open Weights Decision Model