The Jev model writes no text and TypeSafe won't say how

TypeSafe Jev is a decision model. You send it one block of state plus typed questions, and it hands back probabilities and a confidence score instead of text. Input costs $0.042 per million tokens, output is free, and answers arrive in roughly 100 to 500 milliseconds.

What is TypeSafe Jev and what does it return?

You get one answer per typed question, sent against one block of state. Jev still reads plain language on the way in. What changes is the way out: the answer comes back as a typed value your code uses directly, and that value is a probability, a number you can test against a threshold.

The launch post describes three question types, and that is the whole vocabulary:

• Noul: is this true? Returns a probability between 0 and 1.
• Choice: pick one of up to 255 options. Returns the pick plus a probability for every option.
• Score: rate against ordered levels. Returns a score plus a probability per level.

All the questions run in parallel inside one request, each judged in isolation against the same shared state.

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient(model="jev-1.13")

result = client.system_one(
    {"ticket": ticket_text},
    {
        "refund": Noul(instructions="Is the customer asking for a refund?"),
        "team": Choice(options=["billing", "shipping", "engineering"]),
        "mood": Score(levels=["calm", "annoyed", "furious"]),
    },
)

Every answer also carries a confidence value, separate from the probability. TypeSafe suggests you act on the high-confidence answers, review the middle band, and send the low end to a person.

The name comes from William Stanley Jevons, the economist behind the paradox that cheaper things get used more. TypeSafe AI left stealth with $40M in seed funding led by DCVC, and CEO Diogo Almeida co-invented RLHF and ChatGPT at OpenAI. The launch post says outright that Jev cannot generate text. When people want a normal model to return a clean typed value today, they reach for constrained decoding or a schema-validated client like Instructor .

How fast and how cheap TypeSafe Jev is

The launch claims 70ms to 500ms end to end, plus 40x to 200x faster and 40x to 400x cheaper than frontier models on what TypeSafe calls System One tasks. The demo figure everyone quotes is 0.114 seconds against 8.566 seconds, and $0.000081 against $0.013880.

The models page lists the price you will pay: $42 per billion input tokens, which works out to $0.042 per million, with output tokens free. TypeSafe says that is 238 times cheaper on input than Claude Fable 5.1.

A request tops out at 64k tokens, with 32k for the state plus the longest question. Rate limits are 250,000 tokens per second and 1,200 requests per minute, and the docs warn that those numbers can change without notice. Jev handles text only and cannot be fine-tuned. Every account gets the same weights, so you steer it through the state and the wording of your questions.

TypeSafe’s own workflow evals aggregate four workflows:

Jev ties Sonnet 5 on accuracy at roughly 1/300th of the cost and 1/200th of the latency.

Per task, Jev comes second best on customer service at 76.0%, and worst on invoice processing at 61.8% against Sol’s 79.1%. It slips wherever numbers are involved. The reference answers in that table are the average of two other models at high thinking settings, not human labels. TypeSafe says so itself, and flags that its own team wrote the workflows.

Direct access is still early access, yet resellers appeared within a day. The Vercel AI Gateway changelog lists it as typesafe-ai/jev, and OpenRouter carries it behind a separate alpha decisions endpoint. Jev does not fit the OpenAI-shaped request format everyone else copies, so both had to build a new endpoint type inside a week. That is a bigger commitment than any repo count. Readers weighing price per decision may want the DeepSeek V4-Pro price breakdown for comparison.

But can it play Doom?

The internet’s standard test for any new piece of hardware is whether it runs Doom. People have got the game running on pregnancy tests, ATMs and a John Deere tractor. Jev flips the question, because it runs nothing at all. TypeSafe made it play instead. In the launch post, the game feeds Jev its state as structured text, enemy positions, health and ammo, and Jev picks a control action about ten times a second. TypeSafe puts that at roughly $7 an hour.

It never sees a pixel. It reads a table of what surrounds the player, which is also why it reacts to a demon standing behind a wall.

What Jev is bad at, in TypeSafe’s own words

TypeSafe also documents where Jev breaks. Its Jev 1.13 jaggedness page names nine ways the model fails, each with a fix.

On numbers the docs are blunt: “Jev is not a calculator.” Two phrasings of one question can also disagree outright. Asked whether a customer wanted a refund on the same ticket, a Noul returned 0.22 while a yes/no Choice returned 0.01 for yes and 0.99 for no. Ask a question and its negation as two separate Nouls, and the two probabilities summed to 1.19.

Someone outside TypeSafe hit the same problem. jev-decision-bench ran 49 tasks over 8,200 items and found that a question and its opposite missed a clean 1.0 by about 0.3 on average. The same run found that with roughly 100 long documents in one request, Jev handed high relevance scores to several unrelated documents.

