Most AI models write for a living. The Jev AI model, from a company called TypeSafe, refuses to write at all.

Ask ChatGPT a question and it answers in a paragraph. Ask Jev the same question and it answers with a typed decision: a choice, a score, or a probability.

That trade sounds small. It changes what you can afford to automate. Jev skips the writing step, so it answers in about a tenth of a second. A normal AI model takes several seconds for the same call, and costs far more per answer.

Jev launched into early access on 15 September 2026. Within a week, people had shipped routers, linters, lead scorers, spreadsheets and photo pipelines on it. This guide covers what Jev is, how it works, and eighteen jobs people already gave it.

One Restriction Makes Jev Fast

Every normal AI model works the same way. It reads your prompt, then writes an answer one word at a time. Each new word depends on the words before it. That loop is slow, and that's where most of the cost comes from.

describes the same cost in a data pipeline: "The model spends seconds generating tokens, the pipeline parses the JSON, and sometimes the JSON comes back broken."

Jev skips that step. You give it two things: a state, and a set of questions. The state is the information, a message, a document, a paragraph, anything in text. The questions are what you want to know about it.

It reads the state once, then answers every question in parallel, in a single pass. It never writes a sentence, so there's no word-by-word loop to wait for.

TypeSafe calls this a System One model, after the psychologist Daniel Kahneman. In his framework, System One is your fast, gut reaction. System Two is slow, careful reasoning. A normal AI model tries to do System Two thinking in full sentences. Jev only makes System One judgment calls, and it makes them fast.

Pydantic, the Python validation library, described a call in one sentence when it added Jev support. The type you already wrote is the question, and the answer comes back as that type with one confidence per field.

learned why the type matters in production: "Without structured outputs, we had no data validation, no type checking, and no real control over how the output should look."

You Can Ask Jev Three Kinds of Questions

The three types are Choice, Score and true-or-false. You can mix all three types in one call, and every question runs against the same state at the same time.

A support message can get a Choice question asking which team should handle it, a Score question asking how upset the customer sounds, and a true-or-false question asking whether they want a refund. All three answers come back together.

Shann Holmberg wrote the shortest description of the loop I have read. You supply the information, your questions, and the allowed answers. Your own code decides what happens next.

Every Answer Comes With a Confidence Number

Every Choice and Score answer includes a confidence number, from 0 to 1. A high number means Jev found one clear answer. A low number means the options were close, or the text didn't give it enough to go on.

That number lets your software decide what happens next. A high-confidence answer can be acted on right away. A medium one can be flagged for a person to glance at. A low one can skip automation entirely and go straight to a human.

shows how to tune those cutoffs for decision models, and how "calibration can make them more useful as confidence estimates."

That distinction makes Jev usable for real decisions rather than demos. A system that can say "I am not sure" gives your code a rule to build around, instead of a guess to trust.

OrcDev put the same idea in terms of where Jev sits. Big models think slowly. The small decisions between their calls never needed to be slow.

Jev Can Cost 400 Times Less Than a Normal AI Call

A Jev call costs $0.042 for every million tokens of text you send in. A token is a small chunk of text, close to three quarters of a word. Jev's output costs nothing, because it never writes anything out.

A normal AI model charges for input and for output, and output is usually the bigger cost. The input text alone can run $0.20 to $10 per million tokens.

TypeSafe tested Jev against several AI models on four real workflows. Jev came out up to 444 times cheaper and 193 times faster on those tests. TypeSafe ran that test itself, so read it as their claim, not an independent check. Their launch post plots accuracy against cost, and Jev holds the cheap end of that line without losing much accuracy.

The rest of this guide uses other people's numbers instead.

Eighteen Jobs People Gave Jev in Its First Week

Every job below is a real build, posted publicly between 15 and 20 September 2026. I kept each person's own figures and named who ran the test, because almost nobody has checked these independently yet.

Sorting a Pile That Nobody Wants to Read

1. Classify 1,018 AI research papers for eight cents. Hassan summarized every paper with DeepSeek V4 Flash, which cost $3.99 on Together AI, a service that hosts open models. He then sent each title, each summary and 24 candidate topics to Jev. The 1,018 classifications cost $0.08 in total, at 256 milliseconds median per paper, end to end. He is still running evals before he replaces his current labels, so treat the accuracy as unproven.

2. Triage security alerts in a production pipeline. Greg Pstrucha works on AI at Sentry. He posted a table of seven models running one of Sentry's security pipelines. Jev scored 99.3% accuracy in 0.259 seconds. GPT-OSS 120B scored 96.4% in 1.821 seconds and cost three times more. Gemini 3.1 Flash-Lite matched Jev's accuracy, took 1.338 seconds, and cost fourteen times more.

3. Sort an inbox, then sort the seven queues behind it. Greg Isenberg described the job in one line. Jev reads each item and says "this is junk, I'm 94% sure". He priced 1,700 emails at 18 cents. He then listed the queues that are the same job wearing different clothes: quote forms, inbound leads, support tickets, transcript clipping, grant and permit piles, marketplace matching, and bulk browser work.

