Perplexity Decider V1.2 Decision Models Launch on AI Gateway

AI applications are moving beyond simply "generating content" toward "making judgments." Perplexity's newly released Decider V1.2 series models are aimed squarely at the latter need. According to the official AI Gateway announcement, the Decider V1.2 27B and Decider Flash V1.2 4B multimodal decision models are now officially available, allowing developers to handle content classification, request routing, and text scoring tasks with a single API key.

How Decision Models Differ from Generative Models

Traditional large models output free-form text, requiring you to parse the results yourself, determine correctness, and then write logic branches. The Decider series takes a different approach: it doesn't handle "writing," only "judging," and delivers answers in the form of probabilities.

Developers ask questions using typed questions, and the model returns probability values. Boolean questions return the likelihood of "yes," Choice questions select one from your predefined categories, and Score questions rate content according to an ordered scoring rubric. Once the application receives these results, it can decide which queue to route a ticket to, flag a damaged item, or escalate uncertain judgments to human review.

This approach extracts "classification decisions" from application code and hands them to the model. For teams handling large volumes of unstructured input (text, structured records, images), it eliminates the cost of maintaining a rules engine.

Typed Questions are the core interaction method of Decider. Unlike traditional free-text prompts, typed questions require developers to explicitly declare the expected answer structure at call time: Boolean questions return a probability value between 0 and 1, representing the confidence that the judgment is "yes"; Choice questions require a set of predefined categories, and the model outputs a probability distribution across them; Score questions require an ordered scoring rubric (e.g., 1-5), and the model returns the probability for each score. This constraint mechanism fundamentally eliminates output format ambiguity—the application layer can simply read the probability values without regex parsing or secondary validation. At the same time, outputting probabilities rather than hard boolean values preserves uncertainty information, allowing developers to set confidence thresholds and automatically route low-confidence judgments to human review.

Two Versions, Two Scenarios

Decider V1.2 comes in two specifications, targeting different use cases.

Decider V1.2 27B (model identifier perplexity/pplx-decider-v1.2) is the larger version, suited for tasks requiring nuanced judgment and complex scoring rubrics. A larger parameter count means more stable performance on ambiguous boundaries and multi-condition judgments.

Decider Flash V1.2 4B (model identifier perplexity/pplx-decider-flash-v1.2) is the smaller version, designed for high-concurrency labeling, filtering, and routing tasks. When judgment criteria are sufficiently clear, using the Flash version can significantly reduce inference costs.

This tiered strategy of "large models for hard judgments, small models for batch processing" is more practical in real-world engineering than a single model. Many teams' actual needs don't require deep reasoning for every request—a large volume of simple classifications can be fully handled by smaller models.

One Request, Multiple Questions

One design detail of Decider is worth noting: multiple questions can share the same input. That is, you can ask "Is damage reported," "What is the severity level," and "Which department should this be routed to" all at once for a single input, and the model returns all answers in one request.

The official example demonstrates this with a delivery report: given the input "The tablet arrived with a shattered display and will not turn on," a Boolean question asks "Does this report a damaged delivery?" At the code level, it's called through the AI SDK's experimental_decide interface, which returns a probability value rather than a boolean.

import { experimental_decide as decide } from 'ai';

const result = await decide({
  model: 'perplexity/pplx-decider-v1.2',
  state: 'The tablet arrived with a shattered display and will not turn on.',
  questions: {
    damaged: {
      type: 'boolean',
      instructions: 'Does this report a damaged delivery?',
    },
  },
});

console.log(result.answers.damaged);

For image input, you need to embed a base64-encoded image_url object into the JSON's state field and submit it via the AI SDK or TypeSafe-compatible API. This means the model can not only judge text but also make classification decisions about image content, such as identifying whether a product image shows damage.

The experimental_decide interface is the experimental entry point for decision models in the Vercel AI SDK. Unlike the standard generateText or generateObject, its parameter design revolves around "one input, multiple questions": the state field carries the raw input to be judged (which can be plain text or JSON with an embedded base64 image_url object), while the questions field is a key-value collection where each key corresponds to a question name and the value declares the question type and judgment instructions. The returned answers object is indexed by question name, with each answer containing probability information. Since this interface is still marked experimental, the API signature may change in future versions—when using it in production, it's advisable to lock the SDK version and watch for migration announcements.

Three Integration Methods Covering Different Tech Stacks

Decider V1.2 offers three access paths: AI SDK, Decisions API, and TypeSafe-compatible API.

The AI SDK is suitable for frontend or full-stack projects already using the Vercel AI toolchain, with a calling convention consistent with existing model calls. The Decisions API is a lower-level HTTP interface, suited for scenarios requiring fine-grained control over request format. The TypeSafe-compatible API targets teams with type-safety requirements.

The coexistence of all three methods lowers the barrier to entry—you don't need to refactor your existing tech stack just to use decision models.

BYOK (Bring Your Own Key) means developers use an API key they've applied for directly with the model provider, rather than making calls through a platform intermediary. In the AI Gateway context, BYOK means inference requests still pass through the Gateway's routing and logging layers, but billing happens directly between the developer and the provider. Decider V1.2 explicitly supports this mode with no platform surcharge—particularly important for enterprise users who already have contracts or discounts with specific providers. They can enjoy the observability and routing capabilities of a unified gateway while retaining their existing commercial terms. For teams that haven't yet established a direct relationship with a provider, the Gateway's default billing channel is available, charging at the provider's public pricing.

Cost and Observability

One clear selling point of AI Gateway for this product is billing transparency. Inference is charged at provider pricing with no markup and no platform fee. This same rule applies even when users connect their own provider credentials via BYOK (Bring Your Own Key).

Decision requests are recorded in request logs and included in spending budget tracking. For teams needing to control AI costs, monitoring decision calls alongside generation calls in a single dashboard is far more convenient than spreading them across multiple platforms.

Developers can try Decider V1.2 27B and Decider Flash V1.2 4B directly in the model playground, or browse the decision model catalog to see the full range of options.

What Problem Do These Models Solve

Placed in a broader context, Decider addresses a real pain point: for many AI applications, the bottleneck isn't generation quality—it's consistency of judgment. Using prompts to have a generative model "also make a judgment" often produces unstable results with unpredictable formatting. Decider uses typed questions to enforce output structure and probability values to preserve uncertainty, allowing the application layer to set thresholds based on confidence.

Whether this "decision-as-a-service" approach will become mainstream remains to be seen, but for high-frequency judgment scenarios like ticket routing, content moderation, and quality scoring, it offers a more engineered alternative to "prompt engineering + regex parsing."

One-line Summary

Perplexity releases the Decider V1.2 series of multimodal decision models that return typed judgments as probabilities, designed for classification, routing, and scoring scenarios.

Paragraph Summary

Perplexity has launched the Decider V1.2 series of decision models through AI Gateway, including 27B and Flash 4B versions. Unlike traditional generative models that output free-form text, Decider accepts typed questions (Boolean, Choice, Score) and returns probability values, letting the application layer make routing, classification, or scoring decisions based on confidence. The 27B version is suited for complex judgments, while Flash 4B targets high-concurrency batch processing. Multiple questions can share a single input, and both text and image modalities are supported. Developers can integrate via AI SDK, Decisions API, or TypeSafe-compatible API, with billing at provider pricing and no markup, and decision requests included in unified logging and budget monitoring.