Three Weeks From Launch to Clone: OpenAI Enters the Decisions Market

Image placeholder

Editorial, product-forward hero illustration on an off-white background — a clean horizontal timeline from left to right with two labeled tick points: 'SEP 15' on the left under a pale slate tile labeled 'JEV', and 'SEP 29' on the right under a pale emerald tile labeled 'OPENAI DECISIONS'. Both tiles contain the same tiny abstract shape — three stacked typed-field rows — showing the two products share a form factor. A thin pale slate line connects the two tiles. A small navy caption underneath reads 'fourteen days'. Clean, flat, geometric. Palette strictly off-white background, pale slate grays, one emerald green accent on the OpenAI tile, one navy ink for labels. No AI robots, no neural networks, no faces.

• Aspect ratio: 16:9
• Source size: 1600 × 900 px (sharp on retina at 760 px display width)
• Format: WEBP (preferred), PNG fallback
• Target file size: under 300 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

By Dr. Sanju Abraham, Fractional CTO — 180+ projects shipped, 34 funded companies. Published October 9, 2026.

Key takeaways

• OpenAI previewed its Decisions API at DevDay on September 29, 2026 — fourteen days after TypeSafe AI launched Jev. That is a clone cycle short enough that OpenAI was clearly not building reactively; it was unlocking a drawer.
• OpenAI’s model is GPT-6 Luna, with three output types — Predicates, Choices, Scores — and native image input. Jev launched text-only, so OpenAI’s first visible differentiator is multimodal context.
• Pricing comes in at a reported $0.10 per million input tokens on GPT-6 Luna, versus Jev’s $0.042. OpenAI is roughly 2.4× more expensive at launch, which is unusual for an incumbent fast-follow.
• I am naming this the category copy clock: the number of days between a startup’s category-defining launch and the frontier lab’s visible competing version. For decision APIs, that clock stopped at fourteen.
• A short clock does not mean OpenAI wins. It means the category is now a standard, the primitives are converging, and the real competition will be fought on price, calibration, and latency over the next six months.

The short answer: On September 29, 2026, OpenAI previewed its Decisions API at DevDay 2026 — a dedicated /v1/decisions endpoint that returns typed answers (Predicates, Choices, Scores) instead of prose, running on a specialized model called GPT-6 Luna. The preview arrived fourteen days after TypeSafe AI launched Jev on September 15. Pricing is reported at $0.10 per million input tokens on Luna, against Jev’s $0.042. OpenAI accepts image input in the request; Jev launched text-only. That is the surface. The real story is the fourteen-day clock between the two launches, and what a frontier lab moving that fast says about the category underneath.

A product manager on your team sends a Slack message: “OpenAI just shipped the same thing as Jev. Should we switch?” You could read the DevDay recap. You could pull up the pricing page. But before you do either, there is a much more interesting question to answer first — why did OpenAI ship this product fourteen days after a six-week-old startup defined the category? This piece is the answer, with the specifics of GPT-6 Luna in the right place.

What happened on September 29?

OpenAI used DevDay 2026 to unveil a dedicated decision-model endpoint called the Decisions API. The preview is on the record in secondary reporting from InfoQ and ProPakistani, and both outlets place the announcement on September 29, 2026.

The specifics that OpenAI showed at the event:

• A new HTTP endpoint at POST /v1/decisions, separate from the standard chat completions path.
• A specialized model called GPT-6 Luna behind the endpoint, described as a tuned variant of OpenAI’s current frontier model optimized for structured, short-output calls.
• Three output types: Predicates (probability a statement is true), Choices (pick one of N labels with a confidence score), and Scores (rate on a numeric rubric).
• Native support for image input in the same request as the text prompt.
• A latency claim of roughly 150 milliseconds for a typical decision call, against roughly 1.6 seconds for a standard GPT-6 Luna chat call — the “up to 10× faster” headline the launch coverage keeps repeating.

The limited preview opened at DevDay. Secondary coverage reports a wider public beta on October 6, 2026 at $0.10 per million input tokens, with output tokens and cache operations unbilled; I could not verify that beta rollout against OpenAI’s own pricing page in time for this piece, so treat the beta date and the exact fee schedule as reported-but-not-primary-confirmed. The core facts — endpoint, model name, output types, image input — are consistent across every outlet I checked.

