Jev, the AI built to make decisions

An AI you can't actually talk to

Since September 15, one AI model has taken over developer conversations. The day it launched, its announcement post racked up 1,930 points and 507 comments on Hacker News, the forum where these people gather. TechCrunch reports its service briefly buckled under the demand and stopped responding.

Its defining trait: you can't talk to it. It won't write you a sentence, let alone a line of code. Ask it an open-ended question and it simply won't engage. It only answers closed questions, and it answers them by making a choice. This isn't a weaker ChatGPT. It's a different species of thing.

It's called Jev, and it comes from TypeSafe AI, a San Francisco lab founded in 2024 by Diogo Almeida, a former OpenAI researcher and co-author of the InstructGPT paper that paved the way for ChatGPT. The lab came out of stealth that same day with 40 million dollars in seed funding, led by DCVC according to its press release.

The question is why a mute model has developers this excited. To answer that, you need to look at what they're building right now.

What people mean by an agent

Over the past two years, AI's job description has changed. It's no longer just answering questions, it's doing things. That's what an agent is: software handed a whole task, working through the steps on its own, without anyone holding its hand.

Take one example, and we'll stick with it. A customer emails support: for three days, their Stripe connection has been failing, the tool that collects their payments is down, and they're losing sales.

A human used to read that message, judge how urgent it was, route it to the right team, check the account history, and decide whether a refund was owed. An agent now runs that same routine on its own, and stops to ask a human only when it isn't confident.

A chain of decisions, not an essay

Look closely at that routine and it's nothing but decisions. Complaint or technical question? Urgent or not? Is this customer actually asking for a refund? Confident enough to act alone, or does someone need to be woken up?

None of those questions calls for writing. They call for choosing. Check a box, assign a score, say yes or no.

And yet we hand them to a model built to write. At every step, we ask a ChatGPT or one of its cousins, it drafts a response, and since software can't read prose, we then ask it to squeeze that answer into a format a machine can parse. We check the format holds up, and try again when it doesn't.

Every small choice ends up costing the price and the time of a full essay. We're handing someone a term paper when all we wanted was a checkbox ticked.

What Jev actually does

Jev flips the problem around. You feed it a situation (here, the customer's message and the state of their account) and ask it closed questions. It can only return three kinds of answers.

A pick from a list written in advance: billing, technical, or account management. A score on a scale you've defined: customer calm, annoyed, or furious. A yes or no: are they asking for a refund? Every question gets handled in one pass, in a single move.

Crucially, every answer arrives with a number: the probability it's correct. Not a confident tone, an actual figure. That lets the software act on its own when the number is high and hand off when it's low, with a stricter bar the harder an action would be to undo.

Tools already existed to force a chatty model into a tidy answer. They guarantee the shape of the response, not how much you should trust it. Between a form filled out neatly and one signed with a shaking hand, the box gets checked either way.

What it's actually for

Anything that sorts. Routing an email to the right team, scoring a moderation report, spotting one piece of information in a text against a known list.

A trickier use case has come up from early adopters: watching another model. Having a second ChatGPT check a first one's work is expensive, and plenty of teams skip it. Doing that with Jev, priced at 42 dollars per billion input tokens and free on output, changes the arithmetic.

Why it's taking off

Three things are stacking up: a former OpenAI name behind it, the anti-chatbot storyline landing in a year of chatbot fatigue, and eye-catching numbers.

That last part is where you need to slow down. The homepage claims 193.6 times faster and 444.6 times cheaper. The funding announcement, published the same day, claims up to 100 times. One product, two numbers, depending on the audience.

And on the page where the company details its methodology, the "correct" answer isn't a real-world ground truth: it's the average of two rival models' answers, across four cases the company's own team built. TypeSafe isn't measuring how right it is. It's measuring how much it agrees with its competitors.

The only third-party measurements are more modest, and worth keeping separate. A Vercel engineer, quoted by TechCrunch, swapped a ChatGPT-based sorter for Jev and clocked it at 5 to 18 times faster. Bryo AI's CTO benchmarked it against Gemini on email sorting: 10 to 20 times cheaper, but Gemini was slightly more accurate.

What the company itself says about its model

TypeSafe publishes a page listing nine known flaws in its current version, and it's the most useful reading in the whole story. Jev takes questions literally, can't count reliably, reads dates as plain text, and has no knowledge of the world.

Two examples from that documentation say more than any disclaimer could. On one ticket, the refund question returns 0.22 phrased one way and 0.01 phrased another. On a second, "refund" scores 0.72 and its opposite scores 0.47, 1.19 combined. Probabilities aren't supposed to add up like that.

One limitation matters a lot outside the US: English is the primary training language, and the documentation itself admits other languages are handled less well. All of this ships in early access, with no independent benchmarking behind it.

The missing piece for agents, real or hype?

The ecosystem moved fast, at least in gestures. Vercel plugged Jev into its gateway on September 16. LangChain, the toolkit many agents are built with, shipped a dedicated package and wrote that Jev isn't a replacement for the chatty model but its complement: free-form text for open-ended reasoning, Jev for decisions along the way. LlamaIndex, Pydantic AI, and LiteLLM followed within five days.

There's still an obstacle, and TypeSafe's own documentation names it: Jev doesn't treat what it reads with any suspicion. An instruction buried inside a piece of text can shift its answer. And an agent reads exactly the content it doesn't control: a web page, an inbound email, another model's output. The component you'd want to install as a safety check is fragile precisely where you'd want to install it.

The verdict lands in two parts. It's solid when the decision is closed and the input is controlled: sorting an internal queue, scoring a case file, choosing which model handles a request. It's premature anywhere the agent reads content from outside. Tellingly, the most advanced integrations are still labeled "experimental."

A decision can be confident and wrong

The pitch repeated most often: Jev can't make things up. That's true in a narrow sense: it will never return an answer outside the list it was given. But as one developer put it, following the format isn't the same as being right. A model forced to choose between "billing" and "technical" will always pick one, even when the correct answer was neither.

The documentation says as much itself. These probabilities are reliable when checked across large batches of answers, and that says nothing about whether any single answer, taken on its own, is correct. Almeida admits as much himself: it's still possible to be confidently wrong.

The risk doesn't disappear, it just changes shape. It no longer looks like a made-up sentence you can spot at a glance. It looks like a tidy 0.94 sitting in a variable, headed straight into the rest of the program.