Skip to content

Build Independently confirmed4 publishers 3 min read Published

OpenAI splits classification into a Decisions API priced at 10 cents per million input tokens

OpenAI's Decisions API answers yes/no, pick-one and scale questions for $0.10 per million input tokens, with output free. Jev sells the same three question types for text at less than half that, so OpenAI's case rests on image input and compliance terms.

The Engineer · Build desk

Send a correction

What happened

  • According to Simon Willison, gpt-6-luna accepts images as well as text, an input Jev does not support.
  • OpenAI supports zero-data retention and HIPAA-compliant use of the API in the US and Europe.
  • OpenAI also cut its paid API tiers from five to three, Build, Launch and Grow, with monthly usage limits of $500, $5,000 and $200,000.

Why it matters

  • What it costs cost With output free, prompt and image size set the bill; a Build-tier organisation's $500 limit buys about 5 billion input tokens of decisions a month.
  • Who has to decide decision Text-only classifiers that do not need OpenAI's image support or HIPAA terms pay about 2.4 times more per token on gpt-6-luna than on Jev.
  • What it limits constraint Grow's limit is 40 times Launch's, so a team spending between $5,000 and $200,000 a month has to prepay credits to the Grow threshold before its cap lifts.
  • What's now possible capability Because both vendors expose the same three question types, one classifier can be pointed at each and compared on a team's own labelled data before it commits.

In Simon Willison's first test, he sent an image file named two-pelicans.jpg with the question "Does this image contain any mammals?" and got back {"type": "predicate", "name": "evaluation", "probability": 0.0} [12]. Pelicans are birds, so the model was right [12]. The whole answer is a few tokens, and OpenAI charges nothing for output [6]. Prompt length and attachment size set the bill.

The yes/no type returns a probability [1]. The caller picks the cutoff. Moving it changes how often a router escalates without changing the price of a call [6].

OpenAI says the endpoint runs about ten times faster than its Responses API [24]. That figure describes OpenAI's own comparison payload. It transfers to your queue if your current classifier runs through Responses and spends most of its time generating output, such as a JSON wrapper or a reasoning preamble ahead of the label. A classifier already constrained to one short answer has less generation time to cut.

Jev got there first. The Decoder calls the launch likely OpenAI's response to the "decision models" trend Jev started in mid-September [8]. Willison's 6 October post reported the release, following an announcement at DevDay the week before [9]. He wrote that the API shape "is very similar to Jev, at least conceptually" [4]. Both offer the same three question types [2].

Jev charges 4.2 cents per million input tokens. OpenAI charges 10 [11]. OpenAI is about 2.4 times the price [19]. A billion input tokens a month costs $100 on OpenAI and $42 on Jev [20].

The premium buys two things. "Unlike Jev, the new gpt-6-luna decision model supports image input in addition to text," Willison wrote [7]. OpenAI says the API evaluates text, images or both, and lists damage detection in photos among its use cases alongside inquiry routing and document classification [3][10]. It also supports zero-data retention and HIPAA-compliant use in the US and Europe [13]. A text-only routing queue with no health data uses neither feature, and Jev is the cheaper place to run it [19]. The OpenAI endpoint is also in public beta with one model [5].

Moving between the two looks cheap. Willison built his llm-openai-decisions plugin by having GPT-6 Astra read OpenAI's documentation, modeled on the plugin he already had for Jev [14]. I'd run the same labelled sample through both and compare error rates and latency on my own data before committing either way.

The tier change is a budgeting problem. OpenAI cut its paid tiers from five to three: Build, Launch and Grow [15]. Organisations move up automatically when total credit purchases reach the next threshold [16]. The monthly limits are $500, $5,000 and $200,000 [17]. At Decisions prices, Build covers 5 billion input tokens a month and Launch covers 50 billion [21]. The step from Launch to Grow is 40x [22]. A workload that needs anything in between has to buy credits up to the Grow threshold first [16]. The Decoder's report does not list the thresholds or say whether reaching a limit stops requests. On 3 October, Willison published a post titled "We're going to need default hard budget caps on pretty much everything" [18].

What to watch

  • Terms at general availability: whether OpenAI adds models beyond gpt-6-luna or changes the 10-cent input price.
  • Publication of the credit-purchase thresholds for Launch and Grow, and whether the monthly limits stop requests when reached.
  • Whether Jev adds image input or moves its 4.2-cent price in response.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence62
Adoption20
Hype gap+15
Incentives45
Confidence60

Perspective Coverage