What is OpenAI’s Decisions API, really?

It is OpenAI’s version of a decision model API, built on the same grammar as Jev but packaged as a feature of the OpenAI platform. You send a question and a schema; you get back a typed answer that matches that schema, by construction. No prose, no parsing, no “please only reply with yes or no.”

If you have read not every AI needs to talk or the chatbot vs decision model piece, the shape is familiar. OpenAI’s three output types map almost exactly onto the taxonomy I covered in the three questions a decision model answers:

• Predicate ↔ Verify. “Is this email asking for a refund?” returns a probability.
• Choice ↔ Choose. “Which queue does this go in?” returns one of a fixed list, plus a confidence score.
• Score ↔ Rate. “How risky is this transaction?” returns a number on a rubric.

Three jobs, three primitives. Jev calls them Choice, Score, and Noul; OpenAI calls them Choices, Scores, and Predicates. The names differ by a letter; the mental model is the same. That similarity is not a coincidence — it is the signal.

The one surface-level feature that is genuinely new relative to Jev at launch is image input. OpenAI’s Decisions API accepts text, images, or both in the same request. A support ticket with a screenshot, a receipt photo, a product image — all become legal context for a typed decision call. Jev launched text-only, which closes an entire category of document-and-screenshot workflows that OpenAI opened on day one.

Image placeholder

Infographic: a two-column product sheet comparing input modality. Left column labeled 'JEV' with a text document icon and a single caption 'text only, 32K tokens'. Right column labeled 'OPENAI DECISIONS' with a text document icon stacked above a photo thumbnail icon with a small '×N' badge, caption 'text + images in one request'. A thin separator between the columns. Below both columns, a tiny gray caption reads 'same decision grammar, different context windows'. Clean, flat, product-forward. Palette: off-white background, pale slate borders, emerald accent for OpenAI column, navy ink. No AI robots, no neural networks.

• Aspect ratio: 16:9
• Source size: 1280 × 720 px (sharp on retina at 760 px display width)
• Format: PNG
• Target file size: under 500 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

How does GPT-6 Luna compare to Jev?

On the primitives: identical. On modality: OpenAI has images. On price: Jev is less than half. The side-by-side, with every row sourced from the launch coverage I could find:

	Jev (TypeSafe AI)	OpenAI Decisions API
Launch	Sep 15, 2026	Previewed Sep 29, 2026; beta reportedly Oct 6
Model	Jev-latest	GPT-6 Luna (specialized)
Output types	Choice, Score, Noul	Choices, Scores, Predicates
Image input	text-only at launch	text + up to multiple images
Context window	32K tokens (published)	not confirmed by OpenAI
Reported latency	70–500 ms end-to-end	~150 ms vs ~1.6 s standard Luna
Input pricing	$0.042 / M tokens	$0.10 / M tokens (reported)
Output pricing	reported free	reported free
Access	hosted API, waitlist	hosted API, OpenAI account
Open weights	no	no

Three details worth pulling out of that table:

• The primitives are identical in spirit, down to the trio count. OpenAI did not invent a fourth output type; it did not collapse to two; it did not design around the same taxonomy with a twist. Three jobs, three names, same taxonomy. That is what convergence looks like at the API layer.
• OpenAI is 2.4× more expensive on input tokens. $0.10 against $0.042 is not a small gap. For a workflow processing a hundred million support emails a month, that is the difference between a few hundred dollars and a few thousand. Incumbents fast-following a startup usually undercut on price to force the switch. OpenAI did not — which tells you OpenAI is competing on bundle (image input, platform integration, developer trust), not on raw price per decision.
• Image input is a step-change, not a feature. If your workflow has any screenshot, receipt, scanned form, or product photo in it, OpenAI can decide against the whole thing in one call. Jev needs an OCR step or a vision model in front, and that pipeline costs you latency, error surface, and engineering time. For many document-shaped workflows, the economics flip even at 2.4× the token price.

For the broader frame on how to compare these on something more durable than a launch-week benchmark, see reading decision model benchmarks and how I use decision models in my product.

What is the category copy clock?

