Compare GPT-6 Luna and other decision models in one playgroundExplore the playground

DecisionsApi · Understand the platform and the model

Decisions API vs Jev

Decisions API is the multi-model service on this site. Jev is a decision model you can select within it. Compare their roles, test a bounded question, and see how the service and model work together in one integration.

Platform vs modelOne integration, multiple modelsEvaluate on your own data

An example decision workflow

No credits used

Customer message

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

Jev-style questions, structured results

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

Try Decisions API with your own data

Try OpenAI Decisions API with GPT-6 Luna, or choose another decision model. Edit the input, define typed questions, and inspect the results before connecting the workflow to your backend.

Live requests require sign-in and use your available account credits.

Workbench

What do you want to decide?

Choose a scenario to load editable input and rules. Loading an example uses no credits.

Examples load into the current draft only; no configurations or run history are saved.

State

Give the selected model the context shared by every question.

Text

All questions share this context and are answered independently.

Questions

Define up to eight typed questions for the same state.

3 / 8

3. Run decision

Run the decision request.

Result preview

Subject: Charged twice again!! Hi — this is the SECOND month in a row I've been billed twice for the Pro plan. I already emailed last month and nobody replied. I run my whole business on this. If it's not refunded today I'm cancelling and disputing the charge with my bank.

↓One input → multiple structured decisions

Click “Generate decisions” to see typed output with probabilities.

Results are returned in a structured format so you can connect them to your application logic.

02 / From comparison to a working request

How Decisions API and Jev work together

The service handles access and usage; the selected model evaluates your questions. Keep those roles separate when you design your application.

01

Prepare the same context

Use a real ticket, document excerpt, or application record. Keep the input identical when comparing models.

state = ticket.text
02

Choose a bounded question

Define allowed labels, a scoring scale, or a yes-or-no question before selecting the model.

questions = { route, urgent }
03

Select Jev and inspect results

Run the question with Jev in the playground. Inspect the answer, probability signals, and recorded usage.

model = "typesafe/jev-1.14"
04

Apply your application rules

Use the returned signal to route a case or request review. Your code owns the permissions and next action.

if needs_review: escalate()

03 / Compare on tasks that matter

Three useful Decisions API vs Jev evaluation cases

Start with the outcome your product needs. The platform provides the workflow; Jev supplies the decision signal for the model you select.

01

Customer support routing

Ask Jev to select billing, technical, or account support. Use the service to run the same labeled cases across supported models.

02

Agent tool selection

Define allowed next steps such as lookup, answer, or review. Compare invalid choices and uncertainty before connecting a result to a tool.

03

Evidence and content checks

Put a claim next to its source and ask a focused question. Measure mistakes and review rates on clear, incomplete, and conflicting evidence.

04 / Understand the model output

Jev question types inside the Decisions API workflow

Choice, Score, and Noul express different decision shapes. Choose the shape your application needs, then compare how well a model answers it.

Choice: select a category

Define candidate labels and their criteria. Use the selected answer and its probability signals for routing and classification.

Score: evaluate a scale

Define an ordered scale for relevance, urgency, or quality. Compare scores against labeled examples instead of assuming every model uses the scale equally well.

Noul: ask a yes-or-no question

Use a focused question to obtain a probability between zero and one. Set thresholds using observed outcomes and the cost of incorrect decisions.

Integrate the service, select the model

One API request. Jev as the model.

This example calls this site’s service with Jev selected. The endpoint and API key belong to this service; direct TypeSafe access uses its own host, credentials, and billing. This is not an OpenAI API example.

Read this service’s API docs
Service-specific REST endpoint
State and typed questions
Your service API key

Select Jev in a service request

Server-side JavaScript · this site’s endpoint

POST /v1/systemone
const response = await fetch(
  "https://decisionapi.net/v1/systemone",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${DECISIONS_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "typesafe/jev-1.14",
      state: ticket,
      questions: {
        route: {
          type: "choice",
          instructions: "Choose the support queue for this ticket.",
          criteria
        }
      }
    })
  }
);

05 / Understand the service

How do I start testing and estimate usage?

Testing credits included

Create an account, check your available testing credits, and try real classification and scoring cases before choosing a credit pack.

One wallet for every live call

Use the same credit balance across the playground, API, and evaluation workflows. Credits from purchased packs do not expire.

