Jev, the AI that picks instead of writes: what it’s good for, and the catch

Posted on October 17, 2026 By Troj Leave a comment AI
The AI that picks instead of writes: a support ticket goes in, and Jev returns a pick with probabilities (Billing 91%, Technical 6%, Sales 3%) in about 0.1 seconds.

Written October 14, 2026, and fact-checked again on October 16. Jev is in early access and changing fast, so check the links at the bottom before you build on it.

Almost every AI you’ve used is a writer. You ask ChatGPT or Claude something, and it writes back: a paragraph, an email, some code.

Jev doesn’t write a single word. It’s a new model from a San Francisco startup called TypeSafe AI, released in early access on September 15, 2026. You give it some information and a few questions with fixed answers, and it gives you back numbers: which answer it picks, how likely each option is, and how sure it is.

Investors are paying attention. On October 9, less than a month after launch, TypeSafe announced it had raised $870 million at a $7.5 billion valuation (SiliconANGLE).

That sounds like a lot of money for a step backwards. But for a lot of everyday software jobs, picking is exactly what you want. Here’s what Jev is, what it means for you, what independent testers found, and the catch hiding in the phrase “can’t hallucinate”.

What Jev actually does

Picture a mailroom. A writer reads each letter and drafts a thoughtful reply. A sorting clerk glances at each letter and drops it in the right tray: bills, complaints, orders. The clerk can’t write you a reply, but they can sort a thousand letters before the writer finishes one.

Chatbots are writers. Jev is the sorting clerk.

You send Jev two things:

  • The state: whatever you want it to look at. A support ticket, an email, a product review, a chunk of JSON (a common data format).
  • The questions: what you want to know about it, each with a fixed type of answer.

There are three main kinds of question (TypeSafe docs):

Question typeWhat you askWhat you get back
Choice“Which of these is it: billing, technical or sales?”One pick, a probability for every option, and a confidence
Score“How urgent is this, on a scale?”A score, probabilities and a confidence
Noul“Is this statement true?”A number from 0 to 1: the chance it’s true

(Yes, “noul” is an odd word. It’s short for “Bernoulli”, a maths term for a yes/no chance. People on Hacker News complained that the docs didn’t explain it.)

You can ask many questions at once, and Jev answers them all in parallel, each on its own. TypeSafe’s docs say adding questions “barely changes the response time”.

TypeSafe calls this a “System One” model. The name comes from Daniel Kahneman’s book Thinking, Fast and Slow: System 1 is your fast gut reaction (“that’s a dog”), System 2 is slow, careful thinking (“what’s 17 times 24?”). Chatbots are System 2. Jev is meant to be System 1.

What a request looks like

Here’s a simplified example, following TypeSafe’s API reference. It sorts a support ticket by team and urgency. Each question has instructions (what you’re asking) and criteria (the answers it may pick from):

import requests

response = requests.post(
    "https://api.typesafe.ai/v1/systemone",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "jev-latest",
        "state": "Customer emailed twice this week about a failed refund...",
        "questions": {
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Payments, invoicing, refunds",
                    "technical": "Bugs, outages, integrations",
                    "sales": "Pricing, upgrades, new accounts",
                },
            },
            "urgency": {
                "type": "score",
                "instructions": "How urgent is this?",
                "criteria": ["Can wait", "Today", "Right now"],
            },
        },
    },
)
print(response.json())

What comes back isn’t a sentence. It’s something your program can use straight away: “billing”, a probability for each of the three trays (TypeSafe’s own example shows billing 0.88, technical 0.12, sales 0), a confidence, and an urgency score. Your code can then follow a simple rule: if Jev is very sure, act on it; if not, send it to a person.

What it’s good for

Jev fits anywhere software needs to make a quick, bounded decision, over and over:

  • Sorting and routing. Support tickets to the right team, emails to the right folder, leads to the right salesperson.
  • Yes/no checks. Is this message spam? Does this review mention a safety problem? Does this answer actually come from the document?
  • Scoring. How urgent, how positive, how risky.
  • Guardrails. Checking what a chatbot wrote before it reaches a customer.
  • Going through a big pile. Running the same question over every row of a large spreadsheet, where a cent per row would add up.

It’s not for writing anything: emails, summaries, code, explanations. It can’t produce text at all.

Is it really that fast and cheap?

TypeSafe’s claims are big: 70 to 500 milliseconds per request, 40 to 200 times faster than leading chatbot models, and a price of $0.042 per million input tokens with output free. A token is roughly three-quarters of a word, so a million tokens is a long novel or two. TypeSafe’s homepage says “193.6x faster, 444.6x cheaper” on its own workflow tests.

Those are the vendor’s numbers. Here’s what independent people found.

The most careful test so far comes from Vals.ai (published October 6, 2026). It compared Jev 1.13.0 against eleven other models, including GPT, Gemini and Claude models:

  • Speed: the claim holds up. Jev answered in about 0.1 seconds, and still about 0.12 seconds with 64 questions at once. With 32 questions, it was 194 times faster than OpenAI’s GPT-6 Astra.
  • Cost: the claim holds up too. About $0.02 per 1,000 cases, roughly 1/500th of what GPT-6 Astra cost.
  • But a cheap chatbot came close. A small model, GPT-6 Luna, matched Jev’s accuracy for $0.08 per 1,000 cases. That’s a few times Jev’s cost, but still pennies.

