Let's Talk
← All writingPublished October 15, 2026

Jev vs Decisions API, and the open-source models that make the same decisions

AI modelsDecision models
On this page

A decision API is a model that doesn't chat or write, it just makes split-second decisions, picking from answers you give it and saying how sure it is. If your business pays for AI, Jev is the cheaper choice when the decision is made on text, OpenAI's Decisions API is the one to use when it has to look at an image, and an open model such as Clef or Laya is the one to run when your data can't leave your own servers.

Diagram of one customer email decided three ways, sent off to Jev at TypeSafe or the Decisions API at OpenAI on their servers, or kept on your own servers and decided by an open model such as Clef, Laya or Von, each route ending in the same answerTHEIR SERVERSYOUR SERVERSEMAILJEVTYPESAFETEXTDECISIONS APIOPENAITEXT AND IMAGESOPEN MODELCLEF, LAYA, VONRUN BY YOUANSWERNEEDS A HUMANAUTO
FIG_001

What Jev and the Decisions API do#

A startup called TypeSafe launched a model called Jev in early access on 15 September 2026, and they say it's over 400 times cheaper and 100 times faster than the big AI models. You send it some text and a question with fixed answers, like which customer email needs a human or which lead is worth chasing, and it sends back the answer with a probability for every option. It takes three kinds of question, a yes or no question it calls a Noul, a Choice between up to 255 options, and a Score against a scale you set.

TypeSafe's launch post, Introducing System One Models & Jev, dated 15 September 2026

OpenAI noticed fast. Just two weeks later, at DevDay on 29 September, they launched their own version, the Decisions API, in limited preview, and opened it to every developer in public beta on 6 October. It runs on GPT-6 Luna and takes the same three kinds of question under its own names, Predicates, Choices and Scores. The first difference you'll notice is that it reads images, which Jev does only behind an experimental flag.

OpenAI's DevDay 2026 announcements on its developer forum, saying the Decisions API is in limited preview and uses Luna to classify inputs, route requests or choose an action from predefined answers
JevDecisions API
Input, per million tokens$0.042$0.10
OutputFreeFree
ReadsText, images experimentalText and images
QuestionsNoul, Choice, ScorePredicate, Choice, Score
Access on 15 OctoberEarly accessPublic beta
Your dataLicence to derive Telemetry, in perpetuityKept up to 30 days, zero retention if eligible

What one decision costs#

Both charge only for input, and the question and its options count as input on every call. A customer email of about 500 tokens costs around $0.00002 to decide on Jev and $0.00005 on the Decisions API, so a million of them comes to roughly $21 against $50. One developer on OpenAI's forum ran the same questions through both and found the Decisions API cost two to three times as much.

How each side's numbers were measured#

The published speeds don't line up, because nobody measured them the same way.

  • TypeSafe got its 444.6 times cheaper and 193.6 times faster from four workflows its own team built, with the chat models run through its own wrapper, and says those figures sit at the higher end of what you'll see. Its 70 to 500 milliseconds was timed from its laptops on the West Coast.
  • OpenAI says the Decisions API is up to 10 times faster than GPT-6 Luna through its ordinary Responses API, which compares OpenAI with OpenAI. The 150 milliseconds in most coverage comes from a DevDay slide.
  • OpenRouter serves both, so its numbers are the closest thing to a fair test. Its median is 0.11 seconds for Jev 1.13, 0.20 for the new Jev 1.14 and 0.17 for the Decisions API.
  • Developers who timed Jev themselves got medians between 0.24 and 0.32 seconds, and an analysis of 12,759 launch posts by OpenChamber, reported by InfoQ, put the speedups users reported at a median of 7 times and their cost savings at 30.

Both answer in a fraction of a second, and neither company has published a test against the other.

What the forum found#

On OpenAI's developer forum, one developer ran a few hundred questions through both. On simple yes or no checks they came out about level, and on questions that needed judgment Luna gave about three times as many confident wrong answers as Jev.

Another found that Choice questions pile too much probability onto the likeliest answer. For a coin weighted to land heads 70 percent of the time, the Predicate format said about 70 and the Choice format said 98. Moving one option from first to last took it from 86 percent to 73, and TypeSafe's own documentation says Jev 1.13 leans toward the option that comes first too. If you need the probability to mean something, ask yes or no questions.

What happens to the data you send#

TypeSafe's customer agreement says it won't train models on your data without your consent, and Jev's answers are yours. The same section gives TypeSafe a licence, in perpetuity, to derive what it calls Telemetry from everything you send, including logs, summary statistics, classifications and learnings, which it may use without restriction to improve its service. That licence carries on after your contract ends.

OpenAI doesn't train on API data unless you opt in, keeps it for up to 30 days to check for abuse, and offers zero retention on eligible endpoints to customers who qualify. If your emails hold anything private, read both before you send the first one.

The copying claim#

Nandakishor Mukkunnoth, the founder of ConvAI Innovations, alleges that the ideas behind Jev's design came first in a paper on a model called SalesRLAgent, published on arXiv in March 2025 with its weights and data. Nobody has shown that TypeSafe used that work, and TypeSafe hasn't answered in public.

Other options, open source included#

  • Microsoft-Decision-1 came out on 9 October, built on Alibaba's open Qwen3.5-9B, priced the same as Jev and in public preview on Microsoft Foundry.
  • Clef and Clef-flash, from Cloudflare, came out on 1 October with their weights published under Apache 2.0. They answer Jev's API, so code written for Jev can switch over, and Clef reads images.
  • Laya is Mukkunnoth's own model, under Apache 2.0. It's small enough for a laptop, has a version for other languages and answers Jev's API, and its README warns that it's overconfident as shipped.
  • Kev, by Jared Palmer, under Apache 2.0, runs from 0.8 to 27 billion parameters, and TypeSafe's own SDK works against it unchanged. On its own tests the largest is level with Jev on everyday questions and well behind on harder reasoning.
  • Von, under Apache 2.0, runs on a plain CPU, answers Jev's API and reads English only. Its own benchmark puts it well below Jev, and faster.

The community projects are about four weeks old, and every score above is the project's own. Running one means you run the server, and every email stays with you.

So which one should you be using?#

If the decision is made on text and volume is what costs you, start with Jev. If it has to see a screenshot, a product photo or a scanned form, use the Decisions API and ask it yes or no questions. If your data can't leave your servers, run Clef or Laya yourself. Whichever you pick, call it through your own code so you can swap it later, because four of these launched inside a month.

My team and I built Aiden on OpenAI's Assistants API while it was still in beta, and when OpenAI deprecated it, we moved Aiden onto the Responses API. If you're choosing a model for something of your own, tell me what you're building.

Sources#