What is Jev, and can AI handle routine decisions? How to test it

Jev is a decision model released on September 15, 2026, by San Francisco startup TypeSafe AI, built for judgment calls: no text, just a decision and a confidence value. Confident cases can go to the system and uncertain ones to a person. It's brand new, though, so test it on your own past decisions before deciding whether to use it.

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? Most of these calls rely on the experience of senior staff, and they get them right. As volume grows, the natural question is: could the clear-cut cases be handled automatically, so people's time goes to the ones that really need judgment? This article starts with prompts and groundwork you can use today, then explains what Jev is and how to test it.

Ask AI first

Whether or not you use Jev later, an AI assistant such as ChatGPT, Claude or Gemini can help you spell out your decisions and try them today. Swap in your own details (the examples are illustrative).

Turn your senior staff's judgment into a rules table

Every day our sales assistant decides how to handle each customer order, with four options: enter directly, sales review, credit check, or send back for missing info. Below are the rules our senior staff described. Turn them into a rules table: the condition, the option it leads to, and any exceptions. List anything unclear or contradictory separately, as questions for me. Give me a table I can paste into the Rules sheet in Excel.

Try the calls on last month's orders

Attached are 50 orders from last month (order number, customer code, item, quantity, amount; the decision we made has been removed) and the rules table from before. Using the rules, pick one of the four options for each order and mark it "confident" or "not confident," with the reason for any you're not confident about. Output a table: order number, option, confident or not, reason.

Put the AI's answers next to the decisions you actually made. Where it's wrong, it's often a case the rules don't cover yet; add it to the rules table. Don't take its own "confident" label at face value (see below for why); check whether those cases really were right more often. Before uploading, use your company's enterprise plan, or replace customer names with codes and delete unneeded columns.

4 things you can do now

Whether you end up using Jev, an LLM or plain business rules, all of this will come in handy.

1. Start logging every decision

Set up a sheet in a shared Excel workbook or Google Sheets file: date, order number or message summary, the decision made at the time, the correct outcome in the end, and who handled it. Use Data Validation to turn "decision made" into a drop-down list that matches the options in your rules table. A few months of this is the most important data you'll have for testing any model.

2. Mark what a wrong call means for each decision

A misrouted customer message just means one extra handoff. A wrongly approved refund or loosened payment terms cost real money. Label each kind of decision "low impact" or "high impact," and you'll have a basis for setting thresholds and deciding which ones keep a person's review for good.

3. Flag the clear-cut cases with simple rules

Some cases are clear, such as orders from long-standing customers where the items and prices all match. Add a formula column in Excel that checks the rules, then use conditional formatting to color the orders that need a person.

4. Prepare the questions to ask any AI service

• Where does the data go? Is it stored or used for training? Can it be self-hosted?
• Are there published evaluations for Chinese? Can we test it on our own historical data first?
• Does every answer come with a confidence value, and is that value calibrated?

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. And when an LLM says it's "quite sure," that doesn't mean it's any more likely to be right. Jev drops its result straight into the format you defined, with 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 or 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 reading orders and quotes with AI).
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.

Using confidence: set a threshold for what goes to a person

Look closely at daily processes and most steps are decisions, not writing. Which queue does this order go to? Do we approve this return? Who should handle this message? Does a manager need to see this transaction?

The hard part of automating decisions like these isn't 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 the impact you marked in step 2: for low-impact calls (sorting customer messages, say) it can be lower; for high-impact ones (approving refunds, loosening payment terms) set it high, or keep a person in the loop for good.

At high volume, speed and cost matter too. 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 for picking your first AI process. If quality inspection depends on images, a vision model has to turn them into data first; Jev then makes the call.

Where things stand, and what to watch (as of late September 2026)

• 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. Check the company's latest announcements for how to apply.
• A new company and a new model: at the time of writing, Jev had been out for less than two weeks. Its performance figures come mostly from the company, and 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.

When to consider the next step

It's worth letting a decision model take over part of the work when:

• The same kind of call gets made hundreds of times a day, and it takes longer and longer.
• You've logged a few months of decisions, and the options and rules have settled.
• You'd like clear-cut cases handled automatically so the sales assistants can focus on exceptions.

The next step: test on your own past decisions, then go live in phases

Don't take calibration on the vendor's word. Test it on your own data, using the decision log you've been keeping:

1. Gather past decisions: from your log, pick the cases where the outcome is known, with the input 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 the impact of a wrong call, 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 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. At the time of writing, we hadn't found any published evaluation from the company for Chinese.

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. Still, we wouldn't change a process because of one news story. Shadow-test first, let the numbers speak, then decide whether Jev, an LLM or plain business rules is the right fit. Early on, the manual process keeps running alongside.

If you have a process where the same call gets made hundreds of times a day, start with a free AI Health Check to see whether a decision model could handle it. You can also look at our AI adoption and integration services and our system integration services for connecting those decisions back to your ERP and LINE customer service, or just get in touch.