4. Catch phishing with five small questions instead of one big one. Somebody ran 2,000 phishing emails through Jev. One big question scored 89.4%, which lost to a two-line text rule at 91.8% and to Claude Haiku 4.5 at 94.2%. The same person then asked five small questions and added the answers up in his own code. That scored 95.0%, the best result in the test. Same model, same emails, different question shape.

found the opposite on research paper screening. In his test, "making Jev more sophisticated did not help". Five criterion questions scored 0.536 on WSS@95, and one question scored 0.646.

Choosing the Model Before the Model Runs

5. Route a chat to the right model on its first message. Ashley Hindle runs Fuel, which reads the opening message of a chat and decides how much intelligence that chat needs. His benchmark has 75 test cases. Against GPT-OSS-120B he measured Jev at 3 times faster, 65% cheaper and safer. A wrong route costs him twice, because a weak model on a hard problem annoys the user and raises their bill.

6. Route models inside Claude Code with one install command. Daniel San shipped the same idea as an installable mod. For every request, Jev picks the subagent model and the effort level. It picks the main model only at session start, because changing it mid-session breaks the prompt cache.

7. Pick the right skill out of a catalog of 182. TypeSafe's docs describe a test against the Hermes skill catalog from Nous Research. One Jev request ranks all 182 skills and asks whether the turn needs a skill at all. A second request reads the top three closely and can reject all of them. On Haiku 4.5, wrong skill loads fell from 17% to 7.3%. Both figures come from TypeSafe's own test.

TypeSafe's Skill suggestion page says one request ranks all 182 Hermes skills and a second reads the top three.

Screenshot from Ray Amjad's Jev video, showing TypeSafe's documentation.

8. Put Jev in front of a model you already pay for. Ronin, who posts as @DeRonin_ on X, describes one email tool that swapped two AI calls per email for a single Jev call, and kept every safety check it already had. On a 120-ticket test, the version with Jev in front finished in 42 seconds for $0.0003. The version without it took 22 minutes and cost $0.059. He is clear that retry errors inflated the slow number, so the real gap is smaller.

9. Compact an agent's context tonight. The same thread names the cheapest win available. Score every tool call in the history, drop the dead ones, and keep the survivors word for word instead of writing a lossy summary. Ronin also points at the honest limit. Somebody ran 18,514 emails through Jev with no examples and got 98.33%. A TF-IDF classifier trained on 14,800 labelled examples got 98.39%, so labelled data still wins when you have it.

Deciding Inside the Interface, While Somebody Types

10. Rank a launcher's results on every keystroke. Nader Dabit built what he calls a keystroke oracle. A normal launcher ranks by alias, fuzzy match and habit. Type "the pdf I just downloaded" into his version and the newest PDF is already the top hit, with a confidence on every keystroke, in about 100 milliseconds.

11. Turn a spreadsheet column header into a judgment. Spreadsheets recalculate numbers, never meaning. Dabit typed "Urgency" at the top of a column and the sheet rated every row from "no follow-up needed" to "urgent" as he typed, in about 100 milliseconds a row.

12. Drive a browser by voice, remember what an agent learned, predict a video's numbers. Mario Nawfal published a full build tutorial with three demos. The voice-controlled browser needs a decision per utterance, the memory layer needs one per stored fact, and the YouTube predictor scores a title before you publish it. All three break down into typed questions.

Deciding Where the Money Goes

13. Score 700 leads and their outreach messages in 40 seconds. Romàn fed Jev 700 high-intent leads together with the personalized message written for each one. It predicted how each message would perform, attached a confidence score, and flagged the leads whose message did not match them. The whole run cost $0.09.

14. Lint every comment in a repository for one cent. Ray Amjad asked Claude Code to find useless comments in his own codebase. Claude Code sent 150 comments to Jev in one run. It took 9.3 seconds, used 233,802 input tokens, had zero failures, and cost $0.00982.

Claude Code reports that Jev scored 150 comments in 9.3 seconds for $0.0098, with zero failures.

Screenshot from Ray Amjad's video.

15. Price a code smell scan across 8,270 functions. In the same session, Claude Code costed two versions of a full-repo scan. A gated pass sends about 7.5 million input tokens for $0.32 in roughly four minutes. An exhaustive pass sends 28 million for $1.19 in roughly eleven minutes.

Claude Code prices a gated scan at $0.32 in about 4 minutes and an exhaustive one at $1.19.

Screenshot from Ray Amjad's video.

Money stopped being the constraint at that price. Claude Code's own note under the table names the constraint that replaced it. A 10% false-positive rate across 8,270 functions hands you 827 bad findings, and you stop reading the report. Check that number before you trust any scan this cheap.

Wiring Jev Into Something You Already Run

16. Give a Python agent framework its answer type back. Pydantic AI agents now run on Jev. The output type an agent already declares becomes the question, and the answer arrives as that model with one confidence per field. Nothing in the agent's code has to change shape.

states the reason this matters for agents: "agents that produce validated JSON are composable."

