Ask an LLM a yes/no question.
One thing your code needs to know about this ticket: is it urgent? Press the button a few times. The answer never changes; the shape of it changes every time. The LLM is right, the packaging is not, and packaging is what breaks your parser.
// the only thing you actually need if (reply.toLowerCase().startsWith("yes")) { escalate(ticket); }
Nothing yet. Press a button on the left.
Three question types. That's the lot.
TypeSafe calls them primitives: small, boring, composable. Pick one to see what you define and what comes back.
Build a request and run it.
Tick whichever questions you fancy and send. However many you tick it stays one HTTP call, and the latency barely moves, because every question is evaluated in parallel against the same state.
Tick some questions and press send.
"I don't know" is a feature.
Choice and Score answers carry a confidence from 0 to 1, squeezed out of the probability distribution. The answer tells you what; confidence tells you whether to act. Drag the handles and watch 14 tickets sort themselves.
What 0.8 is supposed to mean.
A calibrated model is one where, across everything it labelled 0.8, about 80% turn out to be right. Not this answer, the pile. RLHF pushes a model toward confident prose; TypeSafe train against the outcome instead and call it RLCD. Run a batch and watch the bars settle onto the dashed lines.
The dashed line is where each bar should land. Bars are what actually happened.
Don't ask a big question. Ask small ones and do the maths yourself.
"Rate this startup pitch" is a bad Jev question: too many independent factors in one judgement. Ask the factors separately and combine them with a formula in your code. Drag feasibility to 100% and the verdict flips, with nothing re-run or re-prompted.
Ask everything, including the questions you might not need.
A 13th question costs almost nothing, because they are all evaluated in parallel against a state read once. So ask all of them speculatively and bin what you do not need. TypeSafe's cookbook runs 13 questions over the GDPR article: batched, it came out 10x faster and 12.2x cheaper.
Six jobs. Which ones should Jev not get?
TypeSafe publish a page listing what Jev is bad at, which is more than most model cards manage. Pick who should do the work.
You can build a noul tonight.
None of this needs an API key. Any local model that hands you logprobs can answer yes/no as a number: read the logits for True and False, softmax over just those two. Getting a number is the easy half; getting one that means something is the hard half.
# a noul, locally: any model that gives you logprobs q = "Statement: the customer wants a refund.\n" \ "True or false? Answer:" out = llm(q, max_tokens=1, logprobs=20) lp = out["choices"][0]["logprobs"]["top_logprobs"][0] gap = lp.get(" True", -99) - lp.get(" False", -99) p = 1 / (1 + math.exp(-gap / T)) # T is fitted once, on a set you have labelled
Swap the tokens for your own labels and you have a Choice. Take the expectation over ordered level tokens and you have a Score. The API surface is not the moat.
T1.00T never changes an answer, only how loudly it is held. Out of the box this model claims ~93% certainty and is right 75% of the time. Slide T until the two match.
An RL-trained head over sequence embeddings that emits a conversion probability turn by turn, 85ms against 3450ms for GPT-4. No text generated, just the number. Paper · weights · dataset.
Scores confidence before generating, then routes into four lanes: local model, RAG, a bigger model, or a human. That is section 04 of this page, published a year earlier. Paper.
Fair is fair. Those are vertical: one task, fixed at training time. Jev's claim is horizontal, with questions written per request. Same instinct, different animal.
| Jev | your local model | a task-trained head | |
|---|---|---|---|
| What it is | hosted System One model | whatever you already run | a small model trained for one job |
| Questions | written per request | anything you can tokenise | fixed at training time |
| Calibration | trained for it | bolt it on with temperature or isotonic, on your labels | trained into the task |
| Many at once | one call, state read once | one pass each unless you cache the prefix | n/a |
| Cost | $0.042 / Mtok | your electricity | your electricity |
| Can you check it | self-reported numbers, no weights, no paper | you can measure it yourself | weights, dataset and paper published |
That last row is the one I keep coming back to. The open one-person project is more verifiable than the lab with $40m.
A gut feeling with an API key.
The name is Kahneman's: System 1 is the fast intuitive judgement, System 2 the slow deliberate one. Chatbots aim at System 2. Jev is built for the other one, betting that most AI work ends up as machines talking to machines, where nobody reads the prose.
The answer space is whatever you defined. A Choice can only return one of your keys. There is no JSON to repair, no schema to validate, no retry loop.
No replies, no code, no explanation of its reasoning. If you need words you still need an LLM, with Jev in front of it or behind it.
You always get the full distribution, not just the winner. Sort by it, threshold it, feed it to a classifier, ignore it.
At $0.042 per million input tokens and output free, asking is cheap enough to do per-passage, per-row, per-message, per-keystroke.
| Jev 1.13 | a frontier LLM | |
|---|---|---|
| What comes back | typed value + probabilities | a string you parse |
| Input price | $0.042 / Mtok | $0.20 – $10 / Mtok |
| Output price | $0, free | roughly 5× input |
| End to end | 70–500 ms | seconds |
| Context | 64k per request, 32k for state + longest question | 100k – 1M+ |
| Input types | text only: string, object, array | often text, image, audio |
| Can it write you an email | no | yes |
TypeSafe AI came out of stealth with $40m, cofounded by Diogo Almeida, who co-invented the RLHF work behind InstructGPT and has now built the thing that points the other way.