Jev

Learning Objectives

• Explain what a System One model is and how it differs from a chat model
• Understand the three question types Jev answers, and what it returns for each
• Judge the vendor's speed and cost claims, and know where the comparison stops being like-for-like

What Is Jev?

Jev is the first model from TypeSafe AI, a San Francisco lab founded in 2024 that came out of stealth on September 15, 2026 with a 40 million dollar seed round led by DCVC. Its chief executive, Diogo Almeida, was a researcher at OpenAI and a co-author of the work behind reinforcement learning from human feedback, InstructGPT and ChatGPT.

The premise is that most AI in production is not talking to a person. It is deciding something inside a program: which queue this ticket belongs in, whether this tool call is safe to run, how good this draft is. Sending that work to a chat model means asking for prose, then parsing the prose back into a value your code can use, and handling the cases where the model wrote something unparseable.

Jev removes that round trip. TypeSafe calls it a System One model, and describes it as a frontier-intelligence function call: unstructured state goes in, typed probabilistic decisions come out. You hand it a block of state and a set of typed questions, it evaluates all of them at once, and it returns answers already in the shape your code declared, each with a calibrated probability. There is no string to parse and no format to validate.

TypeSafe trained it with a method it calls reinforcement learning for calibrated decisions, and generates every output in parallel rather than one token after another, which is where the speed comes from.

How You Actually Use It

Jev answers three kinds of question, and several of them can share one block of state in a single request.

A support-ticket example, using the AI SDK:

const result = await evaluate({
  model: 'typesafe-ai/jev',
  state: 'My card was charged twice for one order.',
  questions: {
    route: {
      type: 'choice',
      instructions: 'Route this support ticket.',
      criteria: {
        billing: 'payment or charge problems',
        shipping: 'delivery problems',
        technical: 'application bugs',
      },
    },
  },
});
// { route: { type: 'choice', choice: 'billing',
//   probabilities: { billing: 1, shipping: 0, technical: 0 } } }

The state field accepts a string, an object or an array, so a structured record or a message history can go in directly without being flattened into a prompt first. Batching genuinely pays: reviewers measured a single call carrying thirteen questions at roughly 11.5 times cheaper and 9.6 times faster than thirteen sequential calls.

How Accurate Is It?

Less accurate than the frontier chat models, on TypeSafe's own public evaluation. This is the number the launch coverage mostly skipped, and it is the one that decides whether Jev fits your problem.

TypeSafe built an evaluation across four workflows and published the results. Jev aggregates at 67.8 percent against 74.1 percent for the best comparator, and trails on all four.

Read the gap, not the average: it runs from 2.3 points on customer service to 17.3 points on invoice processing. Routing a support ticket is close to a tie; pulling structured fields out of an invoice is not, and that is a job for a frontier model.

So the case for Jev is speed and cost, not accuracy. It is not a more correct classifier than a frontier model; it is a far cheaper and faster one that is somewhat less correct, which is a good trade at volume and a bad one when a single wrong answer is expensive.

Availability

This is the most important practical fact about Jev, and it has two halves.

TypeSafe's own API is not open. The company describes Jev as available through a waitlisted early access program for select developers, and has named no date for general availability. You sign up at typesafe.ai and wait for an invitation before you can create a key in its console.

Two gateways are open. Vercel added Jev to its AI Gateway on September 16, 2026 with no waitlist, and Cloudflare lists it in Workers AI. Any developer with a key at either can call it today — through the AI SDK, through Workers AI, or by posting to the gateway's evaluation endpoint. That is the route most people will take, and it is the one worth starting from.

Pricing

Input is billed at $0.042 per million tokens and output is not billed at all, which TypeSafe describes as too cheap to meter. A realistic single decision lands around a thousandth of a cent.

Treat the headline cost comparisons carefully. TypeSafe advertises figures like 238 times cheaper than Claude Fable 5.1, and Vercel quotes a range of 40 to 400 times lower. These compare a model that bills input only and returns no prose against models that also bill for every output token, so the multiple is partly a different billing shape rather than a like-for-like discount. The saving is real for high-volume classification work; it is not a statement that Jev is a cheaper version of a chat model, because it cannot do what a chat model does.

Strengths

