OpenAI Decisions API vs. Jev: What Changes When a Model Makes Decisions?

The OpenAI Decisions API is a limited-preview API for making a bounded choice from context. Instead of asking a model to explain itself in prose and then parsing that prose, you define a question and the possible answers; the API returns a decision your software can use.

This is useful because much application logic does not need another paragraph. A support system needs a team, an agent needs its next tool, and a workflow needs a risk level. A decision interface makes that output the point of the call.

OpenAI has now announced this as a distinct API primitive. Jev, TypeSafe’s System One decision model, already offers a public API in the same broad category. Below, we will separate what OpenAI has confirmed from what remains unknown, compare the two products, and then walk through a real Jev workflow on decisions-api.org.

1. What OpenAI has announced

At DevDay on September 29, 2026, OpenAI described Decisions API as a way to provide context—text or images—then define questions and a finite set of possible answers. The examples in OpenAI’s recap are content classification, request routing, and choosing an agent’s next action. The feature is currently in limited preview, with broader availability described as coming in the following days. OpenAI’s DevDay recap

The difference from an ordinary prompt is easiest to see as a change in where the boundary lives:

Chat-style flow
context → prompt → generated explanation → parse/validate → application branch

Decision-style flow
context → question + allowed answers → typed decision → application branch

The second shape is attractive when the application already knows its possible next steps. It can reduce glue code, but it does not remove the need to define labels carefully, check edge cases, or keep sensitive actions under application control.

OpenAI’s announcement says Decisions API uses Luna’s intelligence and accepts image context as well as text. A report from DevDay describes a specialized GPT-6 Luna version and a roughly 150 ms demo response, compared with about 1.6 seconds for a general Luna call. Treat those numbers as a reported demonstration, not a benchmark, production guarantee, or service-level agreement. DevDay reporting by Pasquale Pillitteri

As of September 30, 2026, I could not find a public Decisions API reference page, request schema, endpoint, or standalone price in OpenAI’s developer documentation. The API changelog also does not yet list a Decisions API entry. So a path such as POST /v1/decisions should not be copied from unofficial examples and treated as an official contract. The preview announcement is real; the public implementation details are still pending.

2. How Jev compares

TypeSafe’s Jev is the first model in its System One family. Its public API accepts a state and typed questions. The main question types are Choice for selecting among named options, Score for ordered levels, and Noul for a yes-or-no proposition. Jev returns structured answers with probability signals; the direct TypeSafe endpoint is POST https://api.typesafe.ai/v1/systemone. TypeSafe API introduction · API reference

Dimension	OpenAI Decisions API	Jev by TypeSafe
Availability	Limited preview announced September 29, 2026	Public API and API reference available
Input described publicly	Text or images as context	Primarily text state, including structured text/JSON
Decision shape	A question with finite possible answers	Choice, Score, and Noul typed questions
Probabilities	Mentioned in launch coverage; public technical details are pending	Probability fields are part of the documented answer shape
Calibration	OpenAI has not published technical detail in the public API docs checked	TypeSafe describes RLCD training for calibrated decisions; this is a provider claim, not a per-answer guarantee
Latency	About 150 ms in one reported launch demo; not an SLA	TypeSafe presents Jev as a low-latency decision model; measure it on your own traffic
Price and schema	No standalone public price or API schema found on September 30, 2026	TypeSafe lists $42 per billion input tokens ($0.042 per million) and publishes a Swagger API reference

TypeSafe describes its approach as RLCD, or Reinforcement Learning for Calibrated Decisions. Its documentation explains calibration as a property to evaluate across groups of predictions, rather than a promise that every individual probability is correct. In production, test probabilities against labeled examples and track calibration and error costs yourself. TypeSafe’s machine-learning primer · TypeSafe pricing

Neither product should be judged by a demo number alone. Compare the complete decision path on the same representative states: correct route, missed escalation, latency, cost, and how often a human must intervene. Keep thresholds and high-impact actions in application code.

3. What you can do on decisions-api.org today

