What Is Jev AI? TypeSafe's Decision Model, Pricing & Limits

Jev AI is an AI model from TypeSafe that makes quick decisions inside other software. Apps and automations call it behind the scenes through TypeSafe's API, much like many apps call OpenAI's or Anthropic's models.

You don't chat with Jev the way you chat with ChatGPT or Claude. Your app sends it some text and a list of possible answers, and Jev sends back its pick and how sure it is, so the app knows what to do next.

That makes it a good fit for jobs like sorting emails, routing support tickets, and checking an AI agent's actions before they run. It works alongside chat models: Jev makes the quick calls, and ChatGPT- or Claude-style models handle the writing.

Developers use it through TypeSafe's API and SDKs, and Claude Code or Codex can help write that code with TypeSafe's agent skill. If you don't code, you can try it in TypeSafe's Playground or connect it through Zapier, n8n, or Make.

I read TypeSafe's launch post and developer docs, plus its own list of where Jev still breaks, then checked the first reports from developers using it.

What is Jev AI?

Jev AI is TypeSafe AI's first System One model, a decision model released in early access on September 15, 2026. It picks an answer from options you define and returns a probability for each one, so software can act on the result right away.

TypeSafe uses System One to mean a class of model built for fast, structured decisions. The output goes straight to your code, and Jev skips text generation entirely (no replies, no code, no explanations of its reasoning).

Picture a sharp coworker who glances at a ticket, points at the right queue, and tells you how sure they are. That's roughly the job Jev does for software, and TypeSafe says it does it in 70 to 500 milliseconds.

Who built Jev

TypeSafe AI is a San Francisco company founded in 2024 by Diogo Almeida, Erik Gafni, and Sasha Sheng. It came out of stealth with $40 million in seed funding led by DCVC on the day Jev launched.

Almeida, the CEO, is a former OpenAI researcher. TypeSafe's team page credits him as a co-inventor of RLHF and InstructGPT, the methods that led to ChatGPT. His pitch for Jev is that chat models got superhuman at chat while automation lagged behind.

TypeSafe trains Jev with a method it calls Reinforcement Learning for Calibrated Decisions (RLCD), which teaches the model to attach honest probabilities to its answers. The version you'll call today is jev-1.13.0, per TypeSafe's models page.

The architecture is under wraps. TechCrunch reports that Almeida is tight-lipped about it, that Jev is trained only on synthetic data, and that outside observers suspect it's built on top of an open-weight LLM.

Where the name comes from

Both names are borrowed. "System One" comes from Daniel Kahneman's Thinking, Fast and Slow, where System 1 is the fast, intuitive mode of thinking and System 2 is the slower, more effortful one.

Jev is named after William Stanley Jevons, the 19th-century economist behind the Jevons paradox: after James Watt's steam engine made coal more efficient to use, England burned far more of it. TypeSafe expects intelligence to follow the same path as it gets cheaper.

(It has no link to FaZe Jev, the gamer.)

How Jev works

Every Jev call has the same shape: text goes in, typed questions go with it, and structured answers come back. Here's the loop, using the support-ticket example from TypeSafe's quickstart.

1. Send the state: The state is the context Jev reads, such as a ticket, an email, or a JSON record. It has to be text, and the whole request fits in a 64k-token budget, with the state plus your longest question capped at 32k.  
2. Ask typed questions: You write each question and its possible answers, like "Which team should handle this?" with billing, technical, and sales as the options.  
3. Get answers with probabilities: Jev returns a pick, a probability for every option, and a confidence score. In the quickstart, a customer stuck on a Stripe integration comes back as technical at 0.85 and billing at 0.15, with 0.78 confidence.  
4. Let your code act: Your code routes, flags, or waits based on those numbers.

That split, where the model makes the call and your code does the work, is the same idea behind most AI agent architecture, with Jev handling one narrow step very fast.

Here's the part of the request that defines that first question, trimmed from TypeSafe's docs:

"department": {

  "type": "choice",

  "instructions": "Which team should handle this",

  "criteria": {

    "billing": "Payment or subscription issues",

    "technical": "Bugs or integration problems",

    "sales": "Pricing or account questions"

  }

}

You can pack several questions into one request. They're evaluated in parallel against the same state, and TypeSafe's introduction says adding questions barely changes the response time.

The three question types

Jev understands three kinds of questions, which TypeSafe calls primitives:

• Choice: Picks one option from a list you define. "Which team should handle this ticket: billing, technical, or sales?"  
• Score: Rates the state against ordered levels you describe, and the answer can land between two levels (a 1.4 on a 0-to-2 scale, say). "How frustrated is this customer, from calm to very angry?"  
• Noul: Answers a yes-or-no question with a probability from 0 to 1. "Does this message ask for a refund?"

Those questions can mix all three types, so one request can tell you the team, the urgency, and whether a refund is on the table.

