What is Jev?
Jev is a model from TypeSafe AI that returns structured decisions with a calibrated confidence score, not text. You hand it an input and the shape of the answer you want; it hands back one value in that shape and a number saying how sure it is. There is no prose to parse, no JSON to validate, no "here's my analysis" preamble to strip out.
Three output types cover most of what you'd ask a classifier to do:
- • Choice. Pick exactly one of up to 255 labels you define —
fraud/legit/review, a routing target, a moderation category. - • Score. A number — a severity rating, a relevance score, a priority.
- • Probability. A calibrated likelihood for a yes/no question — "should this tool call be blocked?"
The mechanical difference from a chat model is that Jev is non-autoregressive. An LLM predicts one token, feeds it back in, predicts the next, and so on until it decides to stop. Jev produces all of its outputs in one parallel forward pass — which is why it can be fast and cheap, and also why it can't ramble, explain, or drift out of your schema. Its whole job is to emit a decision that a program can act on immediately.
What does "System One" mean — decisions vs text?
TypeSafe borrows the framing from the two-modes-of-thinking idea: System One is fast, intuitive, and pattern-matched — you glance at a transaction and something feels off; System Two is slow, deliberate, and verbal — you write out the reasoning. Chat LLMs are System Two machines: they think in language, and language is generated a token at a time. A "System One model," in TypeSafe's terminology, is a model that skips the language step and goes straight to the judgment.
That matters because a huge share of what LLMs are actually deployed for in production is not writing — it's deciding. Is this ticket urgent? Which agent should handle this request? Is this output safe to send? Does this tool call look dangerous? Teams have been answering those with a full LLM, a "respond only with JSON" prompt, a parser, and a retry loop. Jev's pitch is that a decision should come back as a decision. For a deeper side-by-side, see our Jev vs LLMs comparison; the short version is in the table below.
| Aspect | Jev (System One) | Normal LLM (System Two) |
|---|---|---|
| What it returns | A typed decision — a Choice (one of up to 255 labels), a Score (a number), or a calibrated probability | Free-form text (which you then parse into a decision) |
| How it generates | Non-autoregressive: every output in one parallel forward pass | Autoregressive: one token at a time, each conditioned on the last |
| Confidence | Built in — trained (RLCD) so the score tracks real accuracy | Not calibrated by default; a self-reported '90% sure' is just more text |
| Output shape | Always valid — cannot return malformed JSON or a label off the list | Can drift, wrap in prose, or break your schema; needs validation and retries |
| Explanations | None — a value and a number, no reasoning | Can explain, reason step by step, and cite |
| Latency / cost | TypeSafe claims ~70–500 ms and 40–400× cheaper on its own workflows; output tokens are free | Seconds for long outputs; billed on input and output tokens |
| Best for | Classification, routing, scoring, moderation, guardrails, real-time loops | Writing, summarizing, multi-step reasoning, open-ended questions |
Two rows deserve emphasis. "Explanations: none" is a feature and a cost at once — you get a number, not a reason, so if a human needs to understand why, Jev alone won't do it. And the latency/cost row is TypeSafe's own claim on workflows TypeSafe chose; we come back to that below.
How does Jev work? RLCD and calibrated confidence
The part of Jev that is genuinely new is not "a classifier" — small classifiers have existed forever. It's the training objective. TypeSafe trains Jev with RLCD — Reinforcement Learning for Calibrated Decisions — on synthetic data. Where RLHF (which the same CEO helped invent) rewards a model for outputs that human raters approve of, RLCD rewards two things: being right, and reporting a confidence that matches how often it is right. A decision Jev tags with 0.90 confidence should be correct about 90% of the time across many such decisions.
That is what "calibrated" means, and it's the property that makes the confidence score usable as a control signal rather than decoration. If calibration holds, you can write real thresholds: auto-approve above 0.95, auto-reject below 0.05, send the middle to a human or to a bigger model. An LLM that says "I'm 90% sure" in its text has no such guarantee — that sentence is just more generated tokens.
In practice the developer experience is: define the decision (labels, a score range, or a probability question), send the input, get back the typed value and the confidence. A TYPESAFE_API_KEY is all the API needs. Typed outputs map cleanly onto Pydantic models, there's a TypeSafeClassifier integration for LangChain, and Jev is available on Cloudflare Workers AI (model id typesafe/jev), OpenRouter, and Composio. Our how to use Jev guide walks through the actual calls.
Get the weekly AI engineering brief
New models, agents, RAG, and the tools worth using — one practical email a week. Plus the free roadmap PDF.
By subscribing you agree to receive emails from AI Engineer Insights. Unsubscribe anytime. See our Privacy Policy.
Who built Jev? TypeSafe AI, Diogo Almeida, and the $40M seed
Jev comes from TypeSafe AI, a San Francisco company founded in 2024 that came out of stealth in September 2026 with a $40M seed round led by DCVC. The CEO is Diogo Almeida, a former OpenAI and Google Brain researcher who was a co-inventor of RLHF and InstructGPT — the techniques behind ChatGPT — and a contributor to GPT-4. His co-founders are Erik Gafni and Sasha Sheng.
The pedigree is relevant to the technical claim, not just the fundraising. RLHF is the reason chat models became pleasant to talk to; RLCD is the same lineage of reinforcement-learning post-training pointed at a different target — accuracy and honest confidence instead of human approval. Whether that target is fully met is an empirical question (see the limitations section), but the people asking it have done this kind of work before.
How much does Jev cost, and how do you get access?
Pricing as of September 2026:
- • Input: $0.042 per million tokens.
- • Output: free — there are no output tokens to bill, since the answer is a value and a number, not text.
- • Context window: 32,000 tokens.
- • Availability: early access opened September 15, 2026 behind a waitlist; around September 21 the waitlist was dropped and API keys are open. Also on Cloudflare Workers AI, OpenRouter, and Composio.
On speed and cost relative to LLMs, be careful with the headline numbers. TypeSafe claims Jev is up to ~193.6× faster and ~444.6× cheaper at peak, with a more typical range of 40–200× faster and 40–400× cheaper, and ~70–500 ms latency — all measured on workflows TypeSafe selected. There's also a methodological catch that independent reviewers have flagged: the 444.6× figure uses the average of two other models' answers (GPT-6 Astra and Claude Fable 5.1) as the reference. That measures agreement with other models, not accuracy against ground truth. Treat the multipliers as vendor marketing until you've benchmarked your own task.
What you can take at face value is the pricing structure: a fraction of a cent per thousand input tokens and nothing for output makes Jev cheap enough to run inside a loop — which is exactly the kind of use case it's aimed at.
What is Jev used for?
- • Real-time control loops. TypeSafe's demos include game bots (Minecraft, Subway Surfers) and drone/robot simulations where a decision is needed many times a second. TypeSafe's own cost figures: about $0.01 for a 2-minute Minecraft session and about $0.10 for a 15-minute drone sim.
- • Agent routing. Classify an incoming request by complexity and send easy ones to a small model and hard ones to a big one — the first step in most agent architectures, and the one that shouldn't itself cost a full LLM call.
- • Tool-call guardrails. Before an agent executes a tool call, ask Jev for a "should this be blocked?" probability and gate on it. (Read the limitations section before you do this with untrusted input.)
- • Content moderation and classification. The classic bread-and-butter: category labels, severity scores, spam/not-spam, with a confidence you can threshold on.
The common thread: the answer is a value, the volume is high, and latency matters. If you were previously weighing whether to fine-tune a small classifier or prompt a big model for one of these — the trade-off we cover in RAG vs fine-tuning — Jev is a third option worth putting on the bench.
What are Jev's limitations?
This is the section the launch coverage mostly skipped, and it's the one that decides whether Jev belongs in your stack. Four things to internalize:
- • "Cannot hallucinate" is about shape, not truth. Jev will never return malformed JSON, a label that isn't on your list, or a string where you asked for a number. It can and does return the wrong value inside a valid type. Never read the marketing line as "never wrong."
- • Calibration is real but imperfect. An independent study measured an expected calibration error (ECE) of about 0.107 — roughly 4.4× that of a well-calibrated baseline. The confidence is reliable at the extremes (near 0 or near 1) and shaky in the 0.3–0.8 mid-range. Worst case: on unanswerable questions it was right 44.7% of the time while reporting an average confidence of 0.74. Threshold aggressively at the ends; do not trust a 0.6 as meaning much.
- • No reasoning, and weak on some basics. Jev gives no explanation for any decision, and it cannot reliably count or compare dates. If the decision hinges on arithmetic, ordering, or an audit trail, use a System Two model (or plain code) for that part.
- • Prompt injection works. VentureBeat reported, and an Octomind demo showed, that a "should this be blocked?" probability of 0.76 fell to 0.48 after a fake "user pre-approved" field was added to the input. If Jev's decision gates a real action, do not feed it unguarded untrusted content — sanitize the input, or don't let attacker-controlled text reach the field the decision is made on.
None of this makes Jev useless. It makes it a fast, cheap, structurally safe decision layer with a confidence score you should trust at the edges and verify in the middle — which is a precise and useful thing to be, as long as you build around it rather than assume it's an oracle.
Frequently Asked Questions
What is Jev in simple terms?
Jev is an AI model from TypeSafe AI that answers with a decision instead of a paragraph. You give it an input and a set of possible answers (labels, a numeric range, or a yes/no question), and it returns one typed value plus a confidence score — for example {label: 'fraud', confidence: 0.87} — in a single pass. TypeSafe calls this category a 'System One' model, after the fast, intuitive mode of thinking, as opposed to the slow, deliberate 'System Two' style of a chat LLM.
Is Jev an LLM?
Not in the usual sense. A large language model generates text autoregressively, one token at a time. Jev is non-autoregressive: it produces all of its outputs in one parallel forward pass and never emits free text. It is built to be consumed by software directly, not read by a person. Think of it as a decision model that sits next to your LLM, not a replacement for it.
Can Jev hallucinate?
It cannot hallucinate the shape of an answer — you will never get malformed JSON, a label that wasn't on your list, or a string where you asked for a number. But it absolutely can return the wrong value inside a valid type: a legitimate transaction labeled 'fraud', or a confident score on a question it cannot actually answer. 'Cannot hallucinate' means structurally safe, not never wrong.
How much does Jev cost?
As of September 2026, TypeSafe charges $0.042 per million input tokens, output is free, and the context window is 32,000 tokens. Early access opened on September 15, 2026 behind a waitlist, which was dropped around September 21, so API keys are now open. It is also available through Cloudflare Workers AI (model id typesafe/jev), OpenRouter, and Composio.
What is RLCD and how is Jev trained?
RLCD stands for Reinforcement Learning for Calibrated Decisions. Where RLHF rewards a model for outputs that human raters approve of, RLCD rewards the model for being right and for reporting a confidence that matches how often it is right — a '90% confidence' answer should be correct about 90% of the time. TypeSafe says Jev is trained this way on synthetic data. Independent testing shows the calibration is real but imperfect, especially in the 0.3–0.8 mid-range.
Who built Jev?
TypeSafe AI, a San Francisco company founded in 2024. It came out of stealth in September 2026 with a $40M seed round led by DCVC. The CEO is Diogo Almeida, a former OpenAI and Google Brain researcher who was a co-inventor of RLHF and InstructGPT and a contributor to GPT-4. His co-founders are Erik Gafni and Sasha Sheng.
References
- • TypeSafe AI — Introducing System One models and Jev
- • Wikipedia — Jev (AI model)
- • LangChain — Building a harness with Jev
- • Cloudflare Workers AI — typesafe/jev model page
- • AI Engineer — Diogo Almeida speaker profile
- • VentureBeat — Companies are putting Jev in charge of AI agent decisions, and prompt injection can influence the verdict