Jev vs OpenAI Decisions API vs Laya — and what Dcision adds on top

In October 2026 OpenAI launched the Decisions API, with the gpt-6-luna model. It joined two decision engines that were already out there: Jev, by TypeSafe, and Laya, an open-source model by Convai Innovations. None of the three generates text. Each answers typed questions and returns probabilities with every answer.

Dcision runs all three. That raises a practical question: should you call an engine directly, or go through Dcision? This post compares the four options, covering what each one gives you and what it leaves to your code.

What a decision engine does, and what it doesn't

All three engines do the same core job: they evaluate an input and answer closed questions.

• Yes or no with a probability. Jev and Laya call it probability (or noul); OpenAI calls it predicate.
• One option out of a list, with the distribution across the options.
• A score on a scale, with the probability of each level.

OpenAI's own launch material describes the flow it expects inside an application: information → AI evaluation → structured result → application rules → action. The engines cover the first three steps. The rules and the action are yours to build. That is the part Dcision covers.

Side by side

Each engine at its best

Jev (TypeSafe). A System One model trained with RLCD for calibrated probabilities. Per token, it costs less than half of OpenAI's price, it handles long option lists well, and it is Dcision's default engine. It reads text and JSON.

OpenAI Decisions API. The natural path if you already build on OpenAI. You get SDKs in six languages, native real-time voice (GPT-Live), data controls such as ZDR, HIPAA and US/EU residency, and image input. It costs US$0.10 per 1M input tokens and is in public beta.

Laya (Convai Innovations). Open source under Apache 2.0, running on your own server: the data never leaves your infrastructure and there is no per-token price. Its context window is shorter (512 to 1,024 tokens), and you operate the server.

None of the three wins everywhere. Cost points to Jev. Images and the OpenAI ecosystem point to OpenAI. Keeping data in-house points to Laya.

What Dcision adds, on any engine

1. Switch engines without code changes

You describe a decision in a Decision Schema that names no engine. Dcision compiles it to an engine-neutral Decision IR, and only the adapter talks to the model. To change the engine of a workspace, or of a single decision, you change a setting. You can then run the same decision on Jev and on OpenAI and compare confidence in the Playground.

2. Any input, on any engine

State fields of type image, audio and file take files:

• Documents. Dcision reads PDF, Word, Excel, PowerPoint, CSV and similar formats into text itself, with no model cost.
• Audio. It is transcribed.
• Images. OpenAI Decisions receives them as images. Jev and Laya can't see images, so they get a text description instead.

As a result, one schema accepts a voice note or a PDF invoice on any engine.

3. Policies: from probability to action

A probability doesn't tell your system what to do. Dcision's policies turn answers and confidence into an action (continue, block, escalate or fallback) and always explain the choice in action_reason. Each question can have a minimum confidence, and a reserved other option sends the decision to fallback when no option fits. Call an engine directly and this logic ends up scattered across your code.

4. Destinations: what happens next

Each result can trigger a destination:

• a ready reply;
• structured JSON;
• an LLM call;
• your agent;
• a workflow (n8n, Zapier, Make);
• a signed webhook with retries;
• an API request;
• a function in your SDK.

It is the "application actions" column of the Decisions API diagrams, already built.

5. Versions, Playground and audit

Every deploy creates an immutable version, so changing a decision doesn't require redeploying your app. Every run is logged with its input, answers, confidence, action, engine and estimated cost. The overview tab shows volume, latency, errors and threshold calibration hints.

When to call the engine directly

Sometimes the engine alone is enough:

• One question inside a service you already control, with no need for policies, history or actions.
• Real-time voice with GPT-Live, without policies or logs, where OpenAI's native delegation lives inside the voice session. When you need policies, destinations and an audit trail, Dcision exports the questions to the session and takes its answers back.
• Research or a single-engine prototype that won't go to production.

Beyond those cases, everything the table marks "you code them", "you wire them" and "you build them" ends up in your codebase.

Summary

Decision engines answer. Dcision decides and acts, on the engine you choose.