Introducing Parallel Decisions API: the first decision engine with world knowledge built in. Learn more.[Learn more.]

November 6, 2026

# What is a Decisions API? How decision models give software answers instead of text

A Decisions API puts a model inside application logic. You define a bounded question, and the model returns a probability your code can branch on, with no text to parse. More than 15 vendors offer one, from OpenAI and TypeSafe AI to Cloudflare and Upstage. Most judge only the input you send; Parallel’s and Perplexity’s can also pull evidence from the live web.

Parallel avatar
Author: By Parallel
Tags:Industry Terms

**Quick answer.** A Decisions API is an endpoint that takes your input and a set of questions with fixed answer options, then returns a probability for each option. The input can be a support ticket, a product photo, a JSON record, or a web page. Most decision models answer only from the input you send; a few, including Parallel’s, retrieve web evidence first and cite it. Because the result is always one of the options you listed, your code can compare it with a threshold and act on it without parsing text.

Vendors call the model behind the endpoint a _decision model_. TypeSafe AI released the first one and calls the category _System One models_, after Daniel Kahneman’s split between fast, intuitive judgment and slow, deliberate reasoning. Sorting a ticket into one of five queues is a System One task. Writing the reply belongs to the slow kind.

## The three question types

Almost every vendor uses TypeSafe’s System One request shape, which asks noul, choice, and score questions. OpenAI supports the same three types and calls the yes-or-no type predicate.

Question typeOpenAI nameSystem One name (Jev, Perplexity, and most others)What comes backExample
Yes or nopredicatenoulThe probability, from 0 to 1, that the condition is trueDoes this ticket ask for a refund?
Pick onechoicechoiceThe most likely option, a probability for every option, and a confidence valueWhich team should handle it?
Rate on a rubricscorescoreA probability for each ordered level and their weighted averageHow severe is the issue, from cosmetic to fully blocked?

The score type returns a weighted average, so its result can fall between levels. In OpenAI’s documentation example[OpenAI’s documentation example], probabilities of 0.1, 0.7, and 0.2 across three severity levels, numbered 0, 1, and 2, produce a score of 1.1. Use choice when the options have no order, such as departments, and score when they do, such as severity.

## What a request and response look like

In OpenAI’s routing example, the `input` field holds the evidence, and each question carries a `name` that the response echoes back.

### Request to POST https://api.openai.com/v1/decisions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
  "model": "gpt-6-luna",
  "input": "I was charged twice for my order.",
  "questions": [{
    "type": "choice",
    "name": "department",
    "instructions": "Which department should handle this complaint?",
    "choices": [
      {"value": "billing", "description": "Payments, invoices, and refunds."},
      {"value": "technical", "description": "Problems using the product."},
      {"value": "shipping", "description": "Delivery and tracking."},
      {"value": "other", "description": "Requests outside these categories."}
    ]
  }]
}``` 
{
  "model": "gpt-6-luna",
  "input": "I was charged twice for my order.",
  "questions": [{
    "type": "choice",
    "name": "department",
    "instructions": "Which department should handle this complaint?",
    "choices": [
      {"value": "billing", "description": "Payments, invoices, and refunds."},
      {"value": "technical", "description": "Problems using the product."},
      {"value": "shipping", "description": "Delivery and tracking."},
      {"value": "other", "description": "Requests outside these categories."}
    ]
  }]
}
```
### Response (OpenAI’s illustrative example)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "answers": [{
    "type": "choice",
    "name": "department",
    "choice": "billing",
    "probabilities": [
      {"value": "billing", "probability": 0.95},
      {"value": "technical", "probability": 0.02},
      {"value": "shipping", "probability": 0.01},
      {"value": "other", "probability": 0.02}
    ],
    "confidence": 0.93
  }]
}``` 
{
  "answers": [{
    "type": "choice",
    "name": "department",
    "choice": "billing",
    "probabilities": [
      {"value": "billing", "probability": 0.95},
      {"value": "technical", "probability": 0.02},
      {"value": "shipping", "probability": 0.01},
      {"value": "other", "probability": 0.02}
    ],
    "confidence": 0.93
  }]
}
```

One request can carry many independent questions about the same input: up to 400 on OpenAI and up to 100 on Parallel. You can check a product photo for damage and classify its category in one call. Questions that depend on an earlier answer need a second request.

## Why decision APIs appeared in 2026

Applications and agents make many small calls between the big ones: classify this input, route this request, decide whether to continue, retry, or ask for clarification. Teams have made those calls with general-purpose LLMs, which means generating tokens, parsing a string, validating it, and retrying when the format breaks. Each call costs little, but at millions a day the latency and cost add up, and an agent loop waits on each one.

