Jev for non-coders: what it actually builds and where it breaks

Three of the biggest AI channels I track shipped a Jev video inside one week, and my tracker flagged all three as outliers against their own medians. A spike like that usually means the explanations are running ahead of the facts. So here is the boring version: what Jev is, what it costs, what people have built with it, and the failures TypeSafe published about its own model.

Published September 21, 2026 · By Dmitry Tolstoi · 9 min read

What is Jev, in one paragraph?

In short: Jev answers questions you wrote in advance with probabilities instead of prose, so your software can act on the answer without reading anything.

TypeSafe AI came out of stealth on 15 September 2026 with a model called Jev. The founder, Diogo Almeida, worked at OpenAI on the instruction-following research behind ChatGPT. You hand Jev a lump of text - an email, a support ticket, a row of data - plus a short list of questions. It hands back answers, each with a probability attached. It will never write you a sentence. TypeSafe's line on its homepage: "Send Jev structured questions and get typed decisions with probabilities and confidence that your software can act on."

The company calls this a "System One Model", borrowing Kahneman's split between fast instinct and slow deliberation. Chatbots do the slow half. Jev does the half where you glance at something and sort it in under a second, ten thousand times a day.

What can Jev actually answer?

In short: Choice, Score and Noul are the whole surface area, and every Jev demo you have seen is some arrangement of those three.

TypeSafe's documentation lists exactly three primitives:

• Choice: "Choose an option from a list". You supply the options, up to 255 of them, and get back the pick plus a probability for each.
• Score: "Score the state on a rubric". You define between 2 and 10 named levels, so ignore / low / medium / high / critical is a valid rubric.
• Noul: "Is this statement true?" TypeSafe's word for a yes or no. You get back the probability of yes.

That is the entire menu. Input is text only: a string, a JSON object, or an array of them. No images, no audio, no video. Vercel's integration guide puts the ceiling at 64,000 tokens per request, with 32,000 of that reserved for the material being judged.

What does it cost, and how fast is it really?

In short: $0.042 per million input tokens, output free, and an answer back inside 70 to 500 milliseconds.

OpenRouter lists typesafe/jev-1.13 at $0.042 per million input tokens and $0 per million output tokens, because there are no output tokens to bill. TypeSafe's launch post quotes end-to-end response time of "70ms-500ms" against "3 to 329 seconds" for frontier models on the same shaped work, and the homepage headline is "193.6x Faster, 444.6x Cheaper".

Read those multiples as the vendor's own benchmark on tasks the vendor chose. A live demo convinced me more. On Greg Isenberg's channel, Ryan from the Open Code team pushed 1,700 real emails through Jev on camera: 4.2 million input tokens, every message categorised, prioritised and scored for spam, and the whole run cost 18 cents. The order of magnitude is the point: work too expensive to run across your whole history is now cheap enough to run twice.

What people have built with it so far

In short: every shipped example sits in front of a queue of incoming work that a person used to sort by hand.

Riley Brown had Claude build him an inbox app, then ran 500 of his own emails through it in roughly thirteen seconds, tagging category, urgency and whether each one deserved a reply. He added one more question - is this a scam - and Jev flagged 55 of the 500. Ryan's version scores inbound leads from a design agency's contact form from 0 to 1, so serious enquiries surface first.

Past the inbox it gets more interesting. Ryan dropped a video file into a tool that transcribed it and asked Jev to find the publishable moments: 17 of them scored in about three seconds. The Browser Use team wired Jev into browser control and booked a Zurich to London flight in 7.1 seconds, a run David Ondrej priced at $0.004 end to end. TypeSafe's own demos are a Doom bot making ten decisions a second and a Wikipedia-racing agent.

One pattern joins them. Find a queue where information arrives faster than a human can sort it, and put a cheap judgement at the front. That is also the honest boundary: nothing in that list invents anything.

How does a non-coder get hands on it?

In short: there is no Jev app to sign into, so the way in is a gateway key and an agent that does the wiring.

Direct API access is still behind a waitlist at typesafe.ai. Everyone else goes through a gateway. Jev sits on the Vercel AI Gateway as typesafe-ai/jev, on OpenRouter as typesafe/jev-1.13 behind a separate decisions endpoint rather than the usual chat one, and it is listed in Cloudflare's model catalogue. There is a community node for n8n too.

The route Riley used is the one I would copy. Get a gateway key, open a coding agent, hand it the key and a link to TypeSafe's docs, and describe in plain words the thing you want scored. You are not writing code. You are writing the brief and checking the result, which is the same job as any other agent work.

Why is a clean answer still sometimes the wrong one?

In short: the zero-hallucination claim covers the shape of the answer, never its truth, and no explanation comes with it.

