OpenAI Decisions API vs. Jev: A Practical Guide to Decision Models

Many applications ask a model to make a small, repeatable choice: which team should handle a ticket, whether a message needs review, or which approved step an agent should take next. A general chat model can answer those questions in prose, but the application then has to turn that prose into a safe, predictable action.

OpenAI’s new Decisions API puts that bounded choice at the center of the request. Jev and six other hosted models in the decisions-api.dev model directory offer ways to test similar decision workflows today. This guide explains what OpenAI has announced, compares the available options, and shows how to try the site’s API with the same input across models.

Availability note · checked October 2, 2026: OpenAI’s September 29 DevDay recap describes Decisions API as a limited preview and says broader availability is planned in the following days. The recap explains the product’s purpose, but the official API documentation and changelog checked for this article did not provide a public request schema, endpoint, or price. Check OpenAI’s current docs before implementing its preview.

What is OpenAI Decisions API?

OpenAI describes Decisions API as a way to focus Luna’s intelligence on user-defined questions with a finite set of predefined answers. Developers provide context in text or images; the returned answer can be used to classify content, route a request, or choose an agent’s next action. These are the capabilities OpenAI states in its DevDay 2026 recap.

The idea is easiest to see in the shape of the request:

Chat workflow
context → prompt → generated explanation → parse and validate → application branch

Decision workflow
context → bounded question + allowed answers → structured decision → policy check

A chat model is a good fit when the application needs writing, explanation, or open-ended reasoning. A decision API is a candidate when the application already knows the possible outcomes and needs a consistent signal for its code. Structured JSON output can make a chat response easier to parse; a decision API goes further by making the bounded choice the task itself.

A model answer is still a judgment, not permission. Your application must check the user’s authorization, current account state, business rules, and any human-approval requirement before carrying out a consequential action.

OpenAI Decisions API vs. Jev

Jev is TypeSafe’s hosted decision model. The public Jev API uses a state plus typed questions: choice selects from named options, score assigns an ordered level, and noul evaluates a yes-or-no proposition. Jev answers can include probability fields. Through decisions-api.dev, the same kind of workflow is available with the site’s own endpoint, API key, and credit balance.

Dimension	OpenAI Decisions API	Jev through decisions-api.dev
Availability	Limited preview in OpenAI’s September 29 announcement; check OpenAI for current access	Public playground and API on this site
Input	OpenAI says text or image context	Text, JSON objects, or arrays as state; no image input in the hosted endpoint
Output	A choice from a finite, predefined answer space; public request details were not available in the docs checked	Typed choice, score, and noul answers, with probability fields
Endpoint and schema	Verify in OpenAI’s current API reference; this article does not guess a preview endpoint	POST https://decisions-api.dev/v1/systemone, documented by the site
Price	A public Decisions API price was not available in the sources checked	Site credits, billed on input tokens; see the current rates below
Comparison evidence	OpenAI has not published a matched benchmark in the announcement	Run the same labeled examples through Jev and other site models

The main practical difference today is the amount of the integration that is documented. OpenAI has explained the decision-oriented interface and announced a preview. Jev has a request format you can try through this site now. The site’s API key does not grant access to OpenAI, and the site is not a proxy for OpenAI’s preview.

Other decision models available here

The site currently supports seven hosted models through its playground and /v1/systemone API. Five use the general decision workbench; Span-01 and Span-01 Lite are specialized for behavior checks using noul questions.

Model	Supported questions	Good first comparison	Site input rate*
Jev 1.13 · typesafe/jev-1.13	Choice, Score, Noul	A general typed-decision baseline	600 credits / 1M tokens
Liquid d1 · liquid/d1	Choice, Score, Noul	A second hosted model on the shared workbench	0 credits / 1M tokens
Solar Decide · upstage/solar-decide	Choice, Score, Noul	Compare classification and scoring on your rubric	720 credits / 1M tokens
Kev 4B · jaredpalmer/kev-4b	Choice, Score, Noul	Include a compact 4B model in the evaluation	600 credits / 1M tokens
Tev1 4B Experimental · togethercomputer/tev1-4b-experimental	Choice, Score, Noul; Choice allows 2–20 options	Test an experimental compact model	600 credits / 1M tokens
Span-01 · respan/span-01	Noul behavior questions only	Check whether a conversation contains a defined behavior	300 credits / 1M tokens
Span-01 Lite · respan/span-01-lite	Noul behavior questions only	Try the lightweight behavior-checking option	0 credits / 1M tokens