A decision model skips generation. TypeSafe says Jev produces every probability in one pass over the input instead of generating one token at a time. Its docs put most queries at about 100 ms. Because the model generates nothing, OpenAI, TypeSafe, Perplexity, and Liquid AI charge only for input tokens, and output is free.

The first launches came within six weeks of each other:

In OpenAI’s launch post, Sierra says it picks the next action in live customer conversations in under 280 ms at p95, meaning 95% of calls finish faster than that. Sierra puts this at about three times faster and 90% cheaper per call than its previous approach. Datadog scores the risk of agent-generated shell commands before it runs them and reports p95 latency 40 times faster than frontier models at comparable accuracy. Both figures are vendor-published, so test on your own workload before you rely on them.

## Decisions API vs. an LLM call vs. a trained classifier

A decision model sits between two tools most teams use. It’s more flexible than a classifier you train yourself and more constrained than an LLM.

LLM with structured outputsDecisions APIFine-tuned classifier
OutputGenerated JSON that follows your schema, which can include free textOne of your predefined answers, with probabilitiesScores over a fixed label set
Changing the taskEdit the prompt or schemaEdit the question and options in the requestCollect labels and retrain
ConfidenceNot a primary outputA probability for every answer, by designScores, with calibration that varies by model
BillingInput and output tokensInput tokens onlyYour own training and serving costs
Good forExtracting fields, writing explanations, tool calls with argumentsRouting, filtering, triage, gating, rerankingHigh-volume decisions where you already have labels

OpenAI draws the same line in its docs. It recommends Decisions when you need a probability, a choice, or a score. For a generated object, such as extracted fields or a written explanation, it recommends Structured Outputs. For a tool call with arguments, it points to function calling.

TypeSafe markets Jev as unable to hallucinate. The claim holds for the format, because the answer is always one of your options. A decision model can still put 0.9 on the wrong answer, and TypeSafe publishes a list of Jev’s known weaknesses. For Jev 1.13, the list includes arithmetic, counting, and reading dates as text rather than as ordered quantities.

## Which providers offer a Decisions API

As of November 2, 2026, more than 15 first-party vendors offer a hosted decision model. Prices are per million input tokens, except Parallel’s, which is per request because each request includes web retrieval.

ProviderEndpointModelsInput price per 1M tokensNotes
OpenAIPOST /v1/decisionsgpt-6-luna$0.10 uncached, $0.01 cachedUp to 400 questions per request. Text, image, and JSON input
PerplexityPOST /v1/decisionspplx-decider-v1.2 (27B), pplx-decider-flash-v1.2 (4B)$0.02 and $0.01256K-token context and 10 requests per second by default. Optional web_grounding mode adds one search per question at $1 per 1,000 searches
TypeSafe AIPOST /v1/systemoneJev 1.14 (latest), Jev 1.13$0.04264K-token request context and up to 255 options per choice
Liquid AIPOST /decisions/v1/systemoned1.1, d1-ultra$0.02 and $0.042Text and image input. d1 and d1-ultra are also on OpenRouter and Vercel AI Gateway
MicrosoftPOST /providers/microsoft/v1/systemone on your Foundry resourceMicrosoft-Decision-1$0.042 in US and EU Data ZonesText and JSON input. You deploy the model to your own Foundry resource first
BasetenPOST /v1/systemoneelephant-1, mammoth-1Not stated by Baseten16,384-token context. Text, structured data, and image input
CloudflareWorkers AI model @cf/cloudflare/clefClef, Clef-flash, Clef-omni$0.24, $0.038, and $0.15Runs on Workers AI. Prices are from Cloudflare’s own pricing page
UpstagePOST /v1/systemoneSolar Decide (beta), Solar Decide Flash$0.10Solar Decide is in beta
InceptionPOST /v1/decisionsMercury Decide$0.02 promotional, normally $0.04Not stated
ParallelPOST /v1/decisionsfast mode (parallel/decisions-fast on OpenRouter)Not priced per token: $1 per 1,000 requests, including web retrievalRetrieves live web evidence and returns citations. Up to 100 questions per request over one shared evidence set. Free web_decisions tool in Parallel MCP

Perplexity lists its prices in its Decisions API docs[its Decisions API docs] and notes a billing detail there. The Flash model answers each question separately and bills the input again for every question. Once you ask three or more questions about the same input, the 27B model is usually cheaper. Perplexity cut its price once, from $0.04 at launch, so check current rates before you budget.

