A classifier you change by editing the prompt.
Jev is a model from TypeSafe that returns a probability per answer like a trained classifier, but takes its task from the prompt like a language model. This page covers what it does, what it costs, and what it does not do.
| Answers | Three kinds of question. Yes/no as a probability (Noul). One choice from up to 255 options, with a probability per option (Choice). A position on a 2 to 10 level rubric, with a probability per level (Score). |
| Input | Text, up to 64k tokens per request. No images, audio or video. |
| Latency | 111 ms median and 162 ms p90 for three questions in one call, measured 2026-09-21 from a laptop, network included. |
| Price | $0.042 per million input tokens. There are no output tokens to bill. |
| Customization | In the request. Each call carries the question, its options and a rubric per option. There is no fine-tuning and no per-account weights. |
| Not supported | Generating text. Reading images, audio or video. Returning a variable-length list; every field is one boolean, one choice or one score. |
Prompt a language model, or train a classifier
Take ticket triage: route each support ticket to billing, support or sales before anyone reads it. Today you would do that one of two ways.
Prompt a language model. Write a paragraph describing the teams, append the ticket, ask for one word. It works the same day. But the model generates that word the way it generates everything, so a one-word answer takes as long as a sentence and is billed at generation rates. What comes back is a string with no probability attached; you cannot tell whether it was 95% or 51%, so you cannot set a threshold and you cannot pick out the calls a human should check. Change your mind about what counts as billing and you change a sentence.
Train a classifier. Collect a few thousand tickets, label them, fine-tune a small model. Now each call takes milliseconds, costs almost nothing, and returns a real probability over the three teams. Change your mind about what counts as billing and you relabel and retrain. Add a fourth team and you need labeled examples of it before you can retrain at all. Most teams ship the first version and never retrain, because the retrain is a project and the mistakes are only annoying.
What Jev is
Jev reads text and answers three kinds of question: a yes/no, a choice from a list of options, or a score on a rubric. There is no token generation. One forward pass over the input returns a probability for each answer, and a call with twelve questions takes about as long as a call with one. TypeSafe calls this a System One model.
The same weights serve every account. There is no fine-tuning step and no dataset. The question, the options and a rubric for each option arrive in the request, in plain language, and Jev answers that question on that input. So the cost and latency are a classifier's, and the task definition is a prompt.
On the right, the triage question asked both ways. The language model returns a string. Jev returns the string and the distribution behind it.
# A language model, asked for a label.
# It writes the answer one token at a time.
response = llm.chat(
"Which team should handle this ticket? "
"Answer with billing, support, or sales.\n\n"
+ ticket.text
)
team = response.strip().lower() # a string to parse and validate
# No probability. Was it 95% or 51%?# Jev, asked the same question.
# One forward pass over the text; a probability per option.
decision = client.decide(
prompt="Which team should handle this ticket?\n\n" + ticket.text,
schema=Triage,
)
decision.answers["team"]
# {"choice": "support",
# "probabilities": {"billing": 0.31, "support": 0.66, "sales": 0.03},
# "confidence": 0.66}Changing the classifier means editing the prompt
Version one of triage is a schema with three teams and a one-paragraph prompt. Each ticket is routed in roughly 111 ms, inline, before the page renders.
Then the company signs its first reseller and agencies start writing in. With a classifier you would now be collecting and labeling agency tickets. With Jev you add partnerships to the enum and one sentence to the prompt.
Because there is no training run, there is also no evaluation step to catch a prompt edit that made things worse. Every Jev answer comes with its probability, so the uncertain ones can be pulled aside and checked, and a new prompt can be replayed against those checked examples before it ships. That shows whether the edit fixed the cases you reviewed without breaking the others. Unsure does that part; the next section covers it.
class Triage(BaseModel):
team: Literal["billing", "support", "sales"]class Triage(BaseModel):
team: Literal["billing", "support", "sales", "partnerships"]
# Plus one sentence in the prompt:
# "Agencies asking about reselling go to partnerships."
# No training run. Replay against the reviewed set, ship.What Jev does not do, and what Unsure adds
Jev is fast because it does one thing. It takes text only. It returns booleans, choices and scores, not free text. Each call is stateless; nothing is stored. And because there is no training run, there is no evaluation step built in.
Unsure covers those gaps. It calls Jev directly and adds the storage, review and replay around it, plus encoder and decoder steps for inputs and outputs Jev cannot handle. The table lists each limit and what Unsure does about it.
One forward pass, a probability per answer, and a replay that shows whether the edit helped.
Start with one schema and one prompt. The first call returns in about 111 ms with a probability per field.