Jev recipe / vendor comparison

Jev vs OpenAI Decision API (Luna): Typed Decisions Compared

Last updated: 2026-10-08

OpenAI answered Jev with the Decision API on GPT-6 Luna — now in public beta with published input-only pricing. Compare the contracts: answer sets vs typed Choice/Score/Noul, predicate vs noul naming, $0.10 vs $0.042 per million input tokens, and what each confidence number is worth.

AD

Six checks before you pick a decision API

01Confirm you are comparing the same contract, not a chat model: both products take context plus a question plus a predefined answer set and return one answer with a confidence score. Two vendors converging on that shape within a month is the market validating typed decisions.
02Map your decisions to primitives before picking a vendor: Choice for one-of-N routing, Score for ordered quality, Noul for yes/no gates. The beta covers all three — OpenAI names them choice, score, and predicate (its word for Jev’s Noul) — but the request and response shapes still differ, and beta field counts are not yet documented.
03Price your decision volume both ways: Jev publishes $0.042 per million input tokens with output free. Since entering public beta (2026-10-06), the Decisions API has published pricing too — $0.10 per million input tokens, output free, no cache-read or cache-write charges — with two honest caveats: that rate lives on the developer guide page while OpenAI’s main pricing page still lists no separate Decisions line (check both before you budget), and beta rates can move before GA. Jev remains ~2.4x cheaper on input at published rates. On the output-free model, Perplexity is cheaper still — see /recipes/jev-vs-perplexity-decisions-api.
04Gate automation on calibration, not on the existence of a confidence number: Jev probabilities are RLCD-calibrated, so a 0.85 threshold is an accuracy contract. Whatever confidence semantics Luna ships, validate them on ~100 of your own labeled examples before any auto-action.
05Check the modality and deployment edges honestly: the Luna context accepts images today — inline base64 data URLs only; hosted image URLs and file IDs are not supported per the beta guide — while Jev state is text (visual judgment lives in the OpenJev ecosystem); if decisions must stay on your hardware, the local route is OpenJev clones — Luna has no self-host path.
06Keep vendor optionality by design: wrap the decision call behind one interface so a Jev gate and a Luna call are swappable, and let the confidence-gated fallback chain route the low band from either model to the same review queue.
schema / typed multi-question contract
{
  "routing": {
    "type": "choice",
    "instructions": "Which queue should this ticket go to?",
    "criteria": {
      "billing": "Payment, invoice or refund issue",
      "technical": "Product malfunction or bug",
      "sales": "Buying or upgrade question",
      "abuse": "Safety or abuse report"
    }
  },
  "needs_safety_escalation": {
    "type": "noul",
    "instructions": "Does this ticket require a safety escalation regardless of queue?"
  },
  "urgency": {
    "type": "score",
    "instructions": "Rate how urgent a human reply is, 1 (routine) to 5 (business-stopping)"
  }
}
This schema is the contract depth in one view — run all three questions in the Playground and inspect the calibrated confidence.

Decision API contracts: Jev typed primitives vs OpenAI Decision API (Luna)

METRIC
Jev
OpenAI Decision API (Luna)
Availability (October 2026)
Generally available

self-serve API key, also reachable through OpenRouter and gateway providers

Public beta since 2026-10-06 (after the 2026-09-29 DevDay preview)

anyone can call it, OpenAI expects to GA "in the coming weeks," and the beta shape and pricing can still move

Question contract
Typed Choice (one of N options, criteria per option), Score (ordered 1–5), Noul (yes/no)

multiple questions share one call

Three question types in the beta docs

predicate (yes/no), choice (one of N), score (ordered rubric); predicate is OpenAI’s name for Jev’s Noul, and max answer/level counts are not yet documented

Latency per decision
~70–100ms single forward pass

no text generated

~150ms (OpenAI-cited, vs 1.6s for GPT-6 Luna chat)

also a single pass, not generation

Pricing transparency
Public: $0.042 per million input tokens, output free

pennies per 100k decisions

Published with the public beta (2026-10-06): $0.10 per million input tokens, output free, no cache-read/cache-write charges

