Jev is a new kind of model from TypeSafe AI. It doesn’t write text. You hand it a piece of program state, declare the questions you need answered, and it returns typed answers with calibrated probabilities: a yes/no probability, a choice from a list, or a score on a rubric. TypeSafe calls this a “System One Model”, and the pitch is simple: most AI calls inside software aren’t asking for prose, they’re asking for a decision. If you’ve wired an LLM into a classifier and then written a parser to pull a label out of its reply, Jev is built for exactly that job, the way structured outputs were a first step toward it.
It landed on Vercel AI Gateway on September 16, 2026, which is what put it in front of most developers. This guide covers what Jev is, how it differs from a language model, the three question types, how to call it directly and through the Gateway, and how to test and mock it in Apidog before it touches your routing logic.
What Jev is
TypeSafe’s launch post describes Jev as “a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” Three properties define it.
The output is typed, and declared before the call. You define each question’s shape up front. The model can only answer inside that shape, so there’s nothing to parse and no schema mismatch to catch. TypeSafe’s word for this is that Jev “never makes type errors.”
Every answer carries a probability. A yes/no question doesn’t return true; it returns a number like 0.97. A choice returns the full distribution across options. TypeSafe trained the model with a method it calls Reinforcement Learning for Calibrated Decisions, and the claim is that higher confidence means higher accuracy, so you can threshold: automate the clear cases, route the uncertain ones to a human.
Questions are answered in parallel, in one request. A language model produces one token at a time. Jev evaluates every declared question at once against the same state, which is why TypeSafe quotes end-to-end response times of 70ms to 500ms. Those are the vendor’s own numbers; treat them as a claim to verify against your workload, not a benchmark.
How Jev differs from a language model
| Language model | Jev | |
|---|---|---|
| Output | Free text you parse | Typed values you declared |
| Sampling | Sequential, token by token | All questions in parallel |
| Confidence | Not exposed by default | A probability on every answer |
| Best at | Writing, chat, summarizing | Deciding, routing, scoring, verifying |
| Input | Messages | Structured state: a string, object, or array |
| Images | Often supported | Text only, for now |
The tradeoff is explicit: Jev gives up string generation entirely. It’s not a chat model and it won’t summarize a document. Where it fits is the “smart if-statement” inside an application: which team handles this ticket, how severe is this bug, is this reply safe to send, did the build pass.
The three question types
Jev’s direct API exposes three primitives. Each is a JSON object under a key you choose.
Noul: a yes/no probability. TypeSafe’s name for the boolean type. It returns the probability that the answer is yes, and you threshold it in code.
{ "is_urgent": { "type": "noul", "instructions": "Does this message express urgency?" } }
Response: { "type": "noul", "noul": 0.99 }.
Choice: pick one option from a named set. criteria maps option names to descriptions, up to 255 options. The answer carries the top pick plus the full distribution and a confidence figure.
{ "department": { "type": "choice", "instructions": "Which team should handle this?",
"criteria": { "billing": "Charges, invoices, payment problems",
"shipping": "Delivery status, delays, lost packages",
"returns": "Exchanges, refunds, damaged items" } } }
Response: { "type": "choice", "choice": "returns", "confidence": 1.0, "probabilities": { "returns": 1.0, "shipping": 0.0, "billing": 0.0 } }.
Score: a position on an ordered scale. criteria is an array of 2 to 10 level descriptions, lowest first. The score is the probability-weighted position, so it can land between rungs.
{ "bug_severity": { "type": "score", "instructions": "How severe is the reported issue?",
"criteria": [ "Cosmetic; no impact to functionality",
"Broken feature, but a workaround exists",
"Blocking issue; no workaround" ] } }
Response: { "type": "score", "score": 1.3, "confidence": 0.54, "probabilities": { "0": 0.0, "1": 0.7, "2": 0.3 }, "legend": { "0": "Cosmetic...", "1": "Broken...", "2": "Blocking..." } }.
One naming wrinkle: through the Vercel AI SDK the yes/no type is called boolean and the answer field is probability. Against TypeSafe’s own API it’s noul. Same idea, different key.
Two ways to call Jev
Directly. Get a key at console.typesafe.ai/settings/keys, then send POST https://api.typesafe.ai/v1/systemone with a Bearer token. The model id is jev-latest, which currently resolves to jev-1.13.0; jev-preview points at the newest build, official or not. Python and JavaScript SDKs exist, per the quickstart, but the raw endpoint is a single POST, which is the form we’ll use in Apidog.
Through Vercel AI Gateway. The model id is typesafe-ai/jev and you call it with experimental_evaluate from the AI SDK (version 7 or later). One caveat from the evaluation docs: evaluation is available through the AI SDK only, not through the Gateway’s OpenAI-compatible or Anthropic-compatible endpoints. If you already route models through the Gateway, as in our GPT-5.6 Sol on AI Gateway walkthrough, this is the natural path; our Vercel AI SDK guide covers the setup.
import { experimental_evaluate as evaluate } from 'ai';
const result = await evaluate({
model: 'typesafe-ai/jev',
state: 'The support agent issued a full refund to the customer.',
questions: { refunded: { type: 'boolean', instructions: 'Was a refund issued?' } },
});
// result.answers.refunded -> { type: 'boolean', probability: 0.99 }
Your first request with curl
This triages a support message with all three types in one call:
export TYPESAFE_API_KEY="..."
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "My card was charged twice for one order and I need this fixed today.",
"questions": {
"department": { "type": "choice", "instructions": "Which team handles this?",
"criteria": { "billing": "charges and refunds", "shipping": "delivery", "technical": "bugs" } },
"urgency": { "type": "score", "instructions": "How urgent is this?",
"criteria": ["low", "medium", "high"] },
"wants_refund": { "type": "noul", "instructions": "Is the customer asking for money back?" }
}
}'
The response has model, an answers object keyed by your question ids, and usage with input_tokens and output_tokens. Read answers.department.choice, answers.urgency.score, and answers.wants_refund.noul, then apply your thresholds.
Test and mock Jev in Apidog
A model that returns probabilities changes what a test looks like. You’re no longer asserting a string; you’re asserting that a number crosses a line. Apidog makes that a saved, repeatable check rather than a one-off curl.
Store the key. Open Environment Management, create an environment named TypeSafe, and add TYPESAFE_API_KEY with the real value in the local field, so it stays on your machine and never syncs to the team. Our guide to environments and secret variables covers the scope rules.
Build the request. New request, POST https://api.typesafe.ai/v1/systemone, Auth type Bearer Token with {{TYPESAFE_API_KEY}}, JSON body from the curl example. Send it and read the answers in the response panel.
Assert on the decision, not the text. Add post-processor assertions such as answers.department.choice equals billing, answers.wants_refund.noul is greater than 0.9, and answers.urgency.score is greater than 1.5. Now a regression in Jev’s behavior, or in your own criteria wording, fails a test instead of silently misrouting tickets.
Mock it for the frontend. Save the response as a mock, and your ticket UI can be built and demoed against a stable answers object without spending tokens or waiting on the model. Because the shape is declared, the mock and the real response can’t drift apart.
Save it as a scenario. Chain a few states, a calm message, an angry one, an ambiguous one, and assert that confidence drops on the ambiguous case. That’s the check that tells you your threshold is doing its job. Download Apidog to set this up; the free plan covers a team of four.
Pricing, limits, and errors
From TypeSafe’s models page:
- Price: $0.042 per million input tokens. Output tokens aren’t charged. The Gateway lists the same $0.042 per million input.
- Rate limits: 250,000 tokens per second and 1,200 requests per minute, adjusted dynamically.
- Context: 64k tokens per request, of which 32k is for
stateplus the longest question. - Input: text only. A string, a JSON object, or an array of text. No images, audio, or video.
- Language: English is best; other languages work with lower accuracy.
Errors come back as HTTP status codes: 401 for a missing or invalid key, 422 when the body fails validation (a Score with one level, a Choice with no criteria), 429 for rate limits, and 529 when the service is overloaded. Back off and retry on the last two; the SDKs do this by default.
FAQ
Is Jev a replacement for an LLM?
No. It replaces the part of an LLM call where you were asking for a decision and parsing text to get it. Generation, chat, and summarization still need a language model.
Can Jev hallucinate?
It can be wrong, but it can’t produce an answer outside the schema you declared. TypeSafe’s argument is that schema matching is guaranteed, so a “hallucinated” label is impossible; a low-confidence wrong label is still possible, which is why the probability matters.
What does “calibrated” mean in practice?
If the model says 0.9, it should be right about 90% of the time on that kind of question. That’s what lets you pick a threshold and automate above it. Test it on your own data before trusting the number; a saved scenario in Apidog with labeled states is a cheap way to do that.
Do I need Vercel to use Jev?
No. The direct API at api.typesafe.ai works on its own with a Bearer key. Vercel AI Gateway is a convenience if you already use the AI SDK, and it’s the only route that supports experimental_evaluate. Either way, the JSON Schema basics behind declared shapes are worth knowing.
Where Jev fits
Reach for Jev when the question has a fixed set of answers and you need a probability with it: routing, classification, scoring, verification, guardrails. Keep your language model for everything that needs words. Declare the shape, test the thresholds in Apidog, and let the confidence number decide what gets automated.