Extract with Jev, compute in code. Keep counting, arithmetic and date comparison on your side. Do not carry a threshold tuned on one question type over to another, because the model makes no promise that they agree. Over on Reddit, u/dopple-copter answered someone praising Jev’s accuracy in the r/ArtificialInteligence forum by pointing at TypeSafe’s own docs, which admit it struggles with lateral thinking and anything numeric.

TypeSafe published no model card for Jev

Jev has no model card, no paper and no published parameter count. The architecture description stops at “a new architecture, a parallel sampler, and RLCD”, and the training corpus is described only as “synthetic”. TypeSafe ships no weights, which rules out self-hosting, and publishes no licence. RLCD stands for Reinforcement Learning for Calibrated Decisions, which TypeSafe describes as tuning probabilities against outcomes rather than human preference. That recipe is not published either.

Every other AI lab runs its models through the same set of public tests and publishes the scores, so you can line the models up side by side. TypeSafe published none, and it says why. In antibenchmaxxing , the company argues that labs tune their models to win those tests, which ruins the tests for everyone, so it would rather post nothing than a wall of numbers showing it wins. Any scores it does publish later will carry a date and be retired straight away, so nobody can train against them. There is something to that. It also means nobody outside the company can check the model. On Hacker News, jceg put the other side bluntly : they would publish the scores if the scores were good.

The page listing Jev’s nine failure modes, from the section above, is more use to an engineer than another leaderboard row. It still does not replace a model card.

One researcher reconstructed the rest by probing the API more than 10,000 times. Jev’s architecture unmasked deduces a causal transformer with sparse mixture-of-experts, one shared state encoding, isolated question branches and direct probability readouts, at roughly 10B active parameters. Treat that as one person’s reading of the outside of a black box. Calibration error came to 0.0313 on 1,200 MMLU-Pro items, and position changed the result a lot: accuracy on a reference card ran about 50% when the card came first or in the middle, and about 88% when it came last.

With no weights and no paper, you cannot self-host or audit the model, pin a version you own, or confirm that today’s price is unsubsidised. Everything you build depends on one company’s API. u/HelloMyNameIsAmanda asked in r/LocalLLaMA whether there is any reason to believe this is more than a logit-probability wrapper on a fine-tuned open model.

Can Jev hallucinate?

Jev’s output is a value from a set you defined, so it cannot emit an invalid type or an option you never offered. That 0% figure describes schema matching, and TypeSafe calls it theoretical rather than measured. A wrong-but-valid answer routes a billing ticket to engineering just as badly as a made-up one would. The defences people build for hallucinations in production are aimed at a wider problem than this one.

The launch thread on Hacker News drew 1,917 points and 503 comments, and Almeida spent the day in the replies as CompleteSkeptic. The original title read “Jev: New frontier model 40-400x cheaper and 20-200x faster”, and it changed within the hour after commenters objected to “frontier model”.

Commenters kept pointing at the same hole. An answer that fits the options you gave is not the same as an answer that is right. Jev can still approve a payment nobody authorised, or send a billing question to the engineering team. Almeida answered that the same is true of any machine learning model, and asked whether anyone would say a linear classifier hallucinates.

A valid answer is not a correct one. That point lands against TypeSafe. Almeida’s reply is about the other option. If you want an ordinary chatbot to return data your code can read, you stop it from writing anything that would break the format. Almeida says that hides the real problem. A model about to write something broken has misunderstood the question, and blocking one word does not fix that. He would rather it stop with an error than hand you a neat answer you go on to believe.

Jev got 3,000 new GitHub repos in five days

In the five days after launch, developers created 3,056 new GitHub repositories mentioning “jev”. None of them existed before the announcement, and 2,357 carry “jev” in the repo name. At least eight separate “awesome-jev” lists exist, several created on the same day. Making a list of projects and calling it “awesome” is a common trick to get a repo noticed fast. It takes an afternoon to write and it borrows attention from whatever people are already searching for. The trick is now so overused that it works less and less.

The API is one endpoint, three question types and a JSON body, which a developer can wrap in an afternoon. That is why the count is a thousand thin wrappers around a dozen real applications. That count leaves out forks, of which there are another 3,107. What it does include is a lot of “awesome” lists, thin SDK wrappers and one-file experiments.

The five projects that show what Jev is for

All five use Jev the same way. Their code runs the loop and asks Jev one small question each time round: which action, which file, keep or drop, which model next.

jev-ultrafast , a browser controller, has 9.9k stars. Jev picks the operation and the target element from an indexed table, and a small LLM writes text only when the operation is “type text”. It books Google Flights from Zurich to London in 7.073 seconds. The author ran that comparison only three times, and says himself that is too few to prove the speed gain.