The category copy clock is a timer I am naming here, counting the days between a startup’s category-defining launch and the frontier lab’s visible competing version. For decision APIs, that clock stopped at fourteen — the number of days between Jev on September 15 and OpenAI’s DevDay preview on September 29. For context, the full market pile-on took 24 days from Jev to Microsoft’s launch; the broader signal lives in the three-week consensus piece. The category copy clock is specifically about the first frontier-lab tick.

Why coin a new term for something that could just be called “fast follow”? Because fast follow is a product of two very different things, and those two things want different responses from you as a builder.

• Reactive fast follow means an incumbent noticed a competitor, assembled a team, and shipped a response. The timeline is six to twelve months. The product usually feels like a translation of the startup’s thing into the incumbent’s platform. You learn mostly about market demand.
• Drawer-model fast follow means the incumbent already had the product sitting in a drawer, built for other reasons, and chose to unveil it the moment a credible startup validated the category. The timeline is two to four weeks. The product is more polished than it should be at that speed, and the primitives are suspiciously well-aligned with the startup’s. You learn mostly about internal roadmaps.

Fourteen days is not reactive. Fourteen days is drawer. That matters because drawer-model follows signal that the category was already consensus inside the lab’s product org — the startup just gave them an excuse to open the drawer. For buyers and builders, that is a stronger signal of durability than any launch benchmark could be. For the taxonomy of signals in a fast-moving API category, choosing a decision API in 2026 covers how to weight them.

Why does the pricing gap matter?

Because incumbents almost always undercut on price when they fast-follow a startup, and OpenAI did not. $0.10 versus $0.042 is a 2.4× gap in input-token cost at launch. In every other category where OpenAI has moved into a startup’s turf — think embeddings, structured outputs, vector-adjacent tooling — the launch move was to match or beat on price and let bundle and distribution do the rest. On decisions, OpenAI went the other way.

Three possible readings:

• OpenAI believes the bundle is worth 2.4×. Image input, OpenAI account continuity, the platform’s structured-outputs ecosystem, SOC 2 posture, enterprise contracts, the sheer gravity of already having an OpenAI integration — those are real, and for a lot of enterprise buyers they are decisive.
• GPT-6 Luna is actually more expensive to run per decision. A specialized tuning of a frontier model is a more capable base than whatever Jev is quietly running under the hood (TypeSafe has not published weights or parameter count). A higher cost of goods would explain a higher price without implying strategy.
• OpenAI expects the price to fall quickly. Launch pricing is almost never the long-run pricing in a fast-moving category. If the Decisions API drops to $0.05 in six months, the current gap is a transient launch artifact and the real story is image input. For the way pricing curves tend to settle in commodity API categories, open-weight decision models covers the usual arc.

Any of the three readings is plausible. All three have the same practical implication: do not switch to OpenAI purely on launch price, and do not stay with Jev purely on launch price, because today’s number tells you very little about the number you will be billing against in Q2. For the pattern on costed pilots versus production migrations, see your first decision model experiment.

Image placeholder

Infographic: a simple price comparison showing two horizontal bars on a shared axis labeled '$ per million input tokens, Oct 2026'. Top bar labeled 'JEV ($0.042)' is a short pale emerald bar. Bottom bar labeled 'OPENAI DECISIONS ($0.10, reported)' is a bar about 2.4× longer in pale slate blue. A thin gray annotation reads '2.4× gap at launch — unusual for a fast-follow'. A small navy caption underneath reads 'Launch-week pricing. Treat as snapshot, not forecast.' Clean, flat, product-forward. Palette: off-white background, pale slate borders, emerald + navy ink accents. No AI robots.

• Aspect ratio: 16:9
• Source size: 1280 × 720 px (sharp on retina at 760 px display width)
• Format: PNG
• Target file size: under 500 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

What should builders do about OpenAI’s entry?

Treat it as validation of the category, not as a reason to re-platform. The thing that actually changed on September 29 is that decision APIs are now definitively a standard — the primitives are converging, the big labs are in, and your pilot has a longer production runway than it did two weeks ago. Three concrete moves follow from that.