Everyday users see smaller gains. An analysis of nearly 13,000 launch-week posts by people trying Jev found a typical speedup of about 7 times, not 200 (InfoQ). A Vercel engineer reported a safety check running 5 to 18 times faster than the chatbot it replaced.

Both are true. The 200x figure shows up when you compare Jev with a big, slow reasoning model answering lots of questions. Compared with a small, fast chatbot doing one simple job, the gap shrinks.

What it means for you: if you swap a chatbot for Jev on a sorting job, expect something closer to 7 times faster than 200. That’s still a lot, and the cost drops a long way.

Is it accurate?

It depends on the job, and this is the part to pay attention to.

In Vals.ai’s tests:

  • Checking facts against a document (does this company report support this claim?): Jev scored 97.5%, tied with several GPT models. Claude Sonnet 5.5 did slightly better, at 99.5%.
  • Legal reasoning questions (a slice of a benchmark called LegalBench): Jev came last of twelve, at 73% against the leader’s 93%. On one set of questions it simply answered “Yes” to all 33, when the right answers were split almost half and half. Vals.ai notes this slice isn’t representative of the full benchmark.

TypeSafe is upfront about some weak spots. Its own list of known rough edges says Jev “does not count reliably”, reads dates “as text, not as ordered quantities”, and gets less accurate when you stuff the state with unrelated material. Its advice: “Jev is not a calculator”, so do the maths in your own code.

The catch: “can’t hallucinate” doesn’t mean “can’t be wrong”

TypeSafe says Jev “can’t hallucinate”. When people say a chatbot hallucinates, they mean it confidently makes something up: a fake quote, a book that doesn’t exist.

Jev really can’t do that kind of thing. It can only answer with options you gave it. Ask “billing, technical or sales?” and you will never get “banana”, or a paragraph, or a broken answer your program can’t read.

But think of a multiple-choice exam. A student can’t write nonsense on a multiple-choice paper. They can still tick the wrong box.

That’s Jev. Its answers are always valid. They’re not always right. One Hacker News commenter put it bluntly: “Type safety is not factual correctness.” Developer Armin Ronacher told TechCrunch the design “delegates the hallucination problem a little bit to the user”: you decide whether a 50% answer is good enough to act on.

That’s where Jev’s confidence numbers matter. A model is calibrated if, when it says it’s 80% sure, it’s right about 80% of the time. Then you can safely let it handle the confident cases and pass the rest to a person. Vals.ai found Jev was the best-calibrated of the twelve models on the fact-checking task, and the worst on the legal one.

What it means for you: test it on your own examples before you trust its confidence numbers.

Can it be tricked?

A security company, HiddenLayer, tested Jev in October and found that in some cases it is “even more vulnerable” than chatbots to deliberately tricky text (InfoWorld). Two examples:

  • Hidden instructions. In a fake online shop, an attacker’s ad steered a Jev-powered shopping helper into clicking away from the purchase, even though it had been told to treat page text as untrusted.
  • Misspelled words. Small, targeted changes to letters lowered Jev’s toxicity score for messages it had flagged before.

Keep in mind that HiddenLayer sells security products, and TypeSafe didn’t respond to InfoWorld. TypeSafe’s own docs do say Jev doesn’t treat the state “as hostile by default”.

What it means for you: if Jev’s answer triggers a real action (a click, a refund, a ban), anyone who can write text that Jev reads can try to steer it. Don’t let it act on text from strangers without a second check.

Things to know before you try it

  • It’s early access. TypeSafe’s own API is through console.typesafe.ai. Vercel’s AI Gateway also serves it (Vercel changelog). Other routes, like OpenRouter, appear only in third-party guides, and we couldn’t confirm them.
  • Which version? The stable model is jev-1.13.0. A new jev-1.14.0 came out on October 14 as a preview, with small improvements (mostly in languages other than English) plus experimental image input, which TypeSafe says isn’t ready for production yet (TypeSafe blog). TypeSafe says the default “jev-latest” will switch to 1.14 about a week after that.
  • The price might not last. TypeSafe itself says it can’t prove the price isn’t subsidized.
  • No explanations. Jev gives you numbers, not reasons. If you have to justify each decision, for an audit for example, that’s a problem.
  • Your data goes to TypeSafe. It’s a hosted service, not something you run on your own computer.
  • It reads a limited amount at once: 64,000 tokens per request and 32,000 per question (TypeSafe models page). That’s roughly 100 pages of text. An experimental setting raises it to 262,000, but TypeSafe says that’s slower and less accurate.

So, should you care?

If you build small automations, yes. A lot of “AI” in real apps isn’t writing at all. It’s making a quick decision: which tray, how urgent, yes or no. Using a big chatbot for that is like hiring a novelist to sort the post. Jev is a fast, cheap clerk built for that one job.

Just remember the clerk can still put a letter in the wrong tray, and someone may try to slip a fake label on the envelope. Check its work on your own examples, trust it only where it’s confident, and keep a person in the loop for the rest.

Sources

Official (primary sources)

Independent tests

News and explainers

Leave a Reply

Your email address will not be published. Required fields are marked *