4 publishers
Builder
Builder 59%
Operator
Operator 24%
Investor
Investor 17%
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    The API handles three response types: yes/no probabilities, picks from predefined categories, and scale-based ratings.

    Reported Supported Source: The DecoderView cited source
  2. [2]

    Jev supports three question types for yes/no, choices, or scores; OpenAI Decisions supports the same three types.

    Reported Supported Source: Simon WillisonView cited source
  3. [3]

    OpenAI's new Decisions API evaluates text, images, or both.

    Reported Supported Source: The DecoderView cited source
  4. [4]

    "Otherwise the API shape is very similar to Jev, at least conceptually."

    Reported Supported Source: Simon WillisonView cited source
  5. [5]

    The Decisions API is in public beta with general availability coming soon; only gpt-6-luna is supported so far.

    Reported Supported Source: The DecoderView cited source
  6. [6]

    gpt-6-luna on the Decisions API costs $0.10 per million input tokens; output tokens are free.

    Reported Supported Source: The DecoderView cited source
  7. [7]

    "Unlike Jev, the new gpt-6-luna decision model supports image input in addition to text."

    Reported Supported Source: Simon WillisonView cited source
  8. [8]

    The Decisions API is likely OpenAI's response to the mini-trend of 'decision models' that Jev kicked off in mid-September.

    Reported Supported Source: The Decoder's interpretationView cited source
  9. [9]

    In a post dated 6 October 2026, Willison reported that OpenAI released its Decisions API, as previously announced at the previous week's DevDay.

    Reported Supported Source: Simon WillisonView cited source
  10. [10]

    Use cases include damage detection in photos, automatic customer inquiry routing, and document classification.

    Reported Supported Source: OpenAI, as reported by The DecoderView cited source
  11. [11]

    Both models charge for input and not for output: OpenAI's is 10 cents per million input tokens, Jev's is 4.2 cents per million.

    Reported Supported Source: Simon WillisonView cited source
  12. [12]

    Willison's example query sent an image file named two-pelicans.jpg to openai-decisions/gpt-6-luna asking 'Does this image contain any mammals?' and received {"type": "predicate", "name": "evaluation", "probability": 0.0}.

    Reported Supported Source: Simon WillisonView cited source
  13. [13]

    The Decisions API supports zero-data retention and HIPAA-compliant use in the US and Europe.

    Reported Supported Source: The DecoderView cited source
  14. [14]

    Willison had GPT-6 Astra read the new OpenAI API documentation and build an llm-openai-decisions plugin inspired by his existing llm-typesafe plugin for talking to Jev.

    Reported Supported Source: Simon WillisonView cited source
  15. [15]

    OpenAI cut its paid API tiers from five down to three: Build, Launch, and Grow.

    Reported Supported Source: The DecoderView cited source
  16. [16]

    Organizations move up tiers automatically when their total credit purchases hit the next threshold.

    Reported Supported Source: The DecoderView cited source
  17. [17]

    Monthly usage limits for the three tiers sit at $500, $5,000, and $200,000.

    Reported Supported Source: The DecoderView cited source
  18. [18]

    Willison published a post on 3 October 2026 titled "We're going to need default hard budget caps on pretty much everything".

    Reported Supported Source: Simon Willison's site, recent articles listView cited source
  19. [19]

    OpenAI's Decisions input price is about 2.4 times Jev's.

    Derived Supported
  20. [20]

    One billion input tokens costs $100 on OpenAI's Decisions API and $42 on Jev.

    Derived Supported
  21. [21]

    At $0.10 per million input tokens, the $500 Build limit covers 5 billion input tokens a month and the $5,000 Launch limit covers 50 billion.

    Derived Supported
  22. [22]

    The Grow tier's monthly limit is 40 times the Launch tier's.

    Derived Supported
  23. [23]

    Jev's input price is 42% of OpenAI's, less than half.

    Derived Supported
  24. [24]

    The Decisions API runs about ten times faster than the Responses API.

    Reported Insufficient Source: OpenAI, as reported by The DecoderView cited source

Sources

4 independent publishers whose own reporting we read for this story.

  1. blog.vercel.com

    1 article · October 6, 2026

    OpenAI Decisions API now available on AI Gateway
  2. simonwillison.net

    1 article · October 6, 2026

    llm-openai-decisions 0.1a0
  3. the-decoder.com

    1 article · October 7, 2026

    OpenAI launches Decisions API that reduces complex evaluations to yes, no, or pick one
  4. thenewstack.io

    1 article · October 7, 2026

    Decision models are suddenly everywhere. OpenAI’s is now public.

Topics and entities