The Next Big AI Model Can't Write a Single Sentence

Look at the AI calls in most production apps and you'll notice something: a lot of them aren't writing anything.

They're deciding. Is this ticket urgent? Which team owns it? Is this input spam? Is this draft ready to ship?

For each of those, we send the input to a full chat model, ask it nicely to reply in JSON, parse the answer, and hope it stuck to the format. It works, but it's slow, expensive, and a bit silly when all you needed was one word.

That's the gap Jev is built for.

TL;DR

• Jev is the first model from TypeSafe AI. It doesn't generate text. It returns typed decisions with probabilities.
• Think of it as an if statement that understands meaning.
• Every question in a request runs in parallel, in roughly 70 to 500 ms, for $0.042 per million input tokens. Output is free.
• "Can't hallucinate" means it can't answer outside your options. It can still be wrong.

What Jev is

TypeSafe AI was founded by Diogo Almeida, a former OpenAI researcher and co-author of the InstructGPT paper behind ChatGPT. They call Jev a System One model, after Kahneman's Thinking, Fast and Slow: fast, intuitive judgment instead of long reasoning chains.

You send it a state (the input to judge) and a set of questions, each with the answers you'll accept. It returns one typed answer per question:

Type	What you're asking	What you get back
Noul	Is this true?	A "yes" probability from 0 to 1
Choice	Which of these options?	Top option, full distribution, confidence
Score	Where on this scale?	Position on a scale you describe, plus confidence

No prose. No "Certainly! Here's your classification."

The if statement that understands meaning

Normal code branches on things it can compute. It breaks the moment the condition is a judgment call:

if (message.toLowerCase().includes('refund')) {
  routeTo('billing')
}

This catches "I want a refund" and misses "I got billed again after cancelling." You keep adding keywords until nobody wants to touch the rule.

Jev reads the whole message and tells you how sure it is. Your code still makes the final call.

What a call looks like

Using the JavaScript SDK (npm install @typesafe-ai/sdk, Node 20+, server-side only):

import { choice, noul, score, TypeSafeClient } from '@typesafe-ai/sdk'

const client = new TypeSafeClient() // reads TYPESAFE_API_KEY

const message =
  "Got billed again even though I cancelled last week. Kinda annoyed, can someone sort this out?"

const { answers } = await client.systemOne({
  state: { message },
  questions: {
    team: choice('Which team should handle `message`?', {
      billing: 'Charges, invoices, refunds, cancellations',
      technical: 'Bugs, errors, login or integration problems',
      sales: 'Pricing questions, upgrades, new accounts',
      other: null,
    }),
    unwanted_charge: noul('Does `message` complain about a charge the customer did not expect?'),
    frustration: score('How frustrated is the author of `message`?', [
      'Calm, just reporting something',
      'Annoyed but polite',
      'Angry or threatening to cancel',
    ]),
  },
})

const { team, unwanted_charge, frustration } = answers

if (team.confidence < 0.6) return sendToHuman(message)

if (team.choice === 'billing' && unwanted_charge.noul > 0.8) {
  return openBillingCase(message, {
    priority: frustration.score > 1.5 ? 'high' : 'normal',
  })
}

return routeTo(team.choice, message)

team.choice can only ever be one of the four labels you defined, and in TypeScript it's typed that way. All three questions run in one call. And notice I asked about an "unexpected charge," not "a refund," because Jev reads questions literally and the customer never asked for one.

Two habits worth building

Use confidence as a dial. TypeSafe trained Jev to be calibrated: when it says 90%, it should be right about 90% of the time. So act automatically on high confidence, ask for confirmation in the middle, and send low confidence to a human. Set the thresholds based on what a wrong answer costs.

Ask everything at once. Questions run in parallel against the same input, and each extra one only costs its own tokens. Ask every question you might need up front and let your code pick which answers to use. TypeSafe calls this "speculative fan-out."

Where it fits

• Devs: request routing, picking the cheap vs. expensive model, guardrails before an agent runs a shell command, "is this task done?" checks, log triage.
• SaaS founders: ticket triage, lead scoring, churn signals in feedback, spam and abuse moderation.
• Content teams: does this draft follow our style rules, does the headline match the post, which topic cluster does this belong to.

The pattern: an LLM writes, Jev checks and sorts, your code decides.

Where it breaks

TypeSafe publishes its own list of failure modes, which I appreciate:

• A Choice always returns a valid option. It can still be the wrong one.
• It answers the question you wrote, not the one you meant.
• No math, counting or dates. Do those in code.
• Noisy input hurts accuracy, and adversarial text can nudge it.
• Text only, and it can't write.

About the numbers

The headline is up to 194x faster and 445x cheaper than frontier models. That comes from TypeSafe's own evaluations, and they say it's the high end, so treat it as a ceiling. The pricing is easy to sanity-check though: 100,000 tickets at about 500 tokens each is 50M tokens, or roughly $2.10.

What really matters is cost per correctly handled task. Retries and extra human review eat into the savings.

Fun detail: the name comes from William Stanley Jevons, whose paradox says that when something gets cheaper, we use far more of it. TypeSafe's bet is that once a decision costs a fraction of a cent, you'll start putting one everywhere.

How to start

1. Pick one decision you currently handle with a keyword rule or regex that keeps breaking.
2. Try it in the TypeSafe Playground with your own data.
3. Run Jev in shadow mode next to your current logic for a week or two.
4. Tune questions and thresholds, then automate only the low-risk path.

At the time of writing, TypeSafe has paused new signups due to demand, but Jev is also available through Vercel's AI Gateway as typesafe-ai/jev.

The bigger picture

I don't think Jev replaces the models we already use. I think it takes over the dozens of tiny decisions we've been awkwardly handing to them.

What's one decision in your app that you're still solving with a keyword rule, or a full LLM call, that really just needs a yes or no?