These are the site’s current credit rates per million input tokens, not provider dollar prices. Output tokens are not billed. Each successful call costs at least one credit, so a zero per-token rate does not mean every request is free. Rates can change; check the model directory and API docs before estimating a budget.

All five general workbench models accept the same broad request shape, so you can hold the state and questions constant while changing the model ID. Tev1 has a narrower Choice limit of 2–20 options. Span models only accept Noul questions and are intended for behavior checks, such as whether an assistant made an unsupported promise.

Jev-Omni is a separate, self-hosted open-weights model for text, images, audio, and video. It is not one of the seven hosted /v1/systemone models and does not use the site’s API key or credit balance. Its model page lists CUDA hardware and roughly 50 GB of FP32 weights before runtime overhead.

How to use the hosted API

Start in the playground. Choose a model, enter a representative state, and define one to eight questions. Run the same examples through each model you want to compare; use clear labels and include ordinary, ambiguous, incomplete, and out-of-scope cases.

When you are ready to integrate from a server:

1. Create an account and a site API key in API Keys.
2. Store the key in a server-side secret such as DECISIONS_API_KEY; do not expose it in browser code.
3. Send the same state and questions to /v1/systemone for each model.
4. Read the answer from data.result.answers and apply your own validation and business policy.

Here is a Jev example that routes a support ticket and checks urgency:

curl -X POST https://decisions-api.dev/v1/systemone \
  -H "Authorization: Bearer $DECISIONS_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: support-ticket-1842" \
  -d '{
    "model": "typesafe/jev-1.13",
    "state": {
      "subject": "Charged twice for my annual plan",
      "message": "I paid yesterday, but my account is still locked.",
      "account_tier": "business"
    },
    "questions": {
      "ticket_route": {
        "type": "choice",
        "instructions": "Which team should handle the customer’s main issue?",
        "criteria": {
          "billing": "Payment, duplicate charge, subscription, or invoice issue",
          "technical": "A product bug, integration failure, or outage",
          "account": "Login, access, identity, or account security issue"
        }
      },
      "is_urgent": {
        "type": "noul",
        "instructions": "Does this need review today?"
      }
    }
  }'

The successful response is wrapped in data. Read the two answers from data.result.answers.ticket_route and data.result.answers.is_urgent; request metadata and creditsUsed are also returned. The optional Idempotency-Key helps prevent a retry from running the same logical request twice. See the API reference for response fields, errors, limits, and examples.

For the site’s current rate schedule, Jev, Kev, and Tev1 cost 600 credits per million input tokens, Solar Decide costs 720, Span-01 costs 300, and Liquid d1 and Span-01 Lite have a zero per-token rate. The service rounds up to a one-credit minimum per successful request. This is decisions-api.dev billing, separate from any direct provider price.

Compare models on the work, not the name

Before choosing a model, write down what a correct answer means for each option. Build a small labeled evaluation set from cases your application actually receives, and keep that set unchanged across model runs. Track:

• Accuracy by category, including false positives and false negatives.
• Probability calibration if your workflow uses confidence thresholds.
• End-to-end p50 and p95 latency from the region where your app runs.
• Credits used per request and the share of cases sent to human review.
• Performance on missing information, edge cases, and out-of-scope inputs.

Do not treat a probability as an accuracy guarantee. Start in shadow mode for decisions with real consequences: log the model answer next to the current rule or human decision, then review disagreements. Keep execution in application code. Check permissions, account state, idempotency, and policy before performing actions such as issuing a refund, changing access, or sending an external message.

Where the APIs fit

OpenAI’s announcement makes a simple distinction visible: a generative model produces language, while a decision API is designed to return a bounded answer for software to evaluate. The best choice depends on the public contract, the inputs you need, and measured performance on your own examples.

If you need to explore the pattern now, use the decisions-api.dev playground and compare Jev with the other hosted models on identical inputs. If OpenAI’s preview fits your use case, verify access, endpoint, schema, limits, image support, and price in OpenAI’s current documentation before integrating it.

Sources and further reading

• OpenAI DevDay 2026 recap and OpenAI API changelog.
• TypeSafe Jev introduction and API reference.
• decisions-api.dev model directory, playground, and API documentation.
• The Hugging Face community guide supplied as a structural and visual reference. It is not official OpenAI documentation.

This is an independent guide. decisions-api.dev is not an OpenAI product; the site’s key and credits work only with its own API. Jev is a TypeSafe model.