OpenAI Decisions API Hands-On: Better Than Jev, or Just More Expensive?

What Is the Decisions API: Built for Simple Questions

OpenAI's Decisions API, announced at Dev Days, is now publicly available to all developers with an API key. This is OpenAI's answer to Jev (often misheard as "Jeff") — a decision model solution designed to deliver fast, low-latency answers to questions with a fixed output space. Based on hands-on testing by a YouTube tech creator, this article compares the Decisions API against open-source Ollama models and Jev across four dimensions: usage, speed, cost, and quality.

The Decisions API isn't designed for "chatting" with a model. Its purpose is to return extremely fast answers to well-defined, simple questions. Typical latency falls between 100–200 milliseconds, making it suitable for near-real-time decision scenarios — think "which lane should I take based on this image" — where complex reasoning isn't required.

These decision models support three question types:

• Predicate: Yes/no questions (called "null" in Jev), e.g., "Is this request safe?" or "Is this message positive?"
• Choice: Classification questions, e.g., "Is this a billing issue, a technical issue, or a shipping issue?"
• Score: Rating questions, e.g., "How positive is this message?" or "How dangerous is this request?"

In short, when you need to quickly select one answer from a fixed output set, this type of model is the right tool — not a model built for long-form reasoning.

The core difference between a Decision Model and a general-purpose LLM lies in how the output space is constrained. General LLMs produce open-ended natural language and must generate a full token sequence for each inference. Decision models restrict answers to a predefined finite set (yes/no, a few fixed categories, a score range), resulting in shorter inference paths and millisecond-level latency. This architectural approach isn't new to OpenAI — traditional ML classifiers and intent detection models have long served similar roles, though they require large amounts of labeled training data. LLM-based decision APIs, by contrast, enable zero-shot classification through natural language option descriptions, dramatically lowering the barrier to adoption. The confidence field is a key design element, allowing developers to implement fallback logic for uncertain cases rather than blindly trusting model output.

Quick Start in the Playground

The documentation page includes a Playground link where you can test all three modes directly in the browser. The creator used the classic "Is this a hot dog?" meme as a demo: modeled as a Choice question with only hot dog / not hot dog as options, the model correctly returned not hot dog when shown a book or a chocolate bar. The same question can also be reframed as a Predicate for a pure yes/no answer.

The key takeaway from this step: the Decisions API handles not just text but also images, and all three output categories are consistent with other decision models.

Code in Action: Text Classification and Image Recognition

At the code level, the call pattern differs from the Chat API. After initializing the client, you use client.decisions.create to make a request. The only supported model is GPT-6 Luna — it's currently the sole option available.

A single request can include multiple questions in parallel. Using a customer service scenario as an example: a user inputs "I was charged twice on my last order," and the request simultaneously includes two questions — a Choice type asking "What kind of request is this?" (billing / technical / shipping / other, each with a description to help the model decide), and a Predicate type asking "Does this message contain any spelling errors?"

The response returns a decision.answers collection containing multiple answers. Each answer includes a choice (or boolean result) and a confidence score, which developers can use to write business logic — for example, "execute this action when confidence exceeds 70%." In testing, a billing request was correctly identified as billing with near-100% confidence, while the spelling error detector jumped from 0 to 1 in confidence when "twice" was deliberately misspelled as "twise."

For image processing, images must first be base64-encoded before being passed in, using a message format that combines input_text and input_image. The creator tested a photo of Vienna asking "Is this a European city?" — the model returned 99% confidence.

Speed, Cost, and Quality: A Three-Way Comparison

This section is the most valuable part of the whole piece. The creator ran the same set of tasks on the OpenAI Decisions API, Jev, and a local Ollama model.

On cost, the Decisions API is noticeably more expensive:

• Jev: ~$0.04 per million input tokens
• OpenAI (GPT-6 Luna): ~$0.10 per million input tokens
• Output tokens are free for both
• Self-hosted Ollama models: completely free

On speed, for pure text classification tasks:

• Ollama (once the model is loaded into memory): ~1.1 seconds — fastest and free
• OpenAI Decisions API: ~2.5 seconds
• Jev: ~2.9 seconds, slightly slower

Image tasks are where things diverge. Jev doesn't support image input, so it can't participate in multimodal comparisons. In a test classifying video thumbnails (determining subject matter, detecting faces, and scoring clickbait intensity), OpenAI completed the task in ~3.4 seconds, while the local Ollama setup running Qwen Flash took ~9.5 seconds — though that ran on a Dell Pro Max/GB10 (DGX Spark) device, and faster hardware would yield faster results.

Worth highlighting is the practical value of the Score feature in image scenarios: the creator used it to rate thumbnails on "clickbait intensity," and the results aligned well with human intuition — more sensational thumbnails scored higher.

Ollama is a tool that enables running open-source LLMs locally, supporting mainstream models like Llama, Qwen, and Mistral without requiring a cloud API. Its speed is highly dependent on local hardware. The Dell Pro Max/GB10 (NVIDIA DGX Spark) mentioned in the test is a developer-targeted desktop AI compute device powered by the GB10 Grace Blackwell Superchip, offering solid local inference capability. The 9.5-second image processing time doesn't represent the ceiling of what Ollama can do — it would be significantly faster on higher-end GPUs. For developers without dedicated AI hardware, local Ollama latency on multimodal image tasks could be far higher than the test values, an important hidden cost to factor in when comparing it against cloud APIs.

Is It Worth Using?

The creator's conclusion is fairly blunt: the Decisions API is largely just a more expensive Jev — unless you need image input.

The decision logic breaks down like this:

• Text-only tasks, want maximum speed and zero cost → Self-hosted Ollama is the better deal
• Text-only tasks, don't want to maintain infrastructure → Jev is cheaper than OpenAI
• Need multimodal (image) decisions → OpenAI Decisions API is the only out-of-the-box option covered here
• Already deeply invested in the OpenAI ecosystem → Decisions API eliminates integration overhead, and $0.10/million tokens is still very affordable in absolute terms

For teams that have already built applications within the OpenAI ecosystem, or that have image-based decision needs, the Decisions API offers a standardized, low-latency entry point. But if your tasks are text-only and you're cost-sensitive, open-source models and Jev remain more economical options. The core selection criteria ultimately comes down to two questions: "Do you need images?" and "Are you willing to self-host?"

Jev (often transcribed as "Jeff" due to pronunciation) is a model service focused on structured decision reasoning, with pricing ($0.04/million input tokens) significantly lower than OpenAI's, positioning it as a lightweight alternative for decision use cases. It's worth noting that $0.10/million tokens is still at the extremely low end of the LLM API market — general-purpose models like GPT-4o typically start at $2.50+ for input. So even though the Decisions API costs 2.5× more than Jev, for high-frequency production workloads (e.g., millions of classifications per day), it remains far cheaper than using a general-purpose model for the same tasks. When evaluating options, the cost gap between "decision API vs. general LLM" should be part of the calculation — not just the differences between competing decision solutions.