What the confidence score is for

Choice and Score answers come with a confidence number from 0 to 1, calculated from how spread out the probabilities are. One tall spike means Jev is sure. Probability smeared across three options means it's guessing, and it tells you so.

TypeSafe's confidence docs suggest splitting that number into three bands:

• High confidence: Act automatically.  
• Medium confidence: Ask the user to confirm, or flag it for review.  
• Low confidence: Hold off and send it to a person or a different system.

The bands move with the stakes. In TypeSafe's voice-banking example, a balance check goes ahead at 0.6, while a money transfer needs more than 0.85 before the system skips asking the user.

Jev AI vs a regular LLM

Jev and a chat model like ChatGPT or Claude solve different problems. These figures come from TypeSafe's launch post, so read them as the company's numbers. For the full breakdown, see how Jev compares to an LLM.

In most setups, you'll use both. TypeSafe's page on coding agents says Jev can't replace the model behind Claude Code or Cursor, because it doesn't stream text, call tools, or edit files.

So if you need a model that writes, one of the ChatGPT-style assistants is still the right pick. Jev slots in next to it for the quick calls.

How fast and cheap is Jev AI in practice?

TypeSafe puts Jev at 40x to 200x faster than frontier models on the same kind of query. Its headline figures, 193.6x faster and 444.6x cheaper, come from its own workflow evals.

To its credit, the launch post flags the catches itself. Members of TypeSafe's team built those workflows, some bias could exist, and the company expects the numbers to sit at the high end of real-world gains. Its speed tests ran from laptops on the West Coast, where its service is based.

TypeSafe also says Jev can't hallucinate or make type errors, because every answer has to be one of the options you defined. It can still pick the wrong valid option, so test its judgment on your own data.

Early outside results look promising. TechCrunch reports that Vercel swapped Jev in for an OpenAI model on a classifier that reviews commands for safety and got results 5 to 18 times faster, with greater accuracy.

In the same piece, Bryo AI's CTO, Nikhil Mudholkar, found Gemini slightly more accurate at classifying business emails, though 10 to 20 times more expensive. What caught his interest most was Jev's confidence scores.

Armin Ronacher, CTO of Earendil, summed up the tradeoff in that piece: a 50% answer is a coin toss you can ignore, and a 95% answer is one you can act on. Jev hands part of the hallucination problem back to you in the form of a threshold.

‍

{{templates}}

‍

Where Jev fits

Jev earns its keep on decisions that are too fuzzy for an if-statement and too repetitive to justify a full LLM call every time. Here are a few jobs TypeSafe and early builders point to, and you'll find 17 more in these Jev AI use cases:

• Support-ticket routing: A Choice picks the team, a Score rates urgency, and low-confidence tickets go to a person.  
• Sorting incoming requests: TypeSafe's intent-routing pattern classifies each message first, then sends it to plain code, a specialist LLM, or a human, so the expensive model only sees requests that need it.  
• A safety check before an AI agent acts: LangChain's Jev integration includes experimental middleware that checks an agent's tool calls and blocks risky ones before they run. Vercel's command-safety classifier is the same idea.  
• Picking which model handles a request: The same integration can send each request to a cheaper or stronger model, based on criteria you write.  
• Pulling fields out of documents: When the possible values are known, Jev picks the right one from a list of candidates. TypeSafe suggests finding candidates with regex or a generative model first.

Most of these live inside AI agents, where every step comes down to a small call about what to do next. That's the spot where a sub-second, fraction-of-a-cent decision adds up fastest.

What a decision model means for AI assistants

The same pattern shows up in work you probably already hand off. An assistant sorting your inbox makes a string of tiny calls: does this email need a reply, which label fits, is it urgent, is it a pitch you'll never answer.

A decision model like Jev turns each of those calls into a number. With that number, an assistant can handle the easy ones alone and check with you on the rest, the way you'd want a new hire to work in week one.

Take a request to cancel tomorrow's meeting and email the attendees. A careful setup might act on its own above 0.9 confidence, ask you below that, and always ask before deleting anything, since a wrong delete is hard to undo.

You'll see the same instinct in assistants built for work. Lindy, an AI teammate that lives in your company's Slack, waits for your approval before it does anything irreversible. Jev gives developers a way to put a number on that kind of check-in inside their own software.

Where Jev falls short

TypeSafe publishes its own list of Jev's rough edges, which it calls jaggedness. Read it before you build, because several items would surprise anyone coming from chat models:

