Decisions API · MANY MODELS. ONE DECISION WORKFLOW.

Decisions API for the next step in your app.

Explore decision models in one place with Decisions API. Compare Jev, Laya, Kev, Solar, and Span in the playground, then use the API to classify, score, and route text. New accounts receive 100 credits.

ILLUSTRATIVE EXAMPLE · NO CREDITS USED

“I was charged twice this morning. Please refund the duplicate payment today.”

One input → structured decisions

Choice

Billing

Route to the billing queue

Yes / no

96%

Probability of an urgent request

Score

2.8 / 3

Urgency on a 0–3 scale

Static illustration of the output format. Values are not a live model response or a measure of accuracy.

01 / WORKBENCH

Decisions API playground

Preview a task in Decisions API, choose a model, and edit the input. Sign in to run it with your credits. New accounts receive 100 credits once.

What do you want to decide?

Choose a task to load its input and rules. Loading examples uses no credits.

Kev 4B · model & pricing ↗Span · behavior evaluation ↗

Text or JSON evaluated independently by every question.

Questions 1/8

Which team should handle this ticket? Use other when no option fits.Choice

Options

Maximum credit budget: 1 credits

We reserve this budget before the model runs, then charge actual usage and return the difference. Failed calls are refunded.

New account? Receive 100 credits once. Short requests typically use 1 credit; longer inputs can use more.

100 welcome credits · one balance for web & API

Draft saved in this browser · Your draft will be restored after sign-in.

ILLUSTRATIVE EXAMPLE · NO CREDITS USED

“I was charged twice this morning. Please refund the duplicate payment today.”

One input → structured decisions

Choice

Billing

Route to the billing queue

Yes / no

96%

Probability of an urgent request

Score

2.8 / 3

Urgency on a 0–3 scale

Static illustration of the output format. Values are not a live model response or a measure of accuracy.

Your draft will be restored after sign-in.

THE DECISION MODEL LANDSCAPE

A decision is a useful interface for software.

Many SaaS and agent workflows need to choose a category, a tool, or a next step. Decisions APIs turn context and a bounded question into a result your code can use. In Decisions API, explore this workflow with the supported models before connecting it to your application.

  1. 01

    Supply context

    A message, policy, record, or application state.

  2. 02

    Define the question

    Name the decision and the allowed answers or rubric.

  3. 03

    Inspect the result

    Read the typed answer and available probability signals.

  4. 04

    Choose the next step

    Route, score, or request review using your own rules.

ECOSYSTEM UPDATE · SEPTEMBER 30, 2026

OpenAI Decisions API enters the conversation

September 29 DevDay coverage describes OpenAI Decisions API in limited preview: bounded decisions from text or image context, using a specialized GPT-6 Luna version. The reported ~150 ms demo is an early signal, not a production SLA.

Read the launch report · secondary source

How does it compare with Jev? Start with three open questions: the official schema, pricing, and probability calibration. Jev already documents Noul, Choice, and Score; our comparison distinguishes official evidence from preview reporting.

Compare OpenAI Decisions API vs Jev

Decisions API brings decision models together in one playground and API. OpenAI Decisions API is not currently available on this independent platform. Explore available models in the playground or read the comparison below.

02 / COMPARE BEFORE YOU SHIP

Test your decisions in Decisions API

A useful model should work across your real inputs, not just one example. Use Decisions API to compare two configurations with representative cases and expected answers. Adjust the question or model, inspect the results, and keep the version that fits your task.

Open the full workbench
  1. 01

    Define the decision and its boundaries

    Start with the action your application needs to take. In Decisions API, name the question clearly, choose its type, and describe the criteria in language another person could apply. Add examples that sit outside the normal case. If a ticket mentions both billing and login, specify which issue should control its route.

  2. 02

    Read more than the winning answer

    Inspect the answer, available probabilities, and request details together. When a Decisions API result looks surprising, first check whether the input contains the evidence your criteria require. A high probability is not measured accuracy. It needs to be checked against labeled examples from your own domain before you use it as an automation threshold.

  3. 03

    Compare two configurations on the same cases

    Capture configuration A, revise the question, then capture configuration B. The evaluation workspace in Decisions API runs both against the same supplied states, with up to 25 cases in a comparison. Add expected answers where available, inspect individual failures, and export the report. A change that fixes one ticket may still make another class of tickets worse.

  4. 04

    Keep a useful baseline and revisit it

    Save the configuration you want to keep, revisit private web run history, and rerun difficult cases after an edit. Before connecting Decisions API to a live workflow, decide how your application handles missing answers, uncertain results, and request errors. Repeat the evaluation when your policy, input format, or model choice changes.

