What Is Jev? TypeSafe AI's Decision Model, Read Against Our Router Bill

In February we measured our routing agent and found it cost 300ms and 1,200 tokens on every request, and produced nothing the user ever saw. We took it out and wrote up the bill.

This week a company called TypeSafe AI released a model whose entire job is the part we removed. It is called Jev, and it only makes decisions. So the obvious question for us, and for anyone who read the router article and nodded, is whether a model built to decide changes the answer.

Short version: it does not put the router back. It does change what a decision costs, and that opens a few doors we had closed for price reasons.

What Jev is: TypeSafe AI's first System One model

Jev is not a language model. TypeSafe calls it a System One model, after the fast, automatic mode of thought in Daniel Kahneman's Thinking, Fast and Slow. An LLM is the slow, deliberate System Two. Jev is the reflex.

You give it two things: your data, which the API calls state, and a set of fixed questions about that data. It answers every question at once and returns a probability for each answer. It never writes a sentence.

1state: a customer email, a code diff, a page snapshot, a chat turn
2    │
3    ▼
4┌────────────────────────────────────────────┐
5│  JEV                                       │
6│  "Is this a refund request?"     yes 0.93  │
7│  "Which team owns it?"           billing   │
8│  "How frustrated is the sender?" 4 of 5    │
9└────────────────────────────────────────────┘
10    │
11    ▼
12your code branches on the answers

TypeSafe's launch film races the two side by side on the same support ticket. Jev answers 27 questions about it, as probabilities, in 0.114 seconds for $0.000081. The language model on the right is still waiting for its first token.

The company was founded by Diogo Almeida, who worked at OpenAI on the instruction-following research that became the basis for ChatGPT. The launch post claims 70ms to 500ms end to end and 40x to 200x faster than frontier LLMs on the same classification tasks. Pricing is $0.042 per million input tokens, and output is free, because there is no output to meter. It went into early access this week with a waitlist, and Vercel added it to the AI Gateway on 16 September as typesafe-ai/jev, so you can try it on an existing Vercel plan without waiting.

The three questions Jev answers: noul, choice and score

Every request is built from three primitives. The names are TypeSafe's.

Each primitive takes optional criteria, a small rubric that pins down the boundary: what counts as billing versus technical, what a 4 out of 5 looks like. The docs are firm that Jev answers the question you wrote, so the rubric is where the work goes.

The JavaScript SDK is @typesafe-ai/sdk. The minimal call, from the docs:

1import { choice, TypeSafeClient } from "@typesafe-ai/sdk";
2
3const client = new TypeSafeClient();
4
5const response = await client.systemOne({
6  state: { document: "I was charged twice. Please fix this ASAP." },
7  questions: {
8    category: choice("What is this ticket about?", {
9      billing: null,
10      technical: null,
11      other: null,
12    }),
13  },
14});
15
16console.log(response.answers.category.choice); // "billing"

The answer object is typed from the questions you asked. There is no schema to coerce, no JSON to parse, no try/catch around a response that came back truncated or with an invented property. If you have shipped structured output from an LLM in production, you know why that sentence matters. TypeSafe's own benchmark puts a number on it: a structured output error rate of zero for Jev, against a range from under one percent to over twelve for the language models it was measured beside. The zero is by construction, since there is no free text to break. The other bars are TypeSafe's measurements, not ours.

The limits are plain: 64k tokens per request, 32k of it for state, text only. No images yet.

Why Jev does not put our router back

Our router was a language model call that read the conversation and emitted a label. It was the supervisor in the routing pattern we ran before going single-agent. It cost 300ms because a small model call still carries a 400-token system prompt, 300 tokens of history and a 200-token reply to parse. It cost 1,200 tokens because the specialist then needed the same history again. It was right 87% of the time, and every miss cost a second round trip.

Jev changes two of those three numbers and leaves the third alone.

Latency. 70ms to 500ms overlaps our 300ms. On a good day Jev is faster than the router was. On a bad day it is not. Either way it is a round trip in front of the answer, and the whole point of removing the router was that a round trip whose only output is a label is a round trip the user waits for and never sees. For a person asking one question and waiting for one answer, that argument still holds.

Cost. This one moves. At $0.042 per million input tokens, a 1,000-token classification costs four hundredths of a cent. Our router cost about $0.002 a query. Jev at the same volume is roughly fifty times cheaper on tokens, and the output side is free. The Hiring Cafe founder posted a resume-to-job-posting classifier that came in ten times cheaper than the small LLMs he compared it to, and someone classified a thousand research papers for eight cents.

TypeSafe's own chart makes the same point at the scale of a whole workflow. Every other model sits in a band between a tenth of a cent and ten cents per workflow. Jev sits alone at the far left, near three hundredths of a cent, at the same height on the accuracy axis as the frontier models.

Accuracy. Unknown for our traffic, because we have not run it on our traffic. TypeSafe's benchmarks show it matching frontier models on System One tasks, and its own jaggedness page lists where it does not. We will publish our numbers when the waitlist lets us in.

So the router stays out. A decision made inside the same call that writes the answer is still free in wall-clock terms, and Jev cannot beat free.

Where Jev fits in a single-agent stack

The router was one decision, made before the answer, on every request. That is the shape Jev is worst suited to in an agent that talks to a person, because latency stacks. But we make a lot of other decisions, and most of them are made today by either a heuristic or an LLM call we would rather not pay for. Those are the doors.