Other first-party vendors include Nace.AI, Fastino, Mouse, Respan, ScaleDown, and Bevel, which runs inference in Germany. vLLM Semantic Router and Scira offer free decision models, and Kev-4B and Convai Innovations’ Laya ship as open weights. OpenRouter serves about 30 decision models, and Vercel AI Gateway, DeepInfra, Fireworks, and SiliconFlow host models from other vendors. You can also self-host a `/v1/systemone` endpoint with vLLM or SGLang. Hugging Face lists more than 200 open-weight decision models.

There are two main request shapes. OpenAI’s API takes input and a questions array and calls its yes-or-no type predicate. Jev’s System One API takes state and a map of named questions and calls the same type noul. Perplexity and Parallel use Jev’s naming at their own /v1/decisions paths. Liquid AI, Microsoft, Baseten, and Upstage use Jev’s request schema at paths ending in /v1/systemone, and OpenRouter serves Jev and d1 with the same schema. Switching vendors means rewriting the request mapping and rechecking your thresholds, because a probability of 0.7 from one model doesn’t mean the same thing as 0.7 from another. Perplexity tells you in its docs to revalidate thresholds whenever its own model version changes.

For side-by-side comparisons, see Jev alternatives[Jev alternatives], OpenAI Decisions API alternatives[OpenAI Decisions API alternatives], OpenAI vs. Jev vs. Parallel[OpenAI vs. Jev vs. Parallel], Perplexity vs. Parallel[Perplexity vs. Parallel], Cloudflare Clef vs. Parallel[Cloudflare Clef vs. Parallel], and Laya vs. Jev vs. Parallel[Laya vs. Jev vs. Parallel]. Decision model pricing[Decision model pricing] works through what each costs at volume, and What is a System One model?[What is a System One model?] explains where the term comes from.

## What Parallel found when it tested decision models

Parallel trains its own classifiers for search, but each one needs a labeled dataset and rounds of training, so many smaller decisions go without one. Decision models could cover that long tail without training. Parallel’s research team tested them on four real decision tasks from its production pipelines and scored each model against human labels. The team published the results in Are all System One models created equal?[Are all System One models created equal?] on October 14, 2026. The tasks were search result reranking, deciding whether a re-crawled page changed enough to re-index, filtering low-quality pages, and routing each query to the right index.

  • - **Jev was the most consistent.** With starting prompts, it had the best average rank across the four tasks (1.75, where a rank of 1 is best), ahead of pplx-decider-v1 at 2.00 and Liquid d1 at 3.00. Jev also had the lowest and most consistent latency of the models tested.
  • - **The models differed most on hard tasks.** On page change classification, scored by AUPRC (area under the precision-recall curve), results ranged from 93.3 for pplx-decider-v1 and 87.9 for Jev down to 23.5 for the smallest open-weight model. On easier tasks, most models landed in a narrow band.
  • - **Prompt tuning narrowed the gaps.** Five rounds of automated prompt rewriting on 800 labeled examples lifted OpenAI’s Decisions API on page change from 79.0 to 88.8, past an untuned Jev.
  • - **A trained model still won on reranking.** Parallel’s fine-tuned reranker scored 75.2 on top-K overlap, against 71.5 for Jev, the best decision model, at about a quarter of Jev’s per-token cost.

These runs used pplx-decider-v1 and OpenAI’s Decisions API during its public beta. Both vendors have shipped updates since: Perplexity is on v1.2, and OpenAI’s API is generally available. To choose a model, label a few hundred examples of your own task and test candidates on them. In Parallel’s runs, a model’s rank on one task didn’t predict its rank on another. In an earlier hands-on test of Jev[hands-on test of Jev], Parallel found the same pattern. Jev matched one of Parallel’s internal rerankers but trailed the specialized models on topic classification with a large label set and on classifying query freshness.

## Most decision models judge evidence but don’t fetch it

Most decision models answer only from the input you send. Ask whether a company has raised a Series B, and the model can weigh only the text in front of it. If the funding announcement isn’t in the input, the probability reflects a guess. Two APIs in the table above can look things up. Perplexity’s Decisions API has an optional `web_grounding` mode that runs one search per question, adds the top results to the input, and returns them as `search_results`, at $1 per 1,000 searches on top of token pricing. Parallel’s Decisions API always retrieves web evidence and returns citations. In most real workflows, retrieval comes before the decision. Every task in Parallel’s evaluation was a decision about web content: which result is relevant, whether a page changed, and whether a page is worth keeping.