Evaluation separates model behavior from application policy. Decisions API produces the decision signal; your product decides what happens next. Set a review path for cases that should not proceed automatically, and judge the workflow by the outcomes that matter to your users.

03 / START FROM A REAL TASK

What you can build with Decisions API

Start with a decision your product already needs to make. The Decisions API recipes connect editable questions to practical application workflows. Replace the sample state, define your criteria, and compare results before deciding what to automate.

Route customer requests

A customer reports a duplicate charge. Use Decisions API to distinguish a billing issue from a technical fault or an account access problem, then pass the selected label to your support system. Include enough context to separate a refund request from a failed checkout.

Try ambiguous tickets as well as clear ones. Keep an other category for requests outside the available teams, and decide when uncertain results should reach a person.

Open and customize recipe

Choose an agent's next step

Some requests need a record lookup; others need a language model or human review. Decisions API can classify the incoming task against routes you define, giving your application a structured signal before it starts the next operation.

Describe each route's capabilities and limits. Your application remains responsible for executing tools, checking permissions, handling failures, and deciding whether the proposed route is appropriate.

Open and customize recipe

Check claims against evidence

Place a claim beside the source passage and ask whether that passage supports it. With Decisions API, a citation check becomes a specific decision whose input and result can be reviewed together, rather than a vague request to judge an entire document.

Test missing evidence, partial support, and direct contradictions. The supplied passage sets the scope: this check does not independently browse the web or establish that the source itself is correct.

Open and customize recipe

04 / UNDERSTAND THE OUTPUT

How Decisions API turns context into an answer

Decisions API brings decision models and their APIs into one workspace for developers. Describe a situation, define a question, and inspect a structured answer. A support ticket becomes a route; a policy check becomes a yes-or-no judgment; a quality review becomes a score with explicit criteria.

Choose from Jev, Laya, Kev, Solar, and Span in Decisions API. Each model has its own strengths, input limits, and credit rate. This independent platform gives you a shared playground and API so you can test a decision workflow before choosing the model for your application.

CHOICE

Classify with Decisions API

Use a choice question when your application needs one label from a defined set. In Decisions API, each option has a name and a description, so you can explain what belongs in billing, technical support, or account access. Inspect the probability distribution as well as the selected label, especially when two options overlap.

Write distinct criteria and include an explicit fallback for inputs that do not fit. The result can inform a queue assignment, a search filter, or the next step in an agent.

SCORE

Score with Decisions API

A score question is useful when a label alone loses information. Define ordered levels for relevance, urgency, or completeness, and explain what each level means. Decisions API returns a score along that scale, making it possible to compare inputs using a shared rubric instead of an open-ended written opinion.

Keep the order consistent and test examples near each boundary. A score only becomes useful when the people and systems consuming it agree on what the scale represents.

NOUL / YES–NO

Check evidence with Decisions API

Use noul for a focused yes-or-no question, such as whether a source supports a claim or whether a request needs review. The yes probability from Decisions API lets your application choose a threshold. It expresses the model's judgment about the supplied evidence; it is not a guarantee that the statement is true.

Ask one question at a time and describe how missing evidence should be treated. Keep consequential actions behind your own business rules and review process.

Better inputs begin with the decision you need to make. Give Decisions API the relevant message, policy, and known facts, while leaving out unrelated conversation. Text, JSON objects, and arrays can organize that context. The workbench helps you inspect the request before running it, so you can see exactly what the model will receive.

Designed for developers

One Decisions API integration. Multiple models.

Move from the Decisions API playground to your backend with the same state and question structure. Choose a supported model, create an API key, and use the generated cURL, JavaScript, or Python example. The shared endpoint keeps your integration familiar as you explore different decision models.

Send requests to Decisions API with a server-side Bearer token. Successful responses contain structured answers and usage information. Check the response status, keep the request identifier for troubleshooting, and handle errors explicitly. Your application decides whether the result should route a ticket, request a review, or trigger the next operation.

Decisions API uses one balance for playground, API, and evaluation calls at the same per-model rates. A budget is reserved before each call; successful calls settle actual input usage, and failed calls are refunded. Review the request and model rate before integrating.