stated on the developer guide page while the main pricing page still shows no separate Decisions line. Per-decision: ~2.4x Jev’s input rate

Confidence semantics
RLCD-calibrated probabilities

0.85 means ~85% right, so thresholds act as accuracy contracts

Confidence score shipped, calibration methodology unpublished

a ranking signal until validated on your own labels

Modality & deployment
Text state (visual judgment via the OpenJev ecosystem); local route with OpenJev clones on your own hardware
Context accepts images

inline base64 data URLs only (hosted URLs and file IDs are not supported per the beta guide); OpenAI-hosted only — no self-host or on-prem path

Side-by-side code: OpenAI decisions endpoint vs the Jev typed call

python / openai decisions endpoint (public beta)
import os
import requests

# Public beta since 2026-10-06: question types are predicate /
# choice / score (predicate = Jev's Noul), $0.10 per 1M input
# tokens, output free. Field shapes below are the announced shape -
# verify against the current guide before shipping; beta APIs move.
resp = requests.post(
    "https://api.openai.com/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
    json={
        "model": "gpt-6-luna",
        "context": "Ticket: my invoice shows the same charge twice...",
        "question": "Which queue should this ticket go to?",
        "answers": ["billing", "technical", "sales", "abuse"],
    },
    timeout=5,
)
resp.raise_for_status()
decision = resp.json()  # -> {"answer": "billing", "confidence": 0.91}

# Images (when you need them): inline base64 data URLs only -
# hosted image URLs and file IDs are not supported in the beta.
python / jev typed multi-question gate
import requests

JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone"
AUTO_ROUTE_CONFIDENCE = 0.85

QUESTIONS = {
    "routing": {
        "type": "choice",
        "instructions": "Which queue should this ticket go to?",
        "criteria": {
            "billing": "Payment, invoice or refund issue",
            "technical": "Product malfunction or bug",
            "sales": "Buying or upgrade question",
            "abuse": "Safety or abuse report",
        },
    },
    "needs_safety_escalation": {
        "type": "noul",
        "instructions": "Does this ticket require a safety escalation regardless of queue?",
    },
    "urgency": {
        "type": "score",
        "instructions": "Rate how urgent a human reply is, 1 (routine) to 5 (business-stopping)",
    },
}

resp = requests.post(
    JEV_ENDPOINT,
    json={"state": {"ticket": "..."}, "questions": QUESTIONS},
    timeout=5,
)
resp.raise_for_status()
data = resp.json()

route = data["answers"]["routing"]  # criteria-checked answer + calibrated confidence
if (
    route["confidence"] >= AUTO_ROUTE_CONFIDENCE
    and not data["answers"]["needs_safety_escalation"]["noul"]
):
    lane = f"auto:{route['answer']}"  # ~70-100ms, input tokens only
else:
    lane = "review"  # 0.60-0.85 band or safety flag
typescript / openai decisions endpoint (public beta)
const resp = await fetch("https://api.openai.com/v1/decisions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-6-luna",
    context: "Ticket: my invoice shows the same charge twice...",
    question: "Which queue should this ticket go to?",
    answers: ["billing", "technical", "sales", "abuse"],
  }),
});
// Public beta since 2026-10-06 (predicate / choice / score; $0.10 per
// 1M input, output free) - verify field names against the current
// guide before shipping; beta APIs move.
const decision = (await resp.json()) as {
  answer: string;
  confidence: number;
};
typescript / jev typed multi-question call
const JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
const AUTO_ROUTE_CONFIDENCE = 0.85;

const QUESTIONS = {
  routing: {
    type: "choice",
    instructions: "Which queue should this ticket go to?",
    criteria: {
      billing: "Payment, invoice or refund issue",
      technical: "Product malfunction or bug",
      sales: "Buying or upgrade question",
      abuse: "Safety or abuse report",
    },
  },
  needs_safety_escalation: {
    type: "noul",
    instructions:
      "Does this ticket require a safety escalation regardless of queue?",
  },
  urgency: {
    type: "score",
    instructions:
      "Rate how urgent a human reply is, 1 (routine) to 5 (business-stopping)",
  },
} as const;

