Jev explained: the AI model that returns decisions, not text

Every morning, a sales assistant opens the inbox to a string of small judgment calls. Can this order go straight into the system, or should the sales rep look at it first? Should this customer's payment terms get another review? Is this message on LINE (the messaging app most Taiwanese customers use) a quote request, a chase for a late delivery, or a complaint? Each call takes a few seconds, but a few hundred a day add up to hours, and most of them rely on the experience of senior staff.

Over the past two years, plenty of companies have tried handing these calls to large language models (LLMs). They can make the call, but they write a paragraph first, and your code has to dig the answer out of the text. And when an LLM says it's "quite sure," that doesn't mean it's any more likely to be right.

On September 15, 2026, San Francisco startup TypeSafe AI released Jev, which takes a different approach: no text, just a decision and a confidence value. Here's what it is, what it's good for, how it works alongside LLMs, and how to test it if you want to try it.

What is Jev? An AI model that doesn't talk

Jev is TypeSafe AI's first model. The company was founded in 2024; its CEO, Diogo Almeida, worked on RLHF, InstructGPT and ChatGPT at OpenAI. On September 15 the company came out of stealth with a US$40 million seed round led by the venture firm DCVC and launched Jev in limited early access (SiliconANGLE).

TypeSafe calls this kind of model a System One model (see the launch post). The name borrows from psychologist Daniel Kahneman's "System 1," fast and intuitive judgment, as opposed to the slow, deliberate reasoning of "System 2." The name Jev comes from the economist William Stanley Jevons, of the Jevons paradox: when something gets cheaper, people end up using far more of it.

Using it is simple. You hand it a "state" (a customer message, or an order as JSON data) along with a few questions you've defined in advance. It answers all of them in a single call, every answer comes back as a typed value your code can use directly, and it only picks from the options you gave it. There are three kinds of question:

How is it different from asking an LLM?

An LLM generates text one token at a time. To use one for a decision, you typically tell it to "answer only A, B, C or D" and then write code to parse the reply. Longer answers are slower, and the cost scales with the output. Jev drops its result straight into the format you defined, so there's nothing to parse and no answer outside your list.

On speed and cost, TypeSafe claims that on the decision-type tasks it picked, Jev is roughly two orders of magnitude faster and cheaper than frontier LLMs, and that on four workflow tests it built itself, the gap reached about 193x faster and 445x cheaper (Tom's Hardware). Keep in mind that these are the company's own numbers. TypeSafe's launch post itself says the test workflows were built by its own team, may be biased, and probably sit at the high end of real-world gains. Forbes reports that early tests show clear speed and cost advantages, with slightly lower accuracy than the largest models.

Where you still need an LLM

Jev doesn't write replies or summaries, and it doesn't do open-ended, multi-step reasoning. Its input is text or structured data, so it doesn't look at PDFs or photos directly. That work still belongs to LLMs and AI agents. A realistic setup looks like this:

1. An LLM reads: it pulls the fields out of a customer's PDF order or message (see AI that reads orders and quotes).
2. Jev decides: which route this order takes, and whether a person needs to see it.
3. Your systems act: write to the ERP, notify the sales rep, or add it to the review queue.

Why confidence is the key to automation

Look closely at a company's daily processes and you'll find that most steps are decisions, not writing. Which queue does this order go to? Do we approve this return? What kind of message is this, and who should handle it? Is this transaction an exception that a manager needs to see?

The hard part of automating decisions like these has never been producing an answer. It's knowing which answers you can safely leave to the system. That's what calibration means: when a well-calibrated model says "0.8," it's right about 80% of the time across many similar decisions. TypeSafe says it trains Jev with a method called RLCD (Reinforcement Learning for Calibrated Decisions), aimed at making the probabilities honest, though in an interview on Latent Space it was noted that the method hasn't been published in detail.

With confidence you can trust, you can set a threshold: anything above it is handled automatically, anything below it goes to a person. MarkTechPost's coding guide walks through exactly this confidence-gated routing pattern. Where you set the threshold depends on what a mistake costs:

• Cheap mistakes: sorting customer messages, say. A wrong call just means one extra handoff, so the threshold can be lower.
• Expensive mistakes: approving refunds or loosening payment terms. A wrong call costs real money, so set the threshold high, or keep a person in the loop permanently.

At high volume, speed and cost start to matter too. With thousands of messages or orders a day, waiting for an LLM to generate text for each one, and paying for that generation, adds up fast. TypeSafe quotes response times of 70 to 500 milliseconds per call, and launch pricing of US$0.042 per million input tokens with no charge for output (the company's figures, which may change during early access).

How traditional businesses could use it (illustrative scenarios)

These are illustrative scenarios we put together, not real client cases:

What they share: the options can be spelled out in advance, the volume is high, and mistakes can be caught and fixed. Those are the same criteria we suggest in our guide to picking your first AI project. If quality inspection depends on images, a vision model has to turn them into data first; Jev then makes the call.

Test it on your own past decisions first

Don't take calibration on the vendor's word. Test it on your own data. Here's how we'd go about it:

1. Gather past decisions: pick one process and collect cases from the past few months where the outcome is known, including the input data at the time and the correct answer.
2. Check accuracy and calibration: group Jev's answers by confidence and see how often each group was actually right. If the "0.9 and above" group is only right 70% of the time, it isn't calibrated for your business.
3. Run in shadow mode: at first, let Jev make its calls on the side without acting on them while people work as usual, and compare the two every week.
4. Set the threshold: based on what errors cost, pick a cutoff where both the automation rate and the errors that slip through are acceptable.
5. Keep monitoring: track the automation rate and how often people overturn Jev, spot-check automated decisions regularly, and re-test when you add a product line or a new kind of customer.

You can summarize the results in a table like this (numbers are illustrative):

One more point for companies working in Chinese or other non-English languages: test with your own data in that language. As of this writing, we haven't found any published evaluation from the company for Chinese.

Where things stand, and what to watch

• Still early access, and access keeps changing: Jev launched with a waitlist. About a week later the company opened sign-ups to everyone, then soon paused new sign-ups because demand was too high. Whether you can get in, and on what terms, is still in flux.
• A new company and a new model: Jev has been out for less than two weeks. Its performance figures come mostly from the company, and large-scale independent validation is still thin.
• Read "no hallucinations" carefully: it can't return an answer outside your options, but it can still pick the wrong one, and its confidence can still be too high. Forbes also notes that prompt injection remains a risk: a customer's message could contain text meant to steer the decision.
• Your data goes to the cloud: Jev is currently available through TypeSafe's cloud API, with no self-hosted version. Before sending it personal or confidential data, check the contract and data-processing terms.
• Keep it swappable: build "input in, options plus confidence out" as a separate step in your workflow, so you can later switch to another model or to plain rules without rewriting the whole process.

How studiox sees it

We've been following this category of decision models closely. In the order-automation workflow shown on the studiox homepage, the routing node is Jev: AI reads the order first, Jev decides which path it takes, and only when it isn't confident does it go to a person. The value of that split is simple: people's time goes to the cases that actually need judgment.

That said, we wouldn't change a process because of one news story. A steadier sequence is to find a high-volume decision with clear options, shadow-test it on historical data, let the numbers speak, and then decide whether Jev, an LLM or plain business rules is the right fit.

If you have a process where the same call gets made hundreds of times a day and you want to know whether a decision model could handle it, take a look at our AI adoption and integration services. Connecting those decisions back to your ERP, LINE customer service and other existing systems falls under our system integration services. Or just get in touch.