On this page
Last Updated: September 19, 2026
Jev is a decision model from TypeSafe AI that answers typed questions instead of writing text, and in its first week of early access builders used it to triage 1,700 emails for 18 cents, scan a website for AI slop in 243 milliseconds at $0.00015 per check, and drive a browser agent that solved 100 percent of benchmark tasks at 112x lower model cost than a frontier route. The architectural difference from a text-output LLM is simple. An LLM generates a string token by token and you parse it. Jev scores every answer option you define in one parallel pass and returns a typed answer with probabilities. Input costs $0.042 per million tokens, outputs are free, and responses land in 70 to 500 milliseconds according to TypeSafe's launch materials. Here is where that shape wins, where it loses, and how to tell which side your workflow sits on.
What is Jev?
Jev is TypeSafe AI's first System One model, named for the fast intuitive thinking in Kahneman's Thinking, Fast and Slow. You send a state, meaning any text or JSON payload, plus typed questions whose answer spaces you define in advance. Jev returns one of three primitives: Choice picks one of up to 255 options, Score places something on a rubric of 2 to 10 concrete levels, and Noul returns a calibrated yes or no probability. The current release is jev-1.13.0 behind the jev-latest alias, served by a single endpoint, POST /v1/systemone, with a 64K token request budget and text-only input. According to TypeSafe's documentation, there is no fine-tuning. You shape answers by putting your records and rules in the state and writing better question instructions, and the same weights serve every account.
How is Jev different from a text-output LLM?
The difference is generation versus scoring. A text-output LLM runs an autoregressive loop, predicting one token at a time with each conditioned on the last, then your code parses the string and hopes it validates. Jev never generates. It scores all predefined answer options in a single parallel pass, so there is no output bill, no parsing step, and no possibility of an off-schema answer. TypeSafe reports 70 to 500 millisecond end-to-end latency versus 3 to 329 seconds for frontier models on System One shaped tasks. The cost of that speed: Jev cannot write a single word, and calibration is honest uncertainty, not a guarantee of correctness.
Two structural details matter for builders. First, fan-out: questions in one request are evaluated independently against the same state, so adding a question never changes earlier answers through conversational bleed, and every question rides the same single state ingestion. Second, confidence: Choice and Score return a full probability distribution plus a derived confidence value, so a routing decision sees billing at 0.58 with technical still plausible at 0.37, not a bare guess. That is what makes threshold-based automation possible.
| Dimension | Text-output LLM | Jev |
|---|---|---|
| Output | Any string, parsed afterward | Choice, Score or Noul, schema-valid by design |
| Latency | 3 to 329 seconds reported | 70 to 500 milliseconds reported |
| Pricing | Input plus output tokens, output often 5x input | $0.042 per million input tokens, outputs free |
| Failure mode | Malformed output, hallucinated content | Wrong answer with a confident probability |
| Best at | Writing, reasoning, code, conversation | Classify, score, route, gate, rank at volume |
| Cannot do | Guarantee valid structure | Generate any text, including tool arguments |
What did people actually build in week one?
Real builds beat spec sheets, and the first days of early access produced numbers, not slides. A browser agent built with Browser Use found flights in 7 seconds for $0.0039. An ad teardown analyzed 724 live ads from 37 brands in 40 seconds for 9 cents. A lead-scoring run evaluated 700 high-intent leads with personalized message matching in 40 seconds for $0.09. A slop detector checked a URL against 35 tells of AI-generated design in 243 milliseconds. Every build shares one shape: a high volume of narrow judgments where the text LLM generation loop was the bottleneck.
- Archive analysis: 3,282 posts, 4,252,330 tokens, $0.1282 total, 8 minutes 34 seconds, with 8 questions per post
- Virality scoring: 61 questions per post answered in roughly 1 second for $0.0004, trained on 9,481 posts from 207 creators
- Voice-controlled browsing: transcript to action in about 300 milliseconds at $0.0002 per decision, faster than the user finished speaking
- Browser benchmark: Jev plus a small LLM for arguments solved 49 of 49 WebMCP tasks, where Jev alone solved 25 of 49
- Blitz chess: Jev answered in roughly 2.6 seconds per move while a frontier model spent 6 to 15 seconds and lost on time
"How-to posts got 150 median likes versus the average median of 44," says Ian Nuttall, an indie developer who ran his full posting archive through Jev to find what actually drives growth. That is the quiet headline of week one: when a decision costs a fraction of a cent, you stop sampling and start scoring everything.
The 12 use cases that fit Jev today
Nearly everything shipped in week one reduces to twelve patterns across four verbs. Classify: support ticket routing, content moderation triage, email triage, and application piles for grants, claims and job applications. Score: fraud tier risk, lead quality, content slop and quality, and dynamic pricing signals. Route: LLM autorouting and model selection, A/B and feature-flag decisions, and voice-agent turn-taking. Rank: recommendation re-ranking, candidate selection, and link or option choice of the Wikiracing kind, where picking a valid option is the whole game. Each maps to Choice, Score or Noul plus a confidence threshold that keeps humans on the uncertain tail.
According to explainx.ai's use case analysis, the shared signature is a fixed answer set, high volume, and latency that a generation loop cannot meet. TypeSafe's own docs call this the use case map: what kind of thing is this goes to Choice, is property X present goes to Noul, where does this sit on a scale goes to Score, and which code path should handle this goes to Choice with a confidence gate.
How do you design a Jev workflow?
One state, many questions, and code owns the combination. Pack every independent question into a single request, because Jev ingests the state once and scores all questions in parallel. Combine answers in ordinary code where thresholds and weights stay auditable and testable. For lead intake: budget signal as Noul, urgency as Score, best message as Choice, then your code weights them into one routing decision. If a question genuinely depends on another answer, that dependency becomes a second request with the new state, not conversational context.
The result is what TypeSafe calls a smart if-statement. Traditional code escalates when amount exceeds 10,000. A Jev-powered workflow escalates when a semantic judgment, such as safeguarding risk exceeding 0.95, says so. The threshold, the audit log and the side effects all stay in your software.
Where does Jev lose to a text LLM?
Four hard limits. First, no generation: Jev cannot write tool arguments, replies or summaries, which is exactly why the winning browser setups pair it with a small LLM for text. Second, multi-step reasoning: TypeSafe's own documentation acknowledges weaker accuracy when a question needs several chained reasoning steps, so decompose instead of hoping. Third, no vision, audio or video input: screenshot understanding and image moderation are outside its shape today. Fourth, confident wrongness: calibration means probabilities are honest in aggregate, not that any single answer is right.
An independent poker evaluation published at backnotprop.com makes the point with money on the line. Across 30 solver-checked spots Jev matched the optimal action 63 percent of the time. Then the trap: holding the best possible straight on a board where no flush existed, Jev shoved four times the pot sixteen times out of sixteen, and when the turn card changed to put a made flush on board, it still shoved five runs out of five, even after the evaluator added the opponent's literal hole cards to the state. Only when state engineering spelled out "hero is currently behind" and "zero outs" did it check. "TypeSafe skipped published evals in this release, and I think that will produce a lot of naive deployments," the evaluation's author writes. The lesson is not to avoid Jev. It is to engineer the state, test the failure modes, and keep thresholds conservative.
Jev decides, the LLM writes
The production pattern layers both models. In the automation stacks we build at Flowtivity for growing businesses, roughly ten decision calls run for every one generation call, and that 10 to 1 ratio is where all the latency and cost live. Jev takes the judgment layer: route, gate, verify, score. The LLM writes only when something genuinely needs writing, and one Jev call can decide whether the expensive call happens at all. Our published cost model put a 40,000-decisions-per-month intake workflow at $1.34 a month on Jev pricing versus roughly $900 on a frontier model, and we audited every launch claim in our previous Jev teardown at flowtivity.ai/blog/jev-typesafe-ai-decision-model.
The WebMCP browser benchmark is the pattern's proof: Jev chose which tool to call, Mercury 2.5 generated the arguments at over 1,000 tokens per second, and the pair solved 100 percent of tasks at 112x lower model cost than GPT-6 Astra with computer use. Jev is not a smaller LLM. It is the router, gatekeeper and scorer sitting in front of one.
Should you put Jev in production today?
Prototype yes, blind trust no. Jev remains early access with rate limits TypeSafe says are adjusting dynamically, English-first accuracy with weaker performance in other languages, no published architecture paper, and version aliases that can shift calibration, so pin jev-1.13.0 rather than jev-latest when thresholds matter. Access paths now include the TypeSafe API and SDKs, the Vercel AI Gateway as typesafe-ai/jev, and Cloudflare Workers AI as typesafe/jev. The correct move costs nothing: port one routing workflow, run it beside your current LLM calls, and measure accuracy, latency and cost on your own data before you let it branch anything that matters.
Disclosure: Flowtivity has no relationship with TypeSafe AI. Figures come from TypeSafe's published documentation and launch materials, the madewithjev.com build tracker, explainx.ai's use case analysis, and independent evaluations cited inline. Week-one build numbers are self-reported by their builders. Our cost model uses published prices and our own client workflow volumes, not a live benchmark.
One email a month, no noise
Practical AI notes for Australian businesses. Unsubscribe anytime.