Loading skills on demand. We went single-agent, and the way one agent stays sane with dozens of marketing skills is that it loads a handful per request. Right now relevance selection is code and embeddings. A single choice over the skill list, with criteria describing each skill, is exactly the question Jev was built for, and keeping the loaded set small is what keeps the main model accurate. This one we will try first.

Guardrails in the same call. "Is this a jailbreak attempt?" "Does this need a human?" "Is the user angry?" are three nouls. Ask them alongside the skill choice, in one request, and they cost nothing extra in wall-clock time because every question in a request runs in parallel. TypeSafe has a cookbook for LLM guardrails and another for citation checking, which is how the Syntax podcast plans to use it: have an LLM write the episode summary, then run every claim past Jev against the transcript.

Confidence-gated escalation. Every answer carries a calibrated confidence. TypeSafe's routing pattern suggests a floor of 0.6 below which you hand off to a person, and 0.85 before a high-stakes action goes through unconfirmed. We have wanted an "I am not sure, let me check" path for a while and never had a number to hang it on. Now there is one.

Sorting retrieval before it reaches context. Our RAG problems were about which passages reach the model. A score over each candidate passage, run in one batched call, is a re-ranker that costs pennies. TypeSafe ships a cookbook for exactly this.

Batch classification. Anything we currently classify with an LLM in a background job: content type, brand-voice fit, intent on inbound email. The video shows a personal inbox being sorted for priority, spam and reply-needed in real time. At these prices the question stops being whether to classify and becomes what to classify.

The thread through all five: code keeps the control flow, Jev makes the judgment, and the LLM shows up only where a person needs generated text. That is TypeSafe's own framing, and it is the same conclusion we reached from the other direction when we stopped letting agents decide who should answer.

Where TypeSafe says Jev fails

TypeSafe publishes a jaggedness page for Jev 1.13, reviewed 17 September, and it is more honest than most launch material. Read it before you build.

• It reads dates as text, not as ordered quantities. Do not ask it which of two dates is later.
• It is unreliable at counting and numeric precision. Hex colour values in particular.
• Double negatives and multi-hop reasoning trip it. If the answer needs two steps, it is a System Two question.
• Accuracy drops when the state is large and mostly irrelevant. Trim before you send.
• It can be steered by instructions injected into the state. A guardrail that reads untrusted text is itself an attack surface, so keep the question narrow and the criteria explicit.
• It does not generate text, so anything that ends in a sentence for a human still needs a generator.

The video's most striking demo, a chatbot that runs with no LLM at all, is worth understanding for what it is. It answers "how tall is Mount Rainier" by choosing the Wikipedia tool, extracting the place name, fetching the page and pointing at the line that answers. The output the user sees is a quoted line, not a written one. That is grounded by construction, and it is also the reason it only works for questions whose answer already exists as a line somewhere. Ask it to compare two things and there is no line to point at.

What we are testing Jev on first

We are on the waitlist. The first experiment is the skill selector, because it is one choice question with a clean before and after: the current selector's hit rate against Jev's, on the same week of traffic. The second is the three guardrail nouls in the same request, because they are free once the request exists. Both will run under the same tracing that caught the router, so the wait and the cost land in the record next to everything else.

If either works, it will appear on this blog with the numbers, the way the router did. If neither does, that will appear too.

The router article ended with a rule: if your agents run one after another anyway, coordination is buying you a diagram. Jev does not break that rule. It lowers the price of every other decision to the point where the question is no longer whether you can afford to ask, but whether you have written the question well enough to trust the answer.

FAQ

Is Jev a large language model?
No. TypeSafe AI calls it a System One model. It takes your data and a set of fixed questions, and returns a probability for each answer. It does not generate text, which is why the company says it cannot hallucinate a sentence: there is no sentence to hallucinate.

How fast and how cheap is Jev?
TypeSafe's launch post quotes 70ms to 500ms end to end, and pricing of $0.042 per million input tokens with output free. The 40x to 400x claims on the homepage compare against frontier LLMs on the same classification tasks and sit, by the company's own note, at the higher end of real gains.

What questions can Jev answer?
Three kinds. A noul is a yes/no question that comes back as a probability. A choice picks one option from a list you supply, up to 255 options. A score rates the input against ordered levels you describe. You can ask many questions about the same input in one call, and they run in parallel.

Does Jev replace the LLM in an agent?
Rarely on its own. The pattern TypeSafe recommends is code that owns the control flow, Jev for the judgment calls, and an LLM only where you need generated text. A chatbot that only calls tools can run with no LLM at all, and one of the video demos does exactly that, but anything that writes an answer for a person still needs a generator.

Where does Jev fall down?
The company publishes a jaggedness page for version 1.13. It reads dates as text, is unreliable at counting and numeric precision, struggles with double negatives and multi-hop reasoning, loses accuracy when the input is large and mostly irrelevant, and can be steered by instructions injected into the input.

Sources and images: the three charts are frames from TypeSafe AI's Jev launch film, reproduced for commentary with the figures as TypeSafe presented them. TypeSafe AI, "Introducing System One models and Jev" (typesafe.ai/blog); TypeSafe docs, models, primitives, confidence-gated routing pattern and the Jev 1.13 jaggedness page (docs.typesafe.ai); Vercel changelog, "TypeSafe AI Jev now available on AI Gateway", 16 September 2026; Syntax, "wtf is jev?", CJ Reynolds, 17 September 2026.