• Nothing to parse — answers arrive in the type your code declared, so there is no brittle extraction step and no retry when a model writes an unexpected format
• Many questions per call — a single block of state can be evaluated against several typed questions in one round trip
• Calibrated probabilities, not just labels — every answer carries a confidence you can threshold on, which makes partial automation with human review straightforward to build
• Very fast — TypeSafe reports responses between 70 and 500 milliseconds, against several seconds for a frontier chat model on the same job
• Cheap at volume — input-only billing makes per-decision cost small enough that evaluating every request becomes reasonable
• Structured input — state can be an object or a message history rather than a hand-built prompt string

Limitations and Considerations

• It is less accurate than a frontier model — behind on all four workflows of TypeSafe's own evaluation, by 2.3 to 17.3 points, and the answer key was written by two of the models it was measured against
• Calibration is the whole value proposition and it is unvalidated — thresholding on confidence only works if the probabilities hold, and TypeSafe has published no standard calibration metrics, nor any test under distribution shift or adversarial input
• Known functional weak spots — reviewers report it is literal, weak on numeric precision and date comparison, distracted by large blocks of irrelevant state, and susceptible to adversarial content in the state it is given
• No comparison against the obvious cheaper alternatives — nothing published pits it against a classical classifier, a reranker or a small fine-tuned model on the same ground-truth task, which is the comparison an experienced engineer will want; the sharpest public criticism is that it repackages encoder-only classification
• It is a black box — no published parameters, architecture, training data or model card, and no weights
• The direct API is still waitlisted — access depends on a third party's gateway unless TypeSafe invites you, and no general availability date has been announced
• "Never hallucinates" is a claim about types, not about truth — the model cannot return a value outside the shape you declared, but a confidently wrong answer is still possible
• It does not write anything — no summaries, no drafts, no explanations of its reasoning, so it complements a chat model rather than replacing one
• The answers must be known in advance — it decides among options you define, which rules out open-ended work
• A 32,000 token context — smaller than most current frontier models, so very long documents need chunking
• Not available on the OpenAI-compatible, Anthropic-compatible or Cohere-compatible endpoints — an existing integration written against those shapes will need changing
• A young company on its first model — a 40 million dollar seed, a small team, and a product five days old at the time of writing

Best Use Cases

When to choose alternatives:

• Anything that must produce text, code or a summary → a general model such as GPT-6 Astra or Claude Fable 5.1
• Accuracy matters more than cost, or a wrong answer is expensive → a frontier model, which led Jev on every workflow TypeSafe published
• Structured extraction from documents and invoices → a frontier model; this was Jev's weakest workflow by a wide margin
• One narrow, high-volume classification you can label → a small fine-tuned classifier or a reranker is likely cheaper still, and nobody has published the comparison
• A decision that needs a written justification → a chat model with structured outputs, which is slower but explains itself
• Open-ended categories you cannot define up front → a chat model, or a clustering step before Jev

Getting Started

1. Read TypeSafe's introduction to System One models to understand the state-and-questions shape before writing any code
2. Take the open route first: add Jev through Vercel AI Gateway, using the model id shown above, which needs AI SDK 7 or later and no waitlist
3. Start with one boolean question against state you already have, and compare its answer with a chat model on the same inputs
4. Check the calibration on your own data before trusting a threshold — collect a few hundred decisions and see how often the stated confidence holds
5. Join the waitlist at typesafe.ai only if you need the direct API, for example to avoid a gateway in the path

Key Takeaways

• Jev is TypeSafe AI's first System One model, launched September 15, 2026: state and typed questions in, structured decisions with calibrated probabilities out, and no text generated
• It answers boolean, choice and score questions, several against one block of state in a single request, so there is nothing to parse and no format to validate
• The direct API is waitlisted with no general availability date, but Vercel AI Gateway and Cloudflare Workers AI both carry it openly — that is the route to start from
• Input costs $0.042 per million tokens with output unbilled, though the headline multiples against chat models partly reflect a different billing shape rather than a straight discount
• It is less accurate than the frontier models it is pitched against — 67.8 percent against 74.1 percent in aggregate on TypeSafe's own evaluation, trailing on all four workflows, so the case for it is speed and cost rather than correctness
• The "never hallucinates" framing is about type safety, not correctness — it cannot return an invalid shape, but it can still be confidently wrong, and no calibration metrics have been published even though thresholding on confidence is the entire point
• Every speed and cost figure published so far is vendor-reported, on a black-box model from a company less than a week out of stealth