TypeSafe's launch chart puts Jev at 0% hallucinations, and the mechanism behind that is honest enough: the model can only return options you supplied, so a malformed answer is impossible by construction. Hacker News spent 509 comments arguing about what that does and does not buy you. The cleanest line came from a commenter posting as WhitneyLand: Type safety is not factual correctness. Another, thduabmd, made it concrete: An approve for an unauthorized action still meets the schema guarantee.

Almeida answered in the thread himself, under the handle CompleteSkeptic, with a fair counter: would you say a linear classifier hallucinates? Jev will never hand your code a field it cannot read. It will happily route a technical ticket to billing with a confident 0.91 beside it, and your validation layer will wave that through, because the answer is perfectly well formed.

Worse, there is nothing to interrogate afterwards. A chat model at least tells you why it decided something. Jev returns a probability and no reasoning, so a wrong decision leaves you only the question you wrote and the material you fed it. The confidence number will not rescue you either. TypeSafe's own guidance is blunt about whose problem it is: "Start with conservative thresholds, test with your own data, and adjust as you observe results." That work lands on you, not on the vendor.

What does TypeSafe say its own model gets wrong?

In short: the vendor ships a page listing the tasks its own model fails, and half of them look trivial from the outside.

This is the part of the launch I respect. TypeSafe maintains a model jaggedness page for jev-1.13 that reads like a bug list written by the vendor. The entries that bite an operator first:

• Arithmetic. Jev is "not a calculator", and the docs say "we strongly recommend implementing any mathematical logic in code". No totals, no percentages, no margins.
• Counting. It "does not count reliably", including occurrences of a term in a passage and items in a long list.
• Dates. It "reads dates as text, not as ordered quantities". Which invoice is overdue, how far apart two events are, whether something falls inside a window: all unreliable.
• Score precision. The score levels are "weak in numerical calibration", so a 7-out-of-10 is a label, not a measurement you can do maths on.
• Literal reading. It "answers the question you wrote, not the one you meant". Negations and implied conditions are taken at face value.
• Noisy input. "Accuracy falls as the state grows with content unrelated to the decision." Pasting the whole customer record in case it helps makes the answer worse, not safer.

Two live signals sit alongside that list. Ryan hooked Jev up to a buy-hold-sell signal on camera, watched it do badly, and said on the spot he would not put this model in front of a portfolio. And RLCD, the training method TypeSafe credits for the calibration, has no published paper yet, which several readers in that thread named as the weakest part of the pitch.

The one-evening test before you build on it

In short: label a hundred rows by hand, let Jev label the same hundred, and count the disagreements before you wire it to anything live.

Here is the run I would do, with a gateway key and one evening.

1. Pick one queue you already sort by hand. Inbox, contact form, support tickets, applications. Something where you can say what a right answer looks like without thinking hard.
2. Label 100 real items yourself first. Before the model sees anything. Everybody skips this step, and it is the only thing that turns the rest into a measurement.
3. Write each question the way a stranger would read it. One scoped thing per question, read back literally, because literal is how it gets answered.
4. Run the same 100 items through Jev and count the disagreements. All of them, not a sample. Where it was wrong, check whether your question was ambiguous before blaming the model.
5. Find the probability where the errors live. Sort your results by the number Jev returned. Mistakes usually cluster at the low end, and your cut-off becomes obvious from your own data.
6. Route, do not decide. Above that cut-off goes to automatic handling, below it comes to you. Keep everything irreversible - money, deletions, replies to real people - on the human side for the first month.

If the evening ends with Jev disagreeing on 3 items out of 100, in a queue where a mistake costs a minute, it is a sound buy at these prices. If it disagrees on 20, or the mistakes are scattered evenly across every probability, the queue is not a classification problem and no amount of rewording will make it one. Learning that costs well under a dollar. The discipline is the same whether you run one model or a whole team of agents: measure on your own data, and treat the demo as advertising.

Where this comes from

Prices, latency, token limits and the list of failure modes are TypeSafe's own published figures, linked where cited and checked the week this was written. Gateway availability and model identifiers come from Vercel, OpenRouter and Cloudflare directly. The Hacker News quotes are from the launch thread, attributed to the handles that wrote them. The demo figures - 1,700 emails for 18 cents, 500 emails in thirteen seconds, 7.1 seconds to book a flight - are what the creators showed on camera, reported as their claims, not my measurements. The view counts behind this article's premise are my own tracker's: it pulls public YouTube counts for eight channels over a 21-day window and compares each video's views per day against that channel's median. The Jev videos from Greg Isenberg, David Ondrej and Riley Brown came in at 3.6x, 3.3x and 4.2x their channel medians in the same week. I have not put Jev into production, and nothing here is a promise about your results.