Usage you can inspect

Review request history and credit activity, and use request identifiers to connect API calls with their usage records.

Service credits for testing Jev and other models

These packs belong to this site’s Decisions API service. They are separate from direct TypeSafe or OpenAI billing.

Compare the credits used by the same workload, together with answer quality and response time. A credit pack is not a universal per-model price.

Model access and billing

OpenAI’s Decisions API is in public beta. This platform provides model access through its unified API; check the current directory and your account access for available models and question types. Credit packs fund this service and do not add credit to an OpenAI account.

Starter

$10

Validate one real workflow, from the playground to your first API call

  • 100,000 credits, no expiry
  • 1 workspace
  • 3 concurrent requests
  • Standard speed
  • Choice, score, and noul questions
  • Typed decision output
  • Probability and confidence results
  • Online playground
  • API key management
  • Email support
Recommended

Pro

$100

Connect classification, routing, and safety decisions to a production product

  • 1,000,000 credits, no expiry
  • Unlimited workspaces
  • 10 concurrent requests
  • Fast lane
  • Choice, score, and noul questions
  • Typed decision output
  • Parallel questions per request
  • API access
  • Usage and request history
  • Priority support

Enterprise

$1,000

For multiple workspaces, team collaboration, and custom production integrations, with 10% extra credits

  • 11,000,000 credits (10% extra included)
  • Everything in Pro
  • Unlimited concurrency
  • Dedicated fast lane
  • Team workspaces and collaboration
  • Custom integration support
  • Security and permission guidance
  • Dedicated support
  • Priority production processing
  • Product roadmap feedback

Platform and model, side by side

Decisions API vs Jev: what are you choosing?

For this site, the choice is how to access and evaluate a model. You can use Jev through the service; they occupy different parts of the same workflow.

Decisions API vs Jev: what are you choosing?
DimensionDecisions API · this serviceJev · the model
RoleA playground and API for working with supported decision models.TypeSafe’s System One model for bounded decisions.
Decision formatA state-and-questions workflow with structured answers and usage details.Choice, Score, and Noul questions with probability signals appropriate to the question type.
Model selectionSelect a supported model in the playground or the request’s model field.One model family to evaluate for your task; account access determines the versions you can call.
IntegrationUse this service’s endpoint and API key, as shown in the example above.Direct access uses TypeSafe’s API host and credentials. A service integration uses that service’s endpoint instead.
BillingService credit packs, a shared wallet, and usage records.Cost depends on the access provider, model version, and workload. Direct provider charges are separate from this site’s credits.
What to measureIntegration effort, available models, usage visibility, and the end-to-end workflow.Decision accuracy, probability quality, latency, and cost on your own labeled cases.

A platform is not a competing model. Compare access options separately from model quality, using the same inputs and decision criteria.

Explore the Jev model guide

Decisions API vs Jev: common questions

Understand the service, the model, direct access, and what to measure before integrating.

What is the difference between Decisions API and Jev?

On this site, Decisions API is a service for accessing and comparing supported decision models. Jev is TypeSafe’s decision model, which you can select within that workflow. The service manages access and usage; the model evaluates the questions.

Do these credit packs pay for direct Jev or OpenAI access?

No. These packs fund calls through this site’s service. Direct TypeSafe and OpenAI accounts have separate credentials, access rules, and billing. Review the service’s access notice and account balance before running a call.

Can I use Jev through Decisions API?

Yes, when Jev is available for your account. Select it in the playground or set a supported Jev model identifier in your API request. Check current model availability and usage rates before integrating.

Does Decisions API vs Jev mean OpenAI Decisions API vs Jev?

The phrase can refer to different products. This page primarily compares this site’s multi-model service with Jev. We could not verify a dedicated OpenAI Decisions API contract in the official documentation checked on October 3, 2026. Confirm any OpenAI endpoint, price, and access requirement in its official documentation.

Which option is faster, cheaper, or more accurate?

There is no universal winner between a service and a model. Run the same labeled inputs through the access paths and model versions you are considering. Measure answer quality, response time, uncertainty, and total cost together.

Can I reuse a direct TypeSafe integration with this service?

The state-and-questions structure is a useful starting point, but verify the service documentation. API host, authentication, model identifiers, supported parameters, response details, and billing can differ. Test representative requests before changing an integration.