POST /v1/systemone

typesafe/jev-1.13 · upstage/solar-decide · jaredpalmer/kev-4b · laya-english · laya-multilingual · laya-auto

// Server-side JavaScript (Node 20+ or Bun). Set JEV_API_KEY.
const response = await fetch("https://decisions-api.org/v1/systemone", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.JEV_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
  "model": "typesafe/jev-1.13",
  "state": "I was charged twice for order A-4471. Please refund the duplicate payment.",
  "questions": {
    "route": {
      "type": "choice",
      "instructions": "Which team should handle this ticket? Use other when no option fits.",
      "criteria": {
        "billing": "Payments, charges and refunds",
        "technical": "Bugs and product errors",
        "account": "Login and account access",
        "other": "None of these teams"
      }
    }
  }
}),
});
const body = await response.json();
if (!response.ok || body.code !== 0) throw new Error(body.message);
console.log(body.data.result.answers);
console.log(body.data.creditsUsed);

05 / UNDERSTAND THE SERVICE

Start building with Decisions API

100 welcome credits

Create an account to receive 100 credits once. Load a recipe, review the budget and run your questions in Decisions API. Short requests typically cost 1 credit; longer inputs can cost more. Saved configurations and private history help you build on earlier work.

One wallet for every live call

Buy credits when you need more. Every pack works across the Decisions API playground, API and comparison tool at $1 per 10,000 credits. Credits do not expire. Successful requests are billed on input usage, with a minimum of 1 credit per request.

Usage you can inspect

The Decisions API account area separates web activity from API usage and gives you a credit history to review. A request identifier helps connect an API call to its usage record. Private web history stores the state and answers so you can revisit a decision; API usage records track request metadata without storing the full request and answer bodies.

Pricing

One credit balance for web, API and evaluation. New accounts receive 100 credits.

$1 = 10,000 credits on every pack. Credits do not expire. Pay once, with no subscription. Successful calls start at 1 credit; actual input usage determines the charge. Site input rates per million tokens: Jev / Kev $0.06, Solar Decide $0.072, Span-01 $0.03, and Laya $0.06. Output tokens are not charged.

Starter

$10

For your first workflows and integration.

  • 100,000 credits, no expiry
  • Choice, score, and noul questions
  • Probability and confidence results
  • Online playground
  • API key management
  • Request usage & credit history
Recommended

Pro

$100

For regular use and repeated evaluations.

  • 1,000,000 credits, no expiry
  • Choice, score, and noul questions
  • Probability and confidence results
  • Online playground
  • API key management
  • Request usage & credit history

Volume

$1,000

For higher usage at the same unit rate.

  • 10,000,000 credits, no expiry
  • Choice, score, and noul questions
  • Probability and confidence results
  • Online playground
  • API key management
  • Request usage & credit history

Estimate your credit use

Estimate with your average input tokens, including state and questions. Each request is rounded up separately.

Credits per request

1

Estimated total credits

10,000

Credit value at selected pack rate

$1.00

max(1, ceil(input_tokens × 600 / 1,000,000))

All live calls use credits, including web and evaluation. Minimum 1 credit per successful request; output tokens are not charged. Span-01: 300 credits/million input tokens. Span-01 Lite: 1 credit per successful request. Jev, Kev and Laya: 600 credits/million; Solar Decide: 720 credits/million. $1 buys 10,000 credits. Failed calls are refunded. Estimates exclude taxes.

Jev models benchmark

Compare the models behind your decisions

Use independent benchmarks as background when choosing a model in Decisions API. The linked JevBench comparison identifies its sources, versions, and snapshot date. Published scores help you ask better questions; they do not promise an accuracy rate for your own tickets, policies, or documents.

For a deployment decision, pair those results with your own labeled cases in Decisions API. Compare answer quality, uncertainty, response time, and observed credit use on inputs that resemble the work your product will actually receive.

Decision quality & calibrationSpeedCost per decision
Explore the benchmark

Jev 1.13.0

#1 · JevBench v1.3.0

74.4

Score

SemIf

#2 · open rebuild

73.1

Score

djev

#3 · hosted preview

73.0

Score

JevBench v1.3.0 · 52 systems · 534 decisions · snapshot: Sep 21, 2026

Questions about Decisions API

Learn how Decisions API brings multiple decision models together, how credits work, and how to move from the playground to an API integration.