Jev is a System One model from TypeSafe AI that returns typed decisions with calibrated probabilities instead of generated text. You send it state plus a set of questions (choice, score, or boolean), and it answers all of them in one parallel pass, usually in under half a second, at $0.042 per million input tokens.
The Jev AI model matters to VideoSDK developers for one reason: most decisions inside a live app do not need prose. Is this chat message toxic? Which queue should this support call go to? Should the voice agent run that tool? Each needs a fast, typed answer with a confidence score, and that is the only thing Jev does.
TypeSafe AI came out of stealth on September 15, 2026 with $40 million in seed funding and this one model, and within four days Vercel, Cloudflare, and LangChain had shipped integrations. This guide covers what Jev is, what it costs, how to call it, and where it fits in a VideoSDK real-time pipeline.
What is Jev?
Jev is defined as a hosted, proprietary decision model that evaluates supplied state against typed questions and returns probabilities, not text. Jev works by reading your state (a string, JSON object, or array of up to 32,000 tokens), scoring every attached question against it in parallel, and returning one typed answer per question with per-option probabilities and a confidence value.
TypeSafe calls Jev the first System One model. The company was founded in 2024 by Diogo Almeida, a former OpenAI researcher credited as a co-inventor of RLHF, with Erik Gafni and Sasha Sheng, and DCVC led the seed round. As of September 2026 the direct API sits behind a waitlist at typesafe.ai, while Vercel AI Gateway and Cloudflare Workers AI expose it without one.
For a VideoSDK application, Jev does not replace the LLM in a voice agent or the STT engine behind a transcript. It is the layer that decides what to do with their output.
How does the Jev AI model work?
Jev evaluates every question in a request in a single parallel pass, so adding a tenth question barely changes latency. TypeSafe's System One concept page describes questions as evaluated "in parallel and in isolation against the same state."
There are three question primitives:
- Choice picks one of up to 255 named options and returns the pick, per-option probabilities, and confidence.
- Score rates the state on 2 to 10 ordered rubric levels and returns a numeric score that can land between levels, plus probabilities and confidence.
- Noul tests a statement and returns one probability from 0 to 1. Vercel's AI SDK exposes it as
boolean.
Jev bills input tokens only, because the output is a handful of numbers rather than a paragraph. And TypeSafe trains it with what it calls Reinforcement Learning for Calibrated Decisions, so a 0.91 probability is meant to be right about 91% of the time across many calls. Calibration is a group property; it does not make any single answer correct.
Jev vs LLM: What actually changes?
The Jev vs LLM difference is output type, latency, and cost, not raw intelligence. An LLM with structured output can return JSON that looks like a decision, but any probability inside that JSON is itself generated text. Jev's probabilities are native model outputs.
| Dimension | Jev (System One) | Frontier LLM |
|---|---|---|
| Output | Typed answers plus probabilities | Free text, optionally schema-constrained |
| Latency (TypeSafe workflow evals) | 70 ms to 500 ms | 3 s to 329 s |
| Input price | $0.042 per 1M tokens | $0.20 to $10 per 1M tokens |
| Output price | Free | Billed per token |
| Writes prose, code, or summaries | No | Yes |
| Accepts images or audio | No | Many do |
| Schema errors | 0% by construction | Depends on model and parser |
On TypeSafe's four-workflow evaluation set (security alerts, agent review, invoice processing, customer service), Jev scored 67.8% agreement with the averaged answers of GPT-6 Astra and Claude Fable 5.1, level with GPT-5.6 Terra at 67.9%. So the Jev vs GPT question has a clean answer: equal on those decision tasks, far cheaper, and useless for generation.
The headline "193.6x faster, 444.6x cheaper" figure comes from a single workflow that TypeSafe says sits at the high end of real use, and the benchmark is vendor-run. Test on your own data first.
Jev AI model pricing and early access
Jev pricing as of September 2026 is $0.042 per million input tokens with free output, on both TypeSafe's direct API and Vercel AI Gateway.
Three access routes exist:
- TypeSafe direct. Join the waitlist at typesafe.ai, then sign in at console.typesafe.ai. The endpoint is
POST https://api.typesafe.ai/v1/systemone, with a Python SDK (pip install typesafe-sdk, Python 3.10+) and a JavaScript SDK (@typesafe-ai/sdk). - Vercel AI Gateway. No waitlist. Model ID
typesafe-ai/jev, 32,000 tokens of state, 64,000 tokens per request. - Cloudflare Workers AI. No waitlist. Model ID
typesafe/jev, 32,000-token context, called throughenv.AI.run(), priced in the Cloudflare dashboard.
Model weights and self-hosting are not offered.
Jev API: Vercel AI SDK and LangChain
The Jev API surface is small enough to learn from one call. Vercel added Jev to AI SDK 7 (version 7.0.105 onward) through an experimental evaluate function on September 16, 2026. This is Vercel's published changelog sample, unchanged:
1import { experimental_evaluate as evaluate } from 'ai';
2
3const result = await evaluate({
4 model: 'typesafe-ai/jev',
5 state: 'The support agent issued a full refund to the customer.',
6 questions: {
7 refunded: {
8 type: 'boolean',
9 instructions: 'Was a refund issued?',
10 },
11 },
12 providerOptions: {
13 gateway: { zeroDataRetention: true },
14 },
15});
16
17console.log(result.answers.refunded);
18Add
choice and score entries to the same questions object and they evaluate in the same pass. Vercel's guide, How to classify, route, and score with Jev and AI SDK, shows the full response shape. This block is copied from Vercel's changelog and documentation-verified, not run here.LangChain's
langchain-typesafe package wraps the same call as a TypeSafeClassifier and adds two agent middlewares. ModelRouterMiddleware asks Jev which of your named models is the cheapest one able to handle the current turn. AutoModeMiddleware gates risky tool calls such as bash behind a Jev risk check. Both run inside a standard create_agent loop; see Building a harness with Jev.Jev for AI agents in real-time video and voice
Jev's best fit inside a VideoSDK application is every decision that currently waits on an LLM round trip. Jev answers in a few hundred milliseconds with a probability your code can threshold.
Three patterns work with existing VideoSDK surfaces:
- Transcript-driven routing. VideoSDK real-time transcription emits text as participants speak. Send each chunk to Jev with a
choicequestion (billing, technical, sales) and anoulquestion (is this urgent) to route a support video call while it is still in progress. - Live-stream moderation. Chat and Q&A in interactive live streaming arrive through PubSub. A
scorequestion on a three-level rubric (fine, borderline, remove) with a confidence cutoff auto-hides obvious cases and sends borderline ones to a human. - Voice agent tool gating. Zero Runtime, the voice-agent framework that grew out of VideoSDK AI Agents, lets you wrap a function tool so the Jev proposes an action and agent's LLM approves it.
Jev for enterprise automation
Jev's enterprise pitch is a decision layer between an event and a workflow, priced low enough to run on every event. Integrations reported by MarkTechPost include email triage (Bryo AI), web agents (Browser Use), and mobile automation (Droidrun).
Calibrated confidence gives an enterprise one number to set an automation threshold against and audit over time. Against that, weigh a hosted-only model with early-access pricing that may change and no ability to explain its choice.
Definitions glossary
System One model: A class of AI model that returns typed decisions and probabilities from supplied state instead of generating text. In a VideoSDK app it sits between transcription or chat events and your routing logic.
Calibration: The property that a model's stated probabilities match observed accuracy across many predictions. It lets a VideoSDK moderation flow act automatically above a confidence threshold and escalate below it.
Real-time transcription: VideoSDK's feature that converts participant speech to text during a live session, controlled from theuseTranscriptionhook in React. Its output is the natural state input for Jev questions.
Key takeaways
- Jev returns typed answers with calibrated probabilities, not text, and evaluates every question in one parallel pass at $0.042 per million input tokens.
- "Cannot hallucinate" means schema conformance only. Answers can still be wrong, so threshold on confidence.
- Inside a VideoSDK application, Jev is the decision step after real-time transcription, live-stream chat, or a voice agent's proposed tool call.
Conclusion
The Jev AI model does one narrow thing at a price and speed that make per-event decisions affordable. It will tell you, in a few hundred milliseconds and with a confidence score, which queue a call belongs in or whether a chat message should be hidden. Pair it with VideoSDK real-time transcription and interactive live streaming, and the media pipeline and the decision layer run at the same speed. Start with the React quickstart and $20 in free credit at app.videosdk.live/login.
Which decisions in your live app still wait on an LLM round trip? Drop a comment or ask in the VideoSDK Discord.
FAQ