1. It can't write: Jev isn't trained to generate text. If you need a reply drafted or a summary written, use a generative model.  
2. It reads instructions literally: Jev answers the question you wrote, word for word. If you catch yourself explaining what you meant, that explanation belongs in the instructions.  
3. It's weak at math, counting, and dates: TypeSafe's advice is to keep arithmetic, counting, and date comparisons in code. Jev can pull out the parts of a date, and your code should do the comparing.  
4. It only reads text: Images, audio, and video aren't accepted, so convert them to text or structured fields first.  
5. Extra context hurts: Accuracy drops as the state fills up with detail unrelated to the question. Filter before you send.  
6. It can be steered: Text written to manipulate the model, like an injected instruction, can move the answer. TypeSafe says it expects to improve here.  
7. English works best: Other languages, including Chinese, Japanese, and Korean scripts, are handled less well, according to the models page.  
8. Confidence can still be wrong: TypeSafe's System One page notes that calibration holds across many predictions and doesn't guarantee any single answer.  
9. The big numbers are self-reported: The speed and cost multiples come from TypeSafe's own evals, so benchmark on your own data before you commit.

‍

{{cta}}

‍

Jev AI pricing and where you can use it

Jev costs $0.042 per million input tokens, which TypeSafe also writes as $42 per billion. Output tokens are free, according to the models page.

For scale, a 1,000-token support ticket costs $0.000042 to classify, so a million of them runs about $42. Your questions count as input too, so budget a little extra.

Rate limits are currently 100,000 tokens per second and 80 requests per second, and TypeSafe warns they can change without notice while it adds capacity. (TechCrunch reported that demand briefly knocked out TypeSafe's ability to serve its API.)

Jev is still in early access, but there are already plenty of ways in:

• Get a TypeSafe key: TypeSafe's launch post says it's bringing developers off a waitlist as fast as it can, and the quickstart hands out keys from its dashboard.
• Try the Playground: Once you're in, TypeSafe's Playground lets you paste text, add questions, and see answers before you write any code.
• Call the API or an SDK: Send requests to the systemone endpoint directly, or use the Python SDK (pip install typesafe-sdk) or the JavaScript SDK (npm install @typesafe-ai/sdk).
• Use OpenRouter or Vercel: OpenRouter serves Jev 1.13 at the same $0.042 rate through your OpenRouter account, plus a separate Jev Router that uses Jev to pick a model for each request. Vercel's AI Gateway can call Jev too.
• Run it inside Google's AlloyDB: A Google codelab shows how to register Jev as a model endpoint and call it from SQL, right where your data lives.
• Plug into developer tools: LangChain ships a langchain-typesafe package, and TypeSafe publishes an agent skill for Claude Code, Codex, and other coding agents.
• Skip the code with Zapier, n8n, or Make: Zapier's TypeSafe Jev app has an Ask Questions action, n8n added an official TypeSafe AI node, and Make has a TypeSafe app for its scenarios.

One warning: at least one site branded "Jev AI" sells $10 to $1,000 credit bundles and says in its own footer that it isn't affiliated with TypeSafe. TypeSafe's pages list per-token pricing only, so check the domain before you pay anyone.

Give Jev AI the small decisions your software makes all day

Jev AI shines on the unglamorous calls: which queue, how urgent, is this safe, does a human need to see it.

If your software makes those calls thousands of times and pays an LLM to write a paragraph about each one, Jev deserves a trial run, whether you wire it in with code or through Zapier, n8n, or Make.

Start with one low-risk decision, measure it against what you run now, and set your confidence thresholds before anything goes live.

Frequently asked questions

Is Jev AI a chatbot?

No, Jev AI is a decision model for software, so you don't chat with it. It returns typed answers, like a pick from your list or a yes-or-no probability, and it can sit inside a chatbot as the part that routes or checks messages. For the wider distinction, see how AI agents and chatbots differ.

Can I use Jev in ChatGPT or Claude?

Jev is a separate model, so you use it through TypeSafe's API or tools like Zapier, n8n, and Make. Claude Code and Codex can write code that calls Jev with help from TypeSafe's agent skill. Most setups pair the two: Jev makes the quick decisions, and the chat model writes.

What does Jev stand for?

Jev doesn't stand for anything. TypeSafe named it after William Stanley Jevons, the 19th-century economist behind the Jevons paradox, and took the "System One" label from Daniel Kahneman's idea of fast, intuitive System 1 thinking.

Can Jev replace an LLM?

Jev can replace an LLM on bounded decisions like classification, routing, and yes-or-no checks, where TypeSafe says it's far faster and cheaper. It can't write text or code, so most setups pair Jev with a generative model.

How much does Jev AI cost?

Jev AI costs $0.042 per million input tokens, and output tokens are free, per TypeSafe's models page. That per-token rate is the only pricing TypeSafe lists on its own pages.

Can I use Jev AI without code?

Yes, you can use Jev AI without code. Try it in TypeSafe's Playground by pasting text and adding questions, then put it into real workflows through Zapier's TypeSafe Jev app, n8n's TypeSafe AI node, or Make's TypeSafe app.

Is Jev AI open source?

Jev AI is proprietary. TypeSafe hasn't published the model's weights or full architecture, and it serves the same weights to every account through its API.