Jev by TypeSafe AI: typed decisions your code can branch on

Jev answers questions about text with typed values and probabilities, and never writes a sentence. You send a state (a message, a record, a JSON object) and a set of named questions. Each answer comes back as a choice from your list, a position on your scale, or the probability that a statement is true. Your code branches on it like any other value.

Jev is the first model in what TypeSafe AI calls the System One class: models trained to make fast, narrow judgments that software consumes directly. TypeSafe is an independent, venture-backed company co-founded by Diogo Almeida, who worked on the RLHF research behind InstructGPT at OpenAI. The public SDKs shipped in September 2026, so treat the product as young: limits, prices and models can move.

One endpoint does everything: POST https://api.typesafe.ai/v1/systemone. The request carries a state (string, JSON object or array), a model and a map of questions. There are three question types:

Every question in a request sees the same state and is evaluated in parallel and in isolation, so one answer never leaks into another. Adding questions costs a few input tokens and barely changes latency.

In the stack, Jev sits in the decisions layer, inside your own code. It does not replace your chat model or your agent. It decides which handler runs, whether a draft passes a check, how urgent a ticket is, or whether a person should look before anything happens. The expensive model only runs for the requests that need it.

The JavaScript SDK earns the company name: in TypeScript the answer types are inferred from your questions, so answers.route.choice has the type "billing" | "technical" | "sales" and a misspelled label fails the build.

Pick Jev when the answer space is closed and you need to know how sure the model is:

• Routing and triage. A ticket goes to one of five teams, a message to one of eight handlers, with a confidence gate in front of each action.
• Checks before an action. "Does this reply promise a refund?", "Does the source support this quote?", "Does this message contain personal data?"
• Scoring on your rubric. Urgency, frustration, risk or answer quality on levels you write, with a number you can threshold.
• Many judgments over one state. Ask twenty questions about one document in one call and combine them in code.
• Replacing a prompt-and-parse step. Where you ask an LLM to "return JSON" for a label and then validate it, Jev returns the label by construction.

Pick something else when:

• You need words. Replies, summaries, extraction of free values, code. Jev gives no reasons for its answers either, so a decision that needs a written rationale needs another model.
• The work is arithmetic, counting or date comparison. TypeSafe's own docs say to keep these in code.
• The input is not text. Jev takes strings, JSON objects and arrays of text. Convert images or audio first.
• The language is not English and you cannot test. English is the primary training language. Other languages work "but not equally well", in the vendor's words.
• The signal is lexical. If a curated keyword list or a regex already decides the case, it is free, deterministic and often more accurate on short inputs. A decision model earns its place on semantic judgments: intent, relevance, support for a claim.

Compared with the nearest options: a small chat model with JSON-schema output can return any shape, but the confidence it reports is generated text, not a measured probability. A fine-tuned classifier you host is cheaper at very high volume and keeps data in house, but needs labelled data and retraining for every new label. Rules cost nothing but break on paraphrase.

A request names each question. The key is yours and is never sent to the model, so the full question goes in instructions. Point at parts of a JSON state with backticked paths such as ticket.messages[0].text.

The response carries one answer per key, the versioned model that answered, and token usage. A choice answer looks like {"type": "choice", "choice": "billing", "probabilities": {"billing": 0.88, "technical": 0.12, "sales": 0.0}, "confidence": 0.81}.

Probabilities and confidence are different numbers. TypeSafe trains Jev with what it calls reinforcement learning for calibrated decisions (RLCD), so that across many answers, outcomes given a probability of 0.8 come true about 80% of the time. Calibration describes groups of predictions, not any single answer. Confidence is a statistic derived from the distribution: for a choice with n options it is (p_max - 1/n) / (1 - 1/n), so an even split scores 0 and certainty scores 1. Score confidence also counts how far probability sits from the peak level. A noul has no separate confidence; the probability is the signal, and |2p - 1| puts it on the same scale.

Models and price on 2026-10-13. The current model is jev-1.13.0. The alias jev-latest points to it and is the SDK default; jev-preview points to the same build today. Price is $0.042 per million input tokens, and output tokens are free. Each request holds up to 64k tokens, with 32k for the state plus the longest question. Published rate limits are 100k tokens per second and 80 requests per second, and TypeSafe says they are "adjusting dynamically" and can change without notice. Higher limits come with custom and enterprise plans.