const resp = await fetch(JEV_ENDPOINT, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ state: { ticket: "..." }, questions: QUESTIONS }),
});
const data = await resp.json();

const lane =
  data.answers.routing.confidence >= AUTO_ROUTE_CONFIDENCE &&
  !data.answers.needs_safety_escalation.noul
    ? `auto:${data.answers.routing.choice}`
    : "review";

Jev vs OpenAI Decision API FAQ

What is OpenAI's Decision API?

A non-chat endpoint built on Luna — the smallest and most affordable model in the GPT-6 family — announced in preview at OpenAI DevDay (2026-09-29) and opened to everyone as a public beta on 2026-10-06. You supply context plus questions across three primitives — predicate (yes/no), choice (one of N options), and score (ordered rubric) — and get typed answers with confidence back in about 150ms. The beta guide publishes the pricing: $0.10 per million input tokens with output free and no cache charges. OpenAI says it expects to GA "in the coming weeks." The New Stack reported the original announcement as likely a reaction to TypeSafe’s Jev.

Is the Decision API the same thing as Jev?

Same category, different contracts. Both are non-generative: context plus a question plus a fixed answer set in, one answer plus confidence out — no prose generated. Jev's contract is deeper: Choice questions carry criteria per option (the policy lives in reviewable code), Score covers ordered decisions, multiple questions share one call, probabilities are RLCD-calibrated, input-only pricing is public ($0.042/M, ~2.4x under Luna's beta rate), and the OpenJev ecosystem offers a self-hosted route. Luna counters with first-party OpenAI integration, inline-base64 image input, and published beta pricing — with calibration methodology still unpublished.

Which one should I pick for production today?

Jev remains the default while Luna is in beta: it is generally available, its thresholds are calibrated, its pricing is published on the product itself, and migration is one adapter function away. Choose Luna first if you are all-in on OpenAI, your decisions need image context, or single-vendor billing matters more than price ($0.10/M input vs Jev’s $0.042/M). Either way, run ~100 labeled examples from your own workload through both gates before automating anything on confidence alone.

Can I use both in one pipeline?

Yes, and the pattern is already documented: put both behind one decision interface in your code, then let the confidence-gated fallback chain own the routing — a Jev gate as the always-on first pass, a Luna call where image context helps, and the same 0.60–0.85 review band catching low confidence from either vendor. Vendor swaps then cost an adapter, not a rewrite.

How is this different from the Jev vs Luna benchmark guide?

This page compares the product and API contracts: request shape, primitives, latency, pricing, calibration, deployment. The Jev vs Luna benchmark guide compares measured task results — a 505-sample third-party evaluation where Jev took 382/505 at about $0.01 versus Luna's $0.06, including the event where Luna won. Read both: the contract tells you what you can build; the benchmark tells you what to expect when you build it.

What are the OpenAI Decisions API alternatives?

Four kinds, as of the beta. Jev is the contract-deepest hosted option: typed Choice/Score/Noul with per-option criteria, RLCD-calibrated confidence, and $0.042/M input (2.4x under Luna’s beta rate). Perplexity’s Decisions API is the cheapest hosted one ($0.02/M input, GA, vision input, Apache 2.0 weights). Cloudflare’s Clef and Liquid AI’s D1 are open-weight decision models you can run yourself, and the OpenJev family (Laya, Kev, SemIf, Von) covers fully local routes. The six-vendor landscape with October 2026 pricing is on our decision model API hub (/decision-model-api), and the open-source options are compared line by line in /jev-alternatives.

What happens to my code if the beta shape changes?

The beta can still move fields — OpenAI published the guide and pricing together on 2026-10-06 and expects to GA "in the coming weeks," so assume the request and response fields may shift — which is exactly why the Luna call should live inside one adapter function your application never sees past. The Jev evaluate endpoint has been generally available and unchanged since launch. Keep your ~100-example eval set handy either way: re-validating a swapped gate is an afternoon, not a quarter.

Go deeper on contracts and measurements