17. Check an agent's work before a person ever sees it. Because Jev writes no prose, it invents no facts inside an explanation. That makes it a reasonable verifier for another model's output. Ask whether the answer used the source, whether the tool call matches the request, and whether a human should look. Three typed questions, one call, one price.

18. Sort four years of photos into 39 days of posts. That one is mine, and the next section is the whole build.

Jev Sorted 469 of My Photos Into 78 Carousels for 29 Cents

I ran my first real build on my own camera roll. Four years of photos sat in 54 folders grouped by feel rather than by post. One pipeline regraded, recropped, regrouped, captioned and scheduled the whole set onto Instagram, two posts a day for the next 39 days.

The run report shows 469 photos becoming 78 carousels across six stages, from contact sheets to Zernio.

Four tools each did one job. Claude Sonnet described every frame in words. Jev read those words and made every judgment. Python held the policy and ran the edits. The Zernio API published the queue. Zernio is a social media scheduling service.

The judgment layer cost $0.29. It made 5,961 typed judgments across 132 model calls, and I sorted zero photos by hand.

One judgment pass with Claude alone costs $17.40 and takes 36 minutes. The same pass with Jev underneath costs $0.14 and takes 5 minutes.

Projected to 1,000 images, each re-run of the judgment layer drops from 36 minutes to 5 with Jev.

Projected to a 1,000-image run, the first pass drops from 90 minutes to 58. Every re-run after it drops from 36 minutes to 5. Re-running is where the work actually sits, because a grouping rule is never right on the first try.

The Zernio posts view shows fourteen Instagram carousels scheduled twice a day from 20 to 27 September 2026.

Jev Is Not Built for Every Job

Jev can't write open-ended text. It won't draft an essay, an email, or a chatbot reply. If you need a model to produce free-form writing, you still need a normal AI model.

It can also be confidently wrong. TypeSafe says Jev can't output an invalid answer, only a valid one, because the shape of the answer is fixed in advance. A normal AI model can invent a fact that never existed. Jev can only pick from the options you gave it. But a valid answer can still be the wrong answer, with a high confidence number attached to it. When developers debated this on Hacker News after launch, that distinction was the most argued point in the thread.

Ronin's testing found three failure shapes worth copying into your own notes. Jev does not know what it does not know, so a question like "do you have enough information" answered yes on 85% of 120 test tickets. Option order changes answers, and reordering four options moved 7 answers out of 120. And the final verdict belongs in your code rather than in one big question, because the model is better at noticing things than at ruling on them.

There are plain practical limits too. Jev reads text only, no images or audio yet. It holds about 64,000 tokens of information in one call, smaller than several other AI models. The company is new, so its pricing and rate limits could still change as more people sign up.

Trying Jev Takes About Five Minutes

Getting access takes one of two paths.

The direct path is TypeSafe's own waitlist, at typesafe.ai. Sign up, and TypeSafe sends an API key once a spot opens. Early testers have reported getting in within a few hours.

The second path skips the waitlist. Vercel added Jev to its AI Gateway in September 2026. Anyone already building with Vercel's AI tools can call Jev through that account, with no separate signup.

Cloudflare followed on 17 September and put Jev on its own AI Gateway.

Once you have access, TypeSafe gives you a web playground. You paste in a piece of text and type a plain-language question. Then you pick a choice, a score, or a true-or-false answer. Press run, and the answer comes back in well under a second, confidence score included.

There is also a developer toolkit that plugs Jev straight into an app. Once wired in, the app can ask the question on its own, with no one typing into the playground.

Why This Price Is Low Enough to Start New Companies

A ten-times price drop changes who wins. A four-hundred-times drop changes what gets built at all. Four examples show what that buys.

1. A game bot that runs all day. TypeSafe's own demo has Jev making roughly ten decisions a second to play Doom in real time. Running that continuously costs about $7 an hour. A normal AI model, answering in full sentences at that speed, would cost far more and likely couldn't keep up with the game clock at all.

2. A chess engine priced under a thousandth of a cent. One developer wired Jev into a chess app through Vercel's AI toolkit. Jev picks a move from every legal option in about 300 milliseconds, for roughly $0.00004 a move. A full forty-move game costs less than two thousandths of a dollar.

3. Scanning everything instead of a sample. At $0.042 per million input tokens, checking a million tokens of text costs about four cents. Most systems settle for spot-checking a sample, because scanning everything used to be too expensive. That excuse is gone.

4. A guardrail in front of every action, not just the risky ones. Most AI systems today reserve a safety check for the actions that look dangerous, because running a full model on every single step costs too much. At Jev's price, the check can run in front of all of them.

None of these four needed a new company two years ago. Each needed a decision too slow or too expensive to make in real time, and TypeSafe is betting that gap just closed.

Where Jev Fits Into How I Publish

Every piece I publish goes through the same four steps. I write it, I check it against a set of rules for what good writing looks like, I fix whatever gets flagged, and only then does it go out.

Some of those checks used to be too slow to run on everything, so I read for them by hand instead. Jev is cheap enough to run every one of them, on every piece, every time. That's the first place I'm putting it, and I expect to find more as I keep building.

Jev Is an AI Model That Refuses to Write a…