Vercel put Jev behind a classifier that decides which commands are safe to run. It came back 5 to 18 times faster than OpenAI’s Luna 5.6, and more accurate.

Bryo AI pointed it at business email. Ten to twenty times cheaper than Gemini, a bit less accurate, but every answer arrived with a confidence score that Gemini never gave them.

Neither of those is a text generation task. That is the whole story.

A model that does not write

Jev came out of TypeSafe AI this week, built by Diogo Almeida, who worked on ChatGPT and RLHF at OpenAI before leaving. It takes the state of your program plus a question, and it returns one option from a list you defined, with a probability attached. Yes at 0.73. Category B at 0.41. That is the entire output surface.

It cannot hallucinate a category, because the categories are yours.

Pricing on TypeSafe’s own page is the part people keep screenshotting. Input is metered by the billion tokens at 42 dollars. Output is not metered at all. They claim 238x lower input pricing than Claude Fable 5.1, and their demo finishes a workflow in 0.114 seconds where a language model takes 8.566.

Almeida’s line in the TechCrunch piece is the one worth keeping. We have lightning in a bottle, he says, and it still is not useful, because computers speak a different language.

Confidence scores are an engineering primitive

Here is what nobody budgets for when they wire a language model into a queue.

The model classifies every ticket in exactly the same confident voice. “This is a complaint.” It never tells you whether that was obvious or whether it flipped a coin between two similar labels. So your code has no lever. You either escalate everything to a human, in which case you automated nothing, or you escalate nothing and eventually one expensive case slips through.

Armin Ronacher put the practical version of this in the TechCrunch story. The caller has to be able to say: if this only comes back at 50 percent, I disregard it.

That sentence is a threshold, an escalation rule and an audit trail, all at once. It is the difference between a flow you can operate and a flow you have to babysit.

We argued a version of this before in price per token lies. Jev takes it to the limit. When output is free, price per output token stops being a number you can even compare on.

Where it fits in a stack that already runs AI

Not in the customer-facing chat. That job needs language.

One layer down is where it earns its place:

• model routing, deciding whether a query deserves the expensive model at all
• inbound classification of email, tickets and documents
• safety gates that vet an agent’s command before execution
• live agent monitoring, catching a jailbreak attempt while it is happening

If you already run agents in production, that last one pays for itself faster than the other three combined.

What it will not do

It does not draft. It does not summarize. It does not reason across steps. It does not replace your frontier model.

It is the other half.

The architecture that makes sense here runs at two speeds. Something cheap and fast for the thousands of small calls, and the expensive model only when you genuinely need prose or multi-step reasoning. We laid out that ordering in the pyramid before the agent, and a new model does not change it.

One caution. Jev is in early access. A classifier that changes vendors halfway through the year is a new dependency, not one fewer.

Start with the invoice, not the model

Pull last month’s API billing and split the calls into two columns.

Column one: calls where what your code consumed was a paragraph. Column two: calls where what it consumed was a label, a number or a yes. Column two is your candidate list, and in most stacks it is fatter than anyone expects, because the invoice arrives aggregated and nobody opens it.

That split is where we start when we review an operation’s AI spend. Two columns first. Model selection second.

Let’s split your invoice into those two columns