The System One race
Jev vs OpenAI Decisions API
OpenAI's Decisions API enters the same fast, closed-choice category Jev helped popularize. Both are designed to pick an answer your code can act on; the important differences are how questions are defined, what the confidence number means, and what context the model accepts.
Public reports describe the Decisions API as a limited-preview service built on GPT-6 Luna. Details may change as OpenAI publishes preview documentation. This page separates reported facts from Jev's current API contract.
Availability update
OpenAI Decisions API is not open for public use yet
The feature is still unavailable for general use. You can study the decision workflow here, but the API cannot be called from the public OpenAI platform yet.
Why this category exists
The missing step between model output and application action
A general-purpose model is good at explaining possibilities. A decision model is useful when your software already knows the allowed actions and needs one reliable branch quickly.
Return an answer, not a paragraph
A router should receive billing, sales, or support—not a paragraph that another parser has to read. The decision layer makes the action space explicit and keeps the response small.
Make the boundary explicit
Developers define the question and the answers that are valid. That makes downstream code easier to type, log, test, and reject when the result falls outside policy.
Keep the control loop fast
An agent can use a stronger model to plan, then hand small choices—route, allow, escalate, or choose the next tool—to a low-latency decision model.
At a glance
Same destination: a decision your code can use
The APIs sit next to each other, but they make different promises. Here is the current public picture, with preview claims called out.
Engine
A dedicated, non-conversational decision model.
A specialized version of GPT-6 Luna, according to DevDay coverage.
Primary job
Make bounded classifications, scores, or yes/no judgments that application code can act on.
Make a single fast choice from developer-defined answers for classification, routing, or an agent's next step.
Input
Text state: a string, JSON object, or array of text.
Context supplied as text or images.
Answer space
Choice supports up to 255 options; Score and Noul express other common decision shapes.
A finite set of predefined answers; the public limit was not disclosed in the preview coverage.
Question contract
Noul, Choice, and Score questions; multiple named questions can run in parallel.
A question paired with a closed list of predefined answers; the complete public request schema is still evolving.
Output
Typed answers with probabilities and confidence signals tied to the question type.
The selected answer with a confidence score.
Confidence
Jev documents calibrated probability and confidence signals for its decision outputs.
Current coverage describes a model-produced score; independent calibration details are not yet public.
Speed
Designed for low-latency, repeated decisions; benchmark results depend on the workload and baseline.
Coverage reports a 150 ms response and roughly 10× the speed of regular GPT-6 Luna.
Pricing
The current Jev materials describe metered usage; the exact plan and workload should be checked for the deployment.
Pricing was not published in the limited-preview coverage.
Availability
Public API and playground.
Limited invite-only preview at the time of the DevDay 2026 reports.
The Decisions API figures above are preview-era claims reported around DevDay 2026. Treat them as inputs for an evaluation plan, not as a universal performance promise.
One routing task, two contracts
The shape of the question matters
Both systems can route a billing ticket. Jev makes the question type part of the API contract; the Decisions API is described publicly as context plus a bounded answer set.
Jev: named typed questions
Choice selects a team while Noul asks whether a person should review the case.
{
"model": "jev-latest",
"state": "I was charged twice and need a refund.",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle this?",
"criteria": {
"billing": "Payments and refunds",
"technical": "Product issues",
"other": "None of the above"
}
},
"needs_review": {
"type": "noul",
"instructions": "Does this need human review?"
}
}
}Decisions API: context + allowed answers
A conceptual shape based on public descriptions—not a guaranteed SDK request body.
{
"context": "I was charged twice and need a refund.",
"question": "Which team should handle this?",
"answers": ["billing", "technical", "other"]
}The Decisions API example is intentionally conceptual because the referenced reports describe a preview product without publishing a complete stable request schema.
A practical agent pattern
A decision model is a fast gate, not the whole agent
The useful architecture is not model versus model. It is a division of labor: open-ended reasoning frames the task, a decision model handles a bounded branch, and your code owns the final permission to act.
01
Frame the task
Use an LLM or agent to understand the open-ended request, gather tools, and turn it into a compact decision context.
02
Expose relevant state
Pass only the text or image context needed for the next decision instead of replaying an entire conversation or tool trace.
03
Ask one bounded question
Define the allowed outcomes—route, allow, block, score, or next action—and let the decision API return the branch your code expects.
04
Enforce the action
Apply thresholds, permissions, rate limits, and human approval in deterministic code before booking, paying, sending, or changing data.
This pattern also works for tool selection: the orchestrator decides what the agent is trying to achieve, while a fast decision call chooses the next bounded move.
When each one makes sense
Choose Jev for bounded decisions
Use it when your application has repeated, well-scoped decisions, needs several question types in one request, or wants probability signals as part of the output contract.
Watch the Decisions API when
You need text or image context, want to stay inside OpenAI's ecosystem, and can accept preview availability while its contract matures.
Use a two-model workflow
Let a general model explain or transform information, then use a decision model for a narrow gate such as route, allow, score, or escalate.
Do not treat a confidence score as a safety guarantee. Evaluate either approach on labeled cases, set thresholds around the cost of mistakes, and keep deterministic policy checks or human review for consequential actions.
Before production
What to test before a decision can trigger an action
Fast answers are only useful when the boundary is measured. Keep the model call small, but make the surrounding evaluation and policy layer explicit.
Build a labeled set
Measure routing accuracy, false approvals, false escalations, and abstentions on real examples—not only on clean demo prompts.
Check the score
A confidence number is not automatically a calibrated probability. Compare score bands with observed outcomes before mapping them to business thresholds.
Try hostile inputs
Test numbers, dates, ambiguous instructions, prompt injection, malformed state, and cases designed to push the model toward a confident wrong branch.
Keep a safe fallback
For uncertain or high-impact cases, pause, ask for a human review, or hand the task back to a general workflow instead of forcing a choice.