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. On October 9, 2026 the company raised a further 870 million dollars at a 7.5 billion dollar valuation, in a Series A led by Andreessen Horowitz with Sequoia Capital and DCVC, and a16z's Martin Casado joined its board. TypeSafe says a third of the Fortune 500 already use Jev, a figure it has not broken down.

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 like-for-like comparison against the obvious cheaper alternatives — the sharpest public criticism is that it repackages encoder-only classification, and three days after launch an open model built exactly that way arrived to test the claim. Laya, from Convai Innovations, is under 450 million parameters, carries an Apache 2.0 license, and reports higher scores than Jev on three of four classification tasks at a fraction of the latency, while losing badly when there are dozens of labels. That comparison is self-reported, and it sets Laya's own results against Jev figures from other people's tests with different prompts, so it is a first data point rather than a settled result. No one has yet run both models, or a classical classifier, on the same ground-truth task
• Open imitators arrived within three weeks — on October 1, 2026, Cloudflare released Clef and Clef-flash under Apache 2.0, compatible with Jev's interface and hosted on the same Workers AI service that carries Jev, and says Clef leads TypeSafe's own decision benchmark; Amazon Web Services released Strands Decider, an open-source model of about two billion parameters. Both claims are their makers' own. TypeSafe's chief executive Diogo Almeida told TechCrunch he sees no real competition yet, arguing the rivals underestimate how hard it is to make these models smart. A buyer weighing Jev now has a drop-in open alternative to test it against
• OpenAI now sells the same idea itself — it announced a Decisions API at DevDay on September 29, 2026 and opened it to all developers in public beta on October 6. It answers predicate, choice and score questions about text or images, runs only on GPT-6 Luna for now, and OpenAI says it answers up to ten times faster than calling Luna through its general Responses API. It became generally available on October 22, adding prompt caching, inference residency in the US and EU, a GPT-Live voice integration and up to 400 questions per request. For a team already on OpenAI's platform, that removes the main reason to add a second vendor. The same day the startup Musubi released open weights for PolicyLM, a 1.7 billion-parameter decision model for content moderation
• Microsoft launched a rival at the same price — Microsoft-Decision-1, released October 9, 2026 and built on Alibaba's open Qwen3.5 model with 9 billion parameters, costs 4.2 cents per million input tokens with output free, exactly Jev's price. Microsoft says it topped a 36-benchmark comparison and later added Jev's results to that comparison, but every figure in it is Microsoft's own
• 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 small team and a product launched in mid-September 2026. The October Series A buys runway, not independent evidence that the model works

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, though no independent head-to-head has been published
• The weights must run on your own hardware, or the data cannot leave your network → an open encoder-based decision model such as Laya, which is Apache 2.0 licensed; test it on your own labels first, since its published comparison with Jev is its developer's own
• You already build on OpenAI's platform and want one vendor → OpenAI's Decisions API, generally available since October 22 on GPT-6 Luna; compare it with Jev on your own labels before choosing
• You already buy from Microsoft → Microsoft-Decision-1 in Foundry, at the same price as Jev; run both on your own labels, since each vendor's benchmarks favor its own model
• You want Jev's interface with open weights and a hosted fallback → Cloudflare's Clef, which is Apache 2.0 licensed, compatible with Jev's interface and offers a fine-tuning service; or Amazon's open-source Strands Decider
• 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
• Open rivals followed fast: Cloudflare's Jev-compatible Clef and Amazon's Strands Decider shipped on October 1, 2026, so Jev's lead now has to be shown on your own data
• OpenAI opened its own Decisions API to all developers in public beta on October 6, 2026 and made it generally available on October 22, on GPT-6 Luna, so the idea Jev introduced is now a first-party feature of the largest model platform
• Microsoft matched Jev's price exactly with Microsoft-Decision-1 on October 9, 2026: 4.2 cents per million input tokens, output free, in Microsoft Foundry. Microsoft says it beat Jev on its own benchmarks, a comparison it added after publishing
• Every speed and cost figure published so far is vendor-reported, on a black-box model from a young company. Its October 2026 Series A of 870 million dollars, at a 7.5 billion dollar valuation, funds the lead without verifying it