Decisions-api.org is an independent playground and API service. Its current workbench can run Jev, along with other decision models. It does not currently expose OpenAI’s limited-preview Decisions API. The steps below therefore use the site’s Jev integration and the site’s own API contract; they do not use an OpenAI API key.

Step 1: Open a ready-made decision

Visit the support-routing example and sign in. New accounts receive 100 welcome credits once. Loading an example does not use credits; a live model run does. Choose typesafe/jev-1.13 in the model selector if it is not already selected.

The screenshot shows the example’s input fields. Any static preview in the interface is labeled illustrative and is not a model response. Run your own example before treating an answer or probability as evidence.

Step 2: Define the decision you actually need

Write a short state with the relevant facts, then ask one concrete question. For example, “Which team should handle this request?” is easier to evaluate than “Understand this customer.” Define the allowed destinations and what each one means. In Jev, that maps to a Choice question.

For a first trial, keep one question and use billing, technical, and general support as the options. Then try ordinary, borderline, and ambiguous tickets. Change only one thing at a time so you can tell whether the state, instructions, or answer criteria caused a change.

Step 3: Run examples and inspect the result

Use the Run button to make a live request. Review the chosen option and its probabilities. If you need a numeric severity, add a Score; if you need a yes-or-no judgment, use Noul. Avoid treating a returned probability as measured accuracy or as permission to automate a high-impact action.

If you already have labeled examples, compare model decisions against them. Track false routes, missed escalations, latency, and the cost of review. Route uncertain or high-risk cases to a person until evaluation supports a safer threshold.

Step 4: Create a site API key

Open API keys and create a key for your application. This key belongs to decisions-api.org. Store it as a server-side secret, for example DECISIONS_API_KEY; do not put it in browser code or a public repository. The site’s API quickstart documents this platform API.

Step 5: Send a decision request from your server

Here is a minimal request using the site’s documented endpoint and Jev model. Replace the example state with data your application is allowed to send.

curl -X POST https://decisions-api.org/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": {
      "message": "I paid yesterday but still do not have access.",
      "account_status": "active"
    },
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this request?",
        "criteria": {
          "billing": "Payment, invoice, refund, or access after payment",
          "technical": "A product bug or service failure",
          "general": "A request that does not fit the other teams"
        }
      }
    }
  }'

The site API wraps successful data: read the selected answer at data.result.answers.department. The Idempotency-Key should be unique for each logical request; reusing it intentionally prevents a duplicate model run. This is the decisions-api.org contract, not the direct TypeSafe or OpenAI endpoint. Full site API documentation

Step 6: Keep the final branch in your code

The site charges credits from your decisions-api.org balance. Its current workbench lists Jev at 600 credits per million input tokens, rounds each successful call up to at least one credit, and does not bill output tokens; $1 buys 10,000 credits. This platform billing is separate from TypeSafe’s direct $0.042/M token price. Check the live workbench billing note before estimating a project. Site API limits and billing notes

Your application should decide what to do with the answer. For example, route a high-confidence, low-risk ticket automatically and send uncertain cases to a support queue. Keep authorization checks, payment changes, account closure, and other consequential actions deterministic and auditable.

Which one should you evaluate first?

OpenAI’s announcement makes decision-specific APIs a larger conversation: software often needs a classification, score, route, or next action rather than a paragraph. OpenAI’s preview may be especially interesting for visual inputs if that announced capability reaches a stable public API. The endpoint, schema, price, and probability-calibration details still need to be published.

Jev can be tested now through TypeSafe’s public API or through the decisions-api.org workbench. Start with one bounded, low-risk decision and a labeled evaluation set. The model returns a judgment; your application remains responsible for deciding whether that judgment is good enough to act on.

Research date: September 30, 2026. Product availability and prices may change.

Sources: OpenAI DevDay recap · OpenAI API changelog · TypeSafe Jev introduction · TypeSafe API reference · TypeSafe calibration primer · TypeSafe pricing · DevDay latency report

This article is an independent product guide. Decisions-api.org is not an OpenAI product, and Jev is a TypeSafe model.

---

（End）