fast-jev-compaction has 4.5k stars and replaces Claude Code’s compaction summary. Every tool call gets two yes/no questions, stale ones get dropped, and everything kept stays verbatim. A file path or an exact error is never rewritten into a lossy summary.

jev-trader has 1.4k stars. It makes one buy or sell decision per Monad block, roughly every 300ms, against a live order book. It shows what “fast enough for a real-time loop” means in practice, though it says nothing about trading edge.

tax-doc-classifier handles bulk classification. It has 280 stars and sends one request per PDF page, returning a probability over 261 IRS forms. It reports 100% strict accuracy, counting a wrong answer or a confidence below 0.95 as errors, at about $0.001 per page. That is 34 times cheaper and 6 times faster than the pipeline it replaced. No model was trained: the classifier is a JSON file of form descriptions.

pg-jev has 225 stars. The PostgreSQL extension lets you ask your tables questions in plain language, so a Jev judgment becomes a column value you can put in a WHERE clause. A DuckDB version exists too. It is the most un-LLM-shaped project of the bunch, since it puts the model inside a query planner instead of a chat loop.

The rest is demos: model routers for Claude Code, a simulated drone flying with Jev in the loop at 2.5Hz, agents playing Doom from structured state rather than pixels. The reviewer’s summary of the shape: big model, then Jev, then code, then Jev, then tool, then Jev, then big model.

Jev open model alternatives

The day after launch, someone asked on r/LocalLLaMA whether an open implementation existed. A working one was posted in the same thread.

• SemIf , formerly OpenJev, has 2.1k stars. It reads typed option probabilities straight out of an open model and runs on a 3090 at home.
• Laya has 2k stars. It is a 421M model with a 35ms forward pass, trained on a single RTX 6000 Pro on 25,000 human-annotated examples. Weights are on Hugging Face under Apache-2.0.
• NanoJev has 1.2k stars and ships 0.6B weights, the dataset and the whole training pipeline.
• kev has 680 stars. It is a LoRA adapter and readout head on Qwen, and it speaks TypeSafe’s own API, so the official SDK works against a local server after one changed base URL.

These copy the interface, not the model. One of them tested itself against Jev on six public sets and lost on five. They are free and they run on your own hardware, so you can find out whether the idea suits your problem before joining any waitlist.

Which leaves an open question. If the method were easy to copy with open weights, publishing a paper would hand the whole thing away. That would explain the silence better than anything TypeSafe has said about benchmarks. Whether the gap holds, or the open models close it in a few months, we will find out.

What Reddit thinks about TypeSafe Jev

Reddit is split. The AI-optimist corners took to it straight away. The subreddits that argue about models for a living were far colder, and the most upvoted reply to one enthusiastic post called the whole launch astroturf:

The same charge repeats in r/LocalLLaMA and r/LLMDevs, where the launch posts read like ads to a lot of people. Nobody has produced evidence of paid posting, so it stays unproven.

The technical objection has more behind it. Jev is a zero-shot classifier with classification heads, and GLiNER-family models have done the same job for years. Defenders answer that Jev needs no per-task training, accepts label spaces written in plain language at request time, and answers in under 300ms through one API.

The hands-on reports carry numbers:

Others report a 70% to 80% cost cut on a high-volume conversation-analysis job, and an agent made almost twice as fast and cheap by swapping routing and a few tool calls. One person dropped intent classification from 400ms to 40ms using the open Laya model instead.

Some in the same thread call Jev unimpressive on its own and better used as a tool an LLM reaches for. Others note that with cheap input caching, small models already come in under Jev when many calls reuse the same instructions.

Should you build on TypeSafe Jev?

Put Jev where the decision is small, the answer space is fixed and the volume is high: routing, triage, filtering, reranking, gating a tool call, scoring a rubric. Then follow five rules:

1. Keep arithmetic, counting, dates and anything numeric in your own code.
2. Write each question to mean exactly what it says, because the model answers the words.
3. Send only the fields the question needs, since accuracy falls as irrelevant state grows.
4. Treat confidence as a routing signal rather than a correctness proof.
5. Do not assume a Noul and a Choice asking the same thing will agree. They do not.

The risks: closed weights, no licence, no self-hosting, an early-access waitlist, rate limits the docs say can change without notice, and a price nobody outside the company can confirm is unsubsidised. If your product comes to depend on Jev, you have exactly one supplier. The open alternatives take the same kind of request, so keep all your Jev calls behind one small wrapper of your own and switching later is a quick job.

Speed is the smaller half of what Jev does. Returning a decision instead of a sentence deletes an entire class of parsing and repair code from the middle of your system, and that idea is now open and reproducible. Whether TypeSafe owns it in a year is a separate question from whether you should use the shape of it today. A model card, a paper, published weights, or an eval TypeSafe did not design would each move the answer.