By Assaf Biton
On September 15, 2026, a startup called TypeSafe AI came out of stealth with $40 million in seed funding and released its first model, Jev, in early access. If you have heard that Jev is not an LLM and wondered what that means in practice, here is the short version: you give Jev some data and a fixed menu of possible answers, and it picks one, gives a score, or says yes or no, along with a number that says how confident it is. It never writes a sentence. This guide explains which everyday software jobs fit that shape, where TypeSafe itself says Jev goes wrong, and why you should get it from typesafe.ai rather than a look-alike site.
Jev in one sentence
TypeSafe describes Jev as the first of what it calls System One models: a new class of model built to make fast, structured decisions that other software can use directly, without a person reading the result. The name is a nod to the Jevons Paradox, according to the company's launch press release.
Two design choices separate it from chatbots like ChatGPT:
- The possible answers are fixed in advance. You define the options, the scale or the yes/no question before you ask. Jev returns a typed value that fits that structure, never free-form text. TypeSafe states plainly that Jev gives up text generation in exchange for being optimized for structured outputs.
- All the answers come back at once. A chatbot builds its reply one small piece (token) at a time. Jev produces every output for a request in a single pass, as TypeSafe describes it and as The Register independently summarized the architecture.
The analogy I find most useful: a chatbot is a writer composing an answer word by word. Jev is a multiple-choice exam taker who fills in every bubble at the same time and writes down how sure it is about each one.
The three kinds of question Jev answers
TypeSafe's API documentation builds everything from three question types. Your input data is called the state; each thing you ask about it is a question.
| Question type | What it does | Plain-language example |
|---|---|---|
| Choice | Picks one option from a list you supply | "Is this message about billing, shipping or a bug?" |
| Score | Rates the state against a rubric you define | "How urgent is this request on our scale?" |
| Noul | Gives the probability, from 0 to 1, that a statement is true | "This review contains a personal attack: true or false?" |
The examples in the right-hand column are my own illustrations, not taken from TypeSafe. According to the docs, you can mix all three types in one API call, and each question is evaluated separately and in parallel against the same input. So a single request can route a message, rate its urgency and flag abuse at the same time.
Everyday jobs that fit this shape
TypeSafe's own list of intended uses is short: classify, route, score, extract or branch in places where hand-written rules are too brittle, plus turning very large datasets into features and insights. In everyday software terms, that covers jobs like these. They are illustrative examples of the shape, not tasks I have run on Jev.
| Job | Question type | What you define in advance |
|---|---|---|
| Support-ticket routing | Choice | The list of teams or queues a ticket can go to |
| Content moderation gate | Noul | The statement to check, such as "this post breaks rule X", and the confidence level at which a person takes over |
| Lead scoring | Score | The rubric that describes a strong, medium or weak lead |
| A "smart if-statement" in code | Noul or Choice | The branch condition that is too fuzzy for a keyword rule, such as "the customer is asking to cancel" |
| Bulk tagging of a large dataset | Several questions mixed in one call | The tags or labels each record can receive |
The common thread is that the answer feeds straight into software. Nobody needs to read a paragraph; the program needs a label, a number or a yes/no to act on.
The launch demo pushes the same idea into games. TypeSafe showed Jev making decisions in Doom, and The Register reported that the demo on TypeSafe's site shows Jev responding in 0.114 seconds against 8.566 seconds for OpenAI's GPT-5.6 Terra. Two caveats: this is a vendor demo, not an independent test, and TypeSafe says the game is fed to Jev as a structured description of the game state with text, not as screen images.
What does not fit
Anything where the output is writing. Summaries, email drafts, chat replies, translations and code generation all need a model that produces text, and Jev by design does not. If your task ends with a person reading prose, a conventional LLM is still the tool.
Speed and price, as TypeSafe tells it
Speed and cost are the main selling points, and every figure below comes from TypeSafe. None of the independent sources I reviewed report their own measurements of Jev's speed, cost or accuracy.
- Latency: TypeSafe's launch blog puts end-to-end response time at 70 to 500 milliseconds. The press release claims under 100 milliseconds. I give more weight to the blog's range because it is the more detailed document and states its scope.
- Speed versus LLMs: the blog claims 40x to 200x faster for questions that fit the System One shape.
- Headline multipliers: the homepage figures of 193.6x faster and 444.6x cheaper come, per the blog, from TypeSafe's own workflow evaluations against the average of GPT-6 Astra and Fable 5.1.
- Price: $0.042 per million input tokens, with output tokens free, according to the official blog.
Free output fits the design: Jev returns a label or a number, not a long reply, so almost all of the cost is in the data you send.
"Zero hallucinations" means something narrower than it sounds
The TypeSafe homepage advertises zero hallucinations and ties that promise to confidence estimates: every decision comes with one, so your software can act when confidence is high and hand off to a person when it is not. The Register pointed out that structured output does not rule out being incorrect.
Both statements hold. Because the answers are fixed in advance, Jev cannot invent a new category, a fake citation or an answer outside the menu. It can still pick the wrong item from the menu. Treat the confidence number as the safety mechanism, and decide in advance what your software does when it is low.
Where TypeSafe says Jev fails
TypeSafe publishes an unusually direct limitations page for the current version, jev-1.13. It describes the model as fast, calibrated and good at common-sense judgment, but not perfect, and lists these weak spots:
- It reads you literally. Jev answers the question you actually wrote, not the one you meant. Vague wording in a question produces answers to the vague question.
- It does not count reliably. A question like "does this order contain more than three items?" is a poor fit. Count in your own code and pass the result in.
- It treats dates as text. Jev does not understand dates as ordered quantities, so "is this invoice overdue?" is risky. Compare dates in code first.
- Irrelevant detail distracts it. Unrelated information in the input can pull the answer off course, and a large input makes it harder to tell what caused a wrong answer. Send only what the question needs.
- Adversarial text can steer it. Injected instructions, misleading framing or text that argues for its own classification can move the answer. That matters most for moderation and anything else that reads text written by strangers.
The practical pattern across the list: let ordinary code handle arithmetic, counting and dates, and give Jev the judgment calls that rules cannot capture.
Use typesafe.ai, not the look-alike site
A site at jevtypesafeai.com sells access to Jev. Its own pricing-page footer says it is an independent platform, not affiliated with or endorsed by TypeSafe AI, and operated by CODEFASHION TECH LTD. It lists input prices of $0.25 to $0.42 per million tokens, roughly 6 to 10 times TypeSafe's official $0.042. The official site is typesafe.ai, with documentation at docs.typesafe.ai.
Before you enter payment details or an API key anywhere, check that the domain is typesafe.ai.
Who is behind it
TypeSafe's CEO is Diogo Almeida, a former OpenAI researcher whom The Register describes as one of the co-inventors of reinforcement learning from human feedback (RLHF, a training technique used to make chat models follow instructions) and of ChatGPT. The $40 million seed round was led by the venture firm DCVC, according to the press release.
Before you rely on it
Jev launched ten days ago through a waitlist-based early access program. Flavio Copes, a developer who published an early explainer on Jev, writes about having console access but not yet putting Jev into production. I have not tested Jev myself. The sources I reviewed also do not document regional availability or how well Jev handles non-English input such as Hebrew, so check both before planning around it.
If you build in Python, the Pydantic AI framework already has a TypeSafe integration, installed with:
pip install "pydantic-ai-slim[typesafe]"The Pydantic documentation also gives the most useful advice I found: measure accuracy, the hand-off rate and any confidence threshold on labelled examples of your own before relying on them.
My recommendation: pick one narrow decision your software already makes with brittle rules or a slow LLM call, such as ticket routing. Collect a batch of real examples where you know the right answer, run them through Jev, and compare its accuracy and hand-off rate with what you have now. Keep counting and date logic in your own code, and set a confidence threshold below which a person decides. If the numbers hold on your data, the speed and price TypeSafe advertises start to matter. If they do not, the vendor's multipliers will not change that.