There are two ways to get that evidence in front of the model. You can retrieve it yourself and pass it in, or you can use a Decisions API that retrieves it for you.

A search API returns candidate pages with excerpts. A decision model scores each one against your criterion in a single request, and your code keeps the pages that clear the threshold. This example uses Parallel Search[Parallel Search] in Fast mode and OpenAI’s Decisions API to check which search results come from an official EU source.

### Filter search results with a decision model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import os

from openai import OpenAI
from parallel import Parallel

parallel = Parallel(api_key=os.environ["PARALLEL_API_KEY"])
openai = OpenAI()

# 1. Retrieve: Parallel Search returns ranked pages with excerpts.
search = parallel.search(
    objective="When do the EU AI Act obligations for general-purpose AI models start to apply?",
    search_queries=["EU AI Act GPAI obligations August 2025 explained"],
    mode="fast",
)
results = search.results[:8]

# 2. Decide: one predicate question per result, all in one request.
questions = [
    {
        "type": "predicate",
        "name": f"result_{i}",
        "instructions": (
            "Was this page published by an official EU body, such as the European "
            "Commission, Parliament, Council, or EUR-Lex, rather than a third party?\n\n"
            f"URL: {r.url}\nTitle: {r.title}\nExcerpt: {' '.join(r.excerpts)[:1500]}"
        ),
    }
    for i, r in enumerate(results)
]

decision = openai.decisions.create(
    model="gpt-6-luna",
    input="Each question describes one web search result. Judge who published it.",
    questions=questions,
)

# 3. Act: keep official sources above a threshold you set from labeled examples.
probability = {a.name: a.probability for a in decision.answers if a.type == "predicate"}
for i, r in enumerate(results):
    p = probability.get(f"result_{i}", 0.0)
    print(f"{p:.2f}  {'KEEP' if p >= 0.7 else 'drop'}  {r.url}")``` 
import os
 
from openai import OpenAI
from parallel import Parallel
 
parallel = Parallel(api_key=os.environ["PARALLEL_API_KEY"])
openai = OpenAI()
 
# 1. Retrieve: Parallel Search returns ranked pages with excerpts.
search = parallel.search(
    objective="When do the EU AI Act obligations for general-purpose AI models start to apply?",
    search_queries=["EU AI Act GPAI obligations August 2025 explained"],
    mode="fast",
)
results = search.results[:8]
 
# 2. Decide: one predicate question per result, all in one request.
questions = [
    {
        "type": "predicate",
        "name": f"result_{i}",
        "instructions": (
            "Was this page published by an official EU body, such as the European "
            "Commission, Parliament, Council, or EUR-Lex, rather than a third party?\n\n"
            f"URL: {r.url}\nTitle: {r.title}\nExcerpt: {' '.join(r.excerpts)[:1500]}"
        ),
    }
    for i, r in enumerate(results)
]
 
decision = openai.decisions.create(
    model="gpt-6-luna",
    input="Each question describes one web search result. Judge who published it.",
    questions=questions,
)
 
# 3. Act: keep official sources above a threshold you set from labeled examples.
probability = {a.name: a.probability for a in decision.answers if a.type == "predicate"}
for i, r in enumerate(results):
    p = probability.get(f"result_{i}", 0.0)
    print(f"{p:.2f}  {'KEEP' if p >= 0.7 else 'drop'}  {r.url}")
```

Swap the predicate for a relevance check, a freshness check, or a choice question that routes each page to a different extraction path, and the rest of the code stays the same. Search costs $1 per 1,000 requests in Fast mode. New accounts get up to $80 in free credits, plus $5 a month with a card on file.

The second way is a web-grounded Decisions API. Parallel’s Decisions API[Parallel’s Decisions API] takes the entity in state, searches the live web, and answers every question against one shared set of evidence. It returns the same noul, choice, and score answer types, plus a citations array with the URLs and excerpts it used. A request can carry up to 100 questions and costs $1 per 1,000 requests. It’s also on OpenRouter[OpenRouter] as `parallel/decisions-fast`, and it’s free to try from an agent as the `web_decisions` tool in Parallel MCP[Parallel MCP], with no account or key.

### Ask web-grounded questions with Parallel’s Decisions API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
curl https://api.parallel.ai/v1/decisions \
  -H "Content-Type: application/json" \
  -H "x-api-key: $PARALLEL_API_KEY" \
  -d '{
    "state": {"company": "Clay", "website": "https://www.clay.com"},
    "questions": {
      "has_cli": {
        "type": "noul",
        "instructions": "Does Clay offer an official command-line interface (CLI)?"
      },
      "employee_band": {
        "type": "choice",
        "instructions": "How many employees does Clay have? Select unknown when evidence is insufficient.",
        "criteria": {
          "up_to_100": "100 or fewer employees.",
          "101_500": "101 to 500 employees.",
          "501_plus": "More than 500 employees.",
          "unknown": "The evidence does not establish the company size."
        }
      }
    }
  }'``` 
