Be honest. How many times today did you stop what you were doing to answer a question nobody will ever thank you for? Is this email urgent? Is that a dent in the box, or just a shadow?
We’ve all opened an email, read it, marked it unread so we could “deal with it later,” and then dealt with it never. That email is four years old now. It has a pension.
On October 6, OpenAI opened the Decisions API to every developer, and it’s built for exactly those little calls. My verdict: this is the most useful OpenAI release of the month for regular businesses, and it isn’t a smarter model. It’s an AI that’s been told to stop talking.
You hand it some evidence, like an email or a photo, and ask one question. It hands back a number or a pick from your list. By the end of this you’ll know which calls in your own work it can take, which ones it shouldn’t touch, and what it costs.
Think of it as the sorting table, not the pen pal. Most AI we’ve used so far writes back. You ask, it sends you a letter, and you still have to read the letter. The Decisions API is the person at the sorting table: envelope comes in, envelope goes in a bin, next envelope.
It answers in three shapes. OpenAI’s names for them are nerdier than they need to be, so here they are in plain English:
Yes-or-no odds (OpenAI calls this a predicate). “Does this product photo show damage?” You get the odds it’s true, from 0 to 1. OpenAI’s sample answer is 0.92.
Pick one (a choice). “Which team should handle this complaint?” It picks from the list you wrote. OpenAI’s example sends “I was charged twice for my order” to billing with a 0.95 probability.
Rate it (a score). “How bad is this bug?” on a scale you define. OpenAI’s example scores an export bug that fails in Safari but works in Chrome at 1.1 on a 0-to-2 scale, where 0 is cosmetic, and 2 is fully blocked.
Because every answer comes back as a number, your software can act on it without a person reading anything. That’s the shift: AI stops writing things for people and starts making calls inside the workflow itself.
It runs on GPT-6 Luna, OpenAI’s smallest and cheapest GPT-6 model for high-volume work, which OpenAI released on September 22.
The Decision Finder checklist
Here’s what you can do now that wasn’t cheap before: take the judgment calls that interrupt your people all day and turn them into background decisions, with a human catching the unsure ones.
To find those calls in your own work, run every repeat decision through this checklist. Five yeses means you’ve found a good candidate.
It happens dozens of times a week or more. A one-off call isn’t worth setting up.
You can write the possible answers down in advance. “Billing, shipping, technical, other” works. “Write a thoughtful reply” doesn’t. That’s a different tool.
The evidence is text, a photo, or both. Those are the inputs it takes.
A wrong answer is cheap to fix. A mis-sorted ticket costs a few minutes. A wrongly denied insurance claim costs a lot more. Start with the cheap ones.
You have past examples where you know the right answer. Even 50 to 100 of them. You’ll use them to check its work before you trust it.
Some everyday jobs that pass:
A returns desk flags package photos that likely show damage before anyone opens a box.
A sales team scores every new lead on a 0-to-3 scale so reps call the hot ones first.
An accounts team routes incoming invoices to the right approver.
A property manager checks move-out photos for visible wall damage.
An IT help desk sorts tickets by how blocked the person is.
Then comes the step nobody sets up and everybody should: the lanes. You decide what each number means for your business. Say you’re checking package photos for damage. At 0.90 or higher, the refund goes through on its own. Between 0.20 and 0.89, a person takes a look. Under 0.20, the case closes as no damage.
Those cutoffs are yours, not OpenAI’s. OpenAI’s own docs tell you to set them using labeled examples and the cost of each kind of mistake. A wrong “no damage” on a $9 mug gets a shrug. On a $2,000 laptop, it gets a one-star review written entirely in capital letters.
This is also where the career opportunity sits. Plenty of people know how to use ChatGPT. Far fewer can walk into a meeting and say: the AI takes the confident calls, people take the unsure ones, here’s exactly where the line sits, and here’s why. That’s a design job. It belongs to whoever understands the process best, and that’s usually not the IT department. It’s you.
Decisions vs. Responses vs. Jev: which one you actually need
The Responses API is OpenAI’s regular do-everything door: write, summarize, explain, use tools. Decisions is the narrow door for answers your software can branch on. Same ticket, two doors: Responses writes a memo about the ticket. Decisions stamps it Billing.
Use Decisions when the answer is yes-or-no odds, one pick from your list, or a rating on your scale.
Use Responses when you need words: a reply to the customer, an explanation, or fields pulled out of a document. OpenAI points you to its Structured Outputs feature for that, which forces the reply into a format your software expects.
Use function calling when the AI needs to do something, like look up an order. Function calling means the AI asks your software to run a specific action for it.
Plenty of real setups will use both. Decisions picks who gets the ticket, and Responses drafts the reply.
Two catches before anyone on your team starts building. Photos have to travel inside the request itself as base64, which is the picture converted into text, so a plain link won’t work. And when one answer depends on another, like “is it damaged?” followed by “what kind of repair?”, those go in separate requests. Independent questions about the same email or photo can share one request.
And then there’s Jev, which got here first. On September 15, three weeks before OpenAI’s beta, a startup called TypeSafe AI released Jev, a model built from scratch to answer typed questions instead of writing text. TypeSafe raised $40 million alongside the launch in a round led by DCVC, and its founder, Diogo Almeida, co-invented RLHF and InstructGPT at OpenAI. So OpenAI’s new toy has an older sibling, and the sibling was raised by a former OpenAI guy. Awkward family dinner.
On paper, the two look like twins. Jev answers with a pick from your list (TypeSafe calls it Choice), a rating on your scale (Score), or yes-or-no odds (Noul). Choice and Score come with a confidence number, and you can mix all three in one request. Here’s where they split:
Price. Jev costs $0.042 per million input tokens, and output is free. That’s about 2.4 times cheaper than Decisions, so the million long emails in the next section run about $42 on Jev versus about $100 on OpenAI.
Access. Anyone with an OpenAI developer account can use Decisions today. Jev runs only on TypeSafe’s hosted API and is still behind an early-access waitlist, though you can also reach it through gateways like LiteLLM and Netlify.
What’s underneath. Jev is a purpose-built decision model. Decisions runs on GPT-6 Luna, a general reasoning model aimed at a narrow job. Nobody has published a head-to-head test yet, so which one sorts your tickets better is an open question.
Compliance. OpenAI lists Zero Data Retention, HIPAA support for eligible customers, and data processing in the US or Europe. Check what TypeSafe offers before you send it anything sensitive.
Use Decisions when you’re already on OpenAI or need those compliance boxes checked. Try Jev when volume is high, cost matters most, and you can get through the waitlist. Either way, feed both the same 100 labeled examples before you commit.
What a million decisions really costs
First, the license: this is a paid, closed OpenAI service. There are no open weights and nothing to download. You pay per use through OpenAI’s API. It’s a public beta right now, and OpenAI says it expects general availability “in the coming weeks,” which is not a date.
At OpenAI’s published rates, you pay $0.10 for every million tokens you send in. A token is roughly three-quarters of a word. You pay nothing for what comes back, and there are no charges for cached input either.
So a 750-word email is about 1,000 tokens, and a million of those emails costs about $100. Your questions and the descriptions of your answer options count as input too, so the real number runs a bit higher.
Why does “nothing for output” matter so much? Luna is a reasoning model, meaning it thinks before it answers. In the regular Responses API, that thinking is billed as output at $0.50 per million tokens. Ask the same million questions there, and assume each answer uses 300 tokens of thinking plus reply. That adds $150, for $250 total instead of $100. The 300 is an illustration, and real usage swings by task, which is exactly why you test with your own sample before you budget.
The costs nobody puts in the headline:
Big requests. OpenAI says long-context pricing multipliers apply. For Luna, the higher rate kicks in above 272,000 input tokens per request.
Where your data is processed. Keeping processing in the US or Europe adds a regional premium.
Photos. An image adds far more tokens than a short email.
People. Building it, choosing the cutoffs, and checking its answers. For most teams, this is the biggest line item by a mile.
What OpenAI said vs. what the tests showed
Claim: “10x faster than the Responses API.” (OpenAI API changelog, Oct 6, 2026)
The evidence: OpenAI hasn’t published the test behind that number. As of Oct 8, 2026, no independent speed or accuracy test has appeared, and both Mixed News and AI Weekly flagged the same gap. Treat 10x as a promise until someone measures it.
Claim: You pay only for input tokens. (OpenAI Decisions docs, Oct 6, 2026)
The evidence: Confirmed on the pricing section, which also lists regional processing premiums and long-context multipliers. AI Weekly (Oct 7, 2026) estimates the total lands around one-fifth of what regular Luna pricing implies for short-answer sorting jobs. That’s their estimate, not a measurement.
Claim: It runs on GPT-6 Luna. (OpenAI Decisions docs, Oct 6, 2026)
The evidence: Confirmed, and Luna is the only model available. Mixed News (Oct 7, 2026) spotted that Luna’s own model page doesn’t list the Decisions endpoint yet. Most likely a paperwork lag, but it tells you how fresh this is.
Claim: Jev is fast and cheap. (TypeSafe launch, Sept 15, 2026)
The evidence: The $0.042 price is confirmed in partner docs that cite TypeSafe’s models page. TypeSafe also publishes its own workflow evaluations at evals.typesafe.ai, which is more than OpenAI has shown, but they’re vendor-run. No independent test pits Jev against Decisions yet.
Re-check all four before you build on them. Beta products change fast.
So what
Do this: Spend 20 minutes this week listing the five most repeated judgment calls on your team, and run each one through the Decision Finder checklist.
Skip this: Any call where a wrong answer hurts a person, like hiring, loans, or anything medical. Not without serious human review.
Wait on this: Building anything you can’t easily rebuild. It’s beta, and general availability is still weeks away.
Steal this line: “Where are we paying smart people to make the same small call 200 times a day?”
We spent the first few years of this AI wave teaching machines to say anything. The next phase is teaching them to pick one thing reliably and admit when they’re not sure. That will never get a standing ovation at a keynote. It might get you your Tuesday afternoons back.
See you next time. Go find your first five.
Sources
Intro and the three answer shapes
OpenAI API Changelog: Decisions API released in beta with gpt-6-luna (Oct 6, 2026): launch date, GPT-6 Luna, the 10x speed claim, and Luna’s Sept 22 release.
OpenAI Docs: Decisions guide (accessed Oct 8, 2026): the three question types and the 0.92, 0.95, and 1.1 sample answers.
The Decision Finder checklist
OpenAI Docs: Decisions guide, Interpret the answers (accessed Oct 8, 2026): setting thresholds with labeled examples and the cost of false positives and false negatives.
Decisions vs. Responses
OpenAI Docs: Decisions guide, How decisions work (accessed Oct 8, 2026): when to use Structured Outputs or function calling instead, base64 image requirement, separate requests for dependent questions.
And then there’s Jev
TypeSafe Docs: Introduction to Jev (accessed Oct 8, 2026): Choice, Score, and Noul question types, confidence on Choice and Score, several questions per request.
Eden AI: Jev, a new kind of AI model built for decisions, not conversation (accessed Oct 8, 2026): Sept 15 release, $40 million round led by DCVC, hosted-only API, early-access waitlist.
EveryDev.ai: Jev (accessed Oct 8, 2026): founder Diogo Almeida’s background.
Zuplo Docs: Using Jev (accessed Oct 8, 2026): $0.042 per million input tokens, free output.
Chatgate: Jev, fast structured AI decisions for software automation (accessed Oct 8, 2026): access through LiteLLM and Netlify; Jev can’t chat, write, or explain its answers.
What a million decisions really costs
OpenAI Docs: Decisions guide, Pricing and availability (accessed Oct 8, 2026): $0.10 per million input tokens, no output or cache charges, regional and long-context premiums, public beta status.
OpenAI API Changelog: GPT-6 Sol and GPT-6 Luna released (Sept 22, 2026): Luna’s regular rate of $0.50 per million output tokens.
eesel AI: GPT-6 Luna pricing (accessed Oct 8, 2026): the 272,000-token long-context threshold for Luna.
What OpenAI said vs. what the tests showed
Mixed News: OpenAI’s Decisions API runs on gpt-6-luna alone, and the model’s own endpoint table omits it (Oct 7, 2026): no benchmark behind the 10x claim; endpoint missing from Luna’s model page.
AI Weekly: OpenAI launches Decisions API public beta on GPT-6 Luna (Oct 7, 2026): one-fifth cost estimate; no head-to-head accuracy figures published
.