• If you have an OpenAI integration already and your workflow has images in it, pilot OpenAI first. Image input is the one real step-change in this launch. If your decisions depend on photos, screenshots, or scanned documents, OpenAI gives you a one-call path where Jev gives you a two-step pipeline. Measure the end-to-end accuracy, not the token price.
• If your workflow is text-only and high-volume, run Jev and OpenAI in parallel on the same inputs for a week. You will learn more from a thousand same-shape decisions scored side by side than from any amount of blog-reading, including this one. Keep the adapter thin — see Jev-compatible decision APIs for the one-file interface pattern — so swapping is a config change.
• Do not pick a long-run vendor yet. The price curve has not stabilized, calibration data is thin, and at least one more major entrant is likely in Q4. See the full market map for who else is lining up. Your job this quarter is to learn which workflows benefit from a decision call at all; your job next quarter is to pick the vendor they live on.

The one thing not to do is to interpret OpenAI’s entry as “Jev is now obsolete.” A startup launching the category and a frontier lab fast-following it in two weeks is not a story of displacement. It is a story of a category becoming infrastructure, and the next three to five entrants arriving right behind. For the broader framing of what “infrastructure” means in the decision-model context, see when AI stops talking and starts deciding and what is a System One model.

Frequently asked questions

When did OpenAI launch its Decisions API?

OpenAI previewed the Decisions API at DevDay 2026 on September 29. Secondary coverage from ProPakistani reports a wider public beta on October 6, 2026, running on a specialized model called GPT-6 Luna at a dedicated /v1/decisions endpoint. I could not verify the October 6 beta rollout against OpenAI’s own documentation at the time of writing, so treat the beta date as reported-but-unconfirmed.

What is GPT-6 Luna?

GPT-6 Luna is the model OpenAI runs behind the Decisions API, described in launch coverage as a specialized variant of OpenAI’s current frontier model, tuned for short, structured outputs instead of long-form prose. It is the only model currently available at the /v1/decisions endpoint, and OpenAI reports a typical latency of around 150 milliseconds — against roughly 1.6 seconds for a standard Luna chat call.

How does OpenAI’s Decisions API compare to Jev?

The primitives are nearly identical: Jev offers Choice, Score, Noul; OpenAI offers Choices, Scores, Predicates. Both return a confidence or probability per answer. The two concrete differences at launch are modality — OpenAI accepts images in the same request, Jev launched text-only — and price. Reported input pricing is $0.10 per million tokens for OpenAI versus $0.042 for Jev, roughly a 2.4× gap.

How much does the OpenAI Decisions API cost?

Reported launch pricing is $0.10 per million input tokens on GPT-6 Luna, with output tokens and cache operations unbilled. The number comes from secondary sources (ProPakistani and third-party pricing trackers) rather than OpenAI’s own pricing page, so verify against OpenAI’s current documentation before you plan a budget around it. Prices in fast-moving API categories often change within the first ninety days.

Does the OpenAI Decisions API accept image input?

Yes. Launch coverage confirms that the Decisions API accepts text, images, or both in the same request. That is the one capability Jev does not have at launch, and for workflows involving receipts, screenshots, scanned forms, or product photos, it collapses a two-step pipeline (OCR or vision model, then decision call) into a single API call.

What is the “category copy clock”?

A term I am introducing in this piece: the number of days between a startup’s category-defining launch and the frontier lab’s visible competing version. For decision APIs, that clock stopped at fourteen — Jev on September 15, OpenAI’s DevDay preview on September 29. A short clock signals a “drawer-model” follow, meaning the incumbent already had the product internally and only needed a market trigger to ship it.

Should I switch from Jev to OpenAI’s Decisions API?

Not purely on launch price or launch marketing. If your workflow involves images, OpenAI’s single-call path is a real win and worth a pilot. If your workflow is text-only and high-volume, Jev’s launch price is less than half OpenAI’s reported rate, and the primitives are close enough that a thin adapter makes the choice reversible. Run both on the same inputs for a week before you commit to either.

---

If you are weighing OpenAI’s Decisions API against Jev for a feature you are planning right now, that call-site-by-call-site judgment is exactly what a Fractional CTO is for. The category copy clock just told you the decision API shape is here to stay; it did not tell you which vendor’s bill you want to be paying in Q2. One hour of the right conversation can save a quarter of engineering time. More pieces in this thread live in the AI Strategy archive, and the companion read on everyone else who followed OpenAI into the category lives in OpenAI, Microsoft, and Cloudflare joined in.