curl https://api.parallel.ai/v1/decisions \
  -H "Content-Type: application/json" \
  -H "x-api-key: $PARALLEL_API_KEY" \
  -d '{
    "state": {"company": "Clay", "website": "https://www.clay.com"},
    "questions": {
      "has_cli": {
        "type": "noul",
        "instructions": "Does Clay offer an official command-line interface (CLI)?"
      },
      "employee_band": {
        "type": "choice",
        "instructions": "How many employees does Clay have? Select unknown when evidence is insufficient.",
        "criteria": {
          "up_to_100": "100 or fewer employees.",
          "101_500": "101 to 500 employees.",
          "501_plus": "More than 500 employees.",
          "unknown": "The evidence does not establish the company size."
        }
      }
    }
  }'
```

The trade-off is control. With your own retrieval, you choose the sources and can reuse the evidence in later steps. A grounded API replaces that pipeline with one call, but its citations cover the whole call rather than each answer.

Grounding matters most when the answer isn’t in the input. On PWS-Decisions[PWS-Decisions], a 300-question benchmark whose answers depend on current web facts, Parallel’s Decisions API scored 76.2%. Perplexity’s Decisions API scored 50.9%, OpenAI’s 41.7%, and Jev 33.4%, all run without web context, which means Perplexity ran without its grounding mode. The set was curated to be hard, and random guessing scores 42.4%. On a 231-question JevBench set, where the answer is in the input, Parallel, OpenAI, and Jev scored within two points of each other: 89.6%, 90.0%, and 88.3%. Parallel built the benchmark and published these results, and the code[code] and dataset are public, so you can run it on any model.

The JevBench explainer[JevBench explainer] covers the different boards that share that name.

## What teams build with web-grounded decisions

Parallel built three workflows on its Decisions API before launch. The figures below come from those launch demos, not from customer deployments.

  • - **Lead routing.** Inbound leads land in the wrong segment when the deciding facts, such as funding, headcount, and what the company does, are out of date. Parallel ran 500 inbound leads through the Decisions API in under nine seconds for about $0.50. Of the leads it routed without a person, 97% landed in the right segment.
  • - **KYB rechecks.** Banks re-review business customers every one to five years, and the file can go stale in between when executives or funding change. Parallel rechecked 426 public companies against the live web in under ten seconds for $0.85, and 98% of the changes it flagged held up.
  • - **CRM field refresh.** Columns such as employee band, whether a company has a public API, or whether it sells an enterprise plan go stale between enrichment runs. In one demo request, Parallel asked four questions about Vercel and got all four answers from one retrieval of 10 sources in 681 ms, for $0.001. The employee-band answer came back at 0.55 confidence, so the workflow sent it to review instead of writing it to the CRM.

All three follow the same pattern: ask closed questions about each record, act on the confident answers, and send the rest to a person. When a field needs an open answer, such as a new CEO’s name or a summary of recent news, use an enrichment or research API instead.

Step-by-step guides cover AI lead qualification[AI lead qualification], AI lead scoring[AI lead scoring], AI lead routing[AI lead routing], entity matching[entity matching], fact-checking[fact-checking], vendor validation[vendor validation], content moderation[content moderation], and zero-shot classification[zero-shot classification]. To call Parallel through OpenRouter, see Parallel Decisions on OpenRouter[Parallel Decisions on OpenRouter].

## When to use a Decisions API

A Decisions API fits when the answer is bounded, the call happens often, and latency or cost per call matters:

  • - Routing tickets, requests, or queries to a team, a tool, or a model
  • - Filtering content by quality, relevance, policy, or source type
  • - Deciding an agent’s next step: continue, retry, ask for clarification, or escalate
  • - Scoring severity, urgency, or risk before a person or a program acts
  • - Reranking candidates by asking the same yes-or-no question about each one

It’s the wrong tool when you need the model to produce something: extracted fields, a summary, an explanation, or code. Use an LLM for those. If one decision runs at high volume and you can collect labels, a small fine-tuned classifier may still beat the decision models on accuracy and cost, as it did for Parallel’s reranker. You can combine all three: an LLM for writing, decision models for the long tail of judgments, and trained models for the few decisions that justify training one.

## Related Articles8