What is Jev? Use cases for TypeSafe's decision model in your product

What is Jev AI model and how to use it in your product

Jev is a decision model, not a chat model. What Jev does differently from an LLM, and 8 features in a typical SaaS product where you can plug it in today.

Jev is an AI model that answers questions about your data with a decision instead of a paragraph. You send it your app's state and a typed question ("which team handles this ticket?", "is this signup fraud?", "how urgent is this, 1 to 5?") and it returns the answer as a value from a set you defined, with a probability attached: "billing 84%, technical 16%". It responds in 70 to 500ms and costs $0.042 per million input tokens, output free. That's roughly 40x to 200x faster and cheaper than asking a frontier LLM the same thing.

The model was released on September 15, 2026 by TypeSafe AI, founded by Diogo Almeida, who co-invented RLHF and InstructGPT at OpenAI. It's already on OpenRouter. Matija Sosic's 45 second TL;DR is the fastest way to get the idea:

If you already have an LLM somewhere in your product doing "answer with one of: X, Y, Z as JSON", Jev is built to replace that call. Below: what exactly is different from an LLM, the 3 question types with code, 8 places in a typical SaaS where it fits, where it doesn't, and how to get access today.

How Jev differs from a regular LLM

Most products already use an LLM for small decisions: route this ticket, flag this comment, pick the next tool. The usual way is to write a prompt that says "answer with one of: billing, technical, sales, as JSON", parse the string, validate it, retry when it comes back wrong. Jev removes that whole layer.

	LLM	Jev
Output	Text you parse	A typed value from a set you define
Wrong shape possible	Yes, needs validation and retries	No, the output space is fixed
Confidence	You ask for it and hope	Every answer comes with a calibrated probability
Latency	Seconds	70 to 500ms end to end
Price	GPT-5.6 Terra: $2 in, $12 out per million	$0.042 in, output free
Questions per call	One prompt	Several questions about the same state at once

The speed comes from a different sampler: instead of generating tokens one after another, Jev produces all answers in a single parallel pass. The calibration comes from a different training method, RLCD (Reinforcement Learning for Calibrated Decisions), which optimizes for probabilities that match how often the answer is right, rather than for pleasing a human rater.

"No hallucinations" in TypeSafe's marketing means the output can't be malformed or outside the defined set. The model can still pick the wrong option. The difference is you get "billing 84%, technical 16%" and can act on the 16%.

3 question types: noul, choice, score

Every Jev call is one or more of these:

Noul: yes or no, returned as a probability from 0 to 1. "Is this customer about to churn?"

Choice: one option from a set you define, up to 255. "Which of these 5 queues does this go to?"

Score: a number on a scale you define, 2 to 10 levels. "How urgent is this, 1 to 5?"

TypeScript

Loading editor...

import { choice, noul, score, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();
const res = await client.systemOne({
  state: { ticket: "I was charged twice this month and nobody replies" },
  questions: {
    queue: choice("Which team handles this?", {
      billing: "payments, refunds, invoices",
      technical: "bugs, outages, integrations",
      sales: "pricing, upgrades, contracts",
    }),
    urgent: noul("Does the customer need a reply within the hour?"),
    sentiment: score("How frustrated is the customer?", { levels: 5 }),
  },
});

res.answers.queue.choice;        // "billing"
res.answers.queue.probabilities; // { billing: 0.84, technical: 0.11, sales: 0.05 }
res.answers.urgent.noul;         // 0.71
res.answers.sentiment.score;     // 3.8

You get a useful response with 3 decisions, all under half a second.

Where to use Jev in your product

Jev is built for the decisions software makes millions of times a day. Here are the ones that show up in almost every product.

Route support tickets to the right team

State is the ticket text plus whatever you know about the account (plan, tenure, open incidents). Ask a Choice for the queue, a Noul for urgency, a Score for priority. Because you get probabilities, you can auto-route above 0.9 and send anything in the middle to a human triage view instead of guessing.

Moderate user content before it goes live

Ask a Noul: "Does this comment violate the policy against hate speech or harassment?" and pass the policy text as part of the state. safer-with-jev.com runs a public demo of exactly this, and reports jevMs, the server time per call, so you can see it's fast enough to run on every post before it's published rather than in a batch afterwards.

Screen LLM inputs and outputs for prompt injection and leaks

If your product has an LLM in it, you have 2 untrusted boundaries: what the user sends in and what the model sends out. On the way in, a Choice classifies input as clean, instruction override ("ignore previous instructions...") or disclosure attempt ("reveal your system prompt"). On the way out, a Noul checks whether the generated reply leaks a secret, exfiltrates tool arguments, or breaks policy. At 70 to 500ms and $0.042 per million tokens you can afford to run this guard on every single message, which you can't with a frontier model.

Flag fraudulent signups

State is the signup form, email domain, IP metadata, and behaviour so far. Ask a Noul: "Does this signup look fraudulent?" Set your own thresholds: block above 0.95, add a verification step between 0.6 and 0.95, let the rest through. Calibrated probabilities are the whole point here; a text model that says "likely fraud" gives you nothing to threshold on.

Pick the cheapest model that can handle the request

Not every request deserves your most expensive model. Send a summary of the request to Jev with a Choice over your model list ("simple lookup", "code generation", "long reasoning", "needs vision") and dispatch accordingly. jev-router is an open source LiteLLM proxy that does this: a pre-call hook summarizes the messages, filters models by capability, and lets Jev pick, with a rules-based fallback when it's not configured.

Choose the next step for an agent

Agents make dozens of small choices per run: which tool next, is the task done, should I retry. Each one through a frontier LLM costs seconds. Move the routine ones to Jev: a Choice for the next step, a Noul for "does this tool call need human approval?", a Noul for "should this workflow pause for a human?". Keep the LLM for the steps that need reasoning or text. This is the "smart if-statement" pattern TypeSafe pushes in the announcement, and it's where the 190x speedup claims come from.

Check LLM answers before showing them to users

After a frontier model drafts a reply, ask Jev: "Does this answer the user's question?", "Does it contradict the source document?", "Does it contain a price we didn't quote?". Cheap enough to run on every response, fast enough that the user won't notice the extra hop.

Tag and score millions of records

Any map-reduce job over user content: classify 2 million reviews by topic, score every lead by fit, flag every commit message that looks like a hotfix. At output-free pricing, a million short inputs costs a few dollars and finishes in minutes instead of hours.

Where not to use it

Jev does not generate text, so it can't draft the reply, write the code, or explain its reasoning. It is unreliable for counting, arithmetic, and date comparisons, and it reads instructions literally: negations and contradictory criteria misfire. Irrelevant state degrades accuracy, so filter what you send. And like any classifier, user-controlled content can steer it, so don't make it the only line of defence.

The pattern that works is a cascade: code first, Jev for the judgement calls that code can't make, a frontier LLM only when you need prose or deep reasoning.

How to get access

Two ways:

TypeSafe directly: early access with a waitlist at typesafe.ai. SDKs for Node 20+ (@typesafe-ai/sdk) and Python 3.10+ (typesafe-sdk), or POST https://api.typesafe.ai/v1/systemone.

OpenRouter: Jev is available in beta as typesafe/jev-latest (or a pinned version like typesafe/jev-1.13) at the same $0.042 per million input tokens, output free, 32k context. If you already route models through OpenRouter, this is the fastest way to try it without a waitlist.

TypeSafe's benchmarks use the average of GPT-6 Astra and Fable 5.1 as the reference answer and report up to 190x faster and 440x cheaper on their published workflows. They also say those are "on the higher end of real world gains". Treat them as a ceiling and measure on your own traffic.

Explore the full stack

100+ modern dev tools and platforms for building startups, reviewed and compared.

Browse Stack

Ship faster than
your competition

Focus on customers and sales while we handle product delivery. Hire a dedicated AI maker or a whole product team.

Launch new products

Fix your delivery

Hit fundraising milestones

View recent work

[Analytics Chart]

Wireframe v0.1

Sarah Chen CEO, Founder

$127k

MRR

2,847

Customers

+23%

Growth

Sales Performance

Latest Deal

Enterprise plan closed

Acme Corp · $12k/mo

Full-stack development

Build a custom-coded web/mobile SaaS

Integrate AI

Use OpenAI and other AI APIs to build your SaaS

UI/UX design

Design the product MVP before building

Release regularly

Keep your customers engaged with regular fixes and updates

Resources

Kickstart No-Code Stack Tech Stack Tech Trends AI SaaS Skills MCP Servers Academy Help Center Blog Changelog

Our products

Showroom Ship Clipwing Fireprompts Momentum Salt & Bold

AI Tools

AI Studio Landing Page SaaS Dashboard Features Grid Marketing Strategy UX Prototype MVP Assets Meta Tags Preview

Hire

Claude Code Devs Next.js Devs React Devs React Native Devs Supabase Devs Lovable Devs AI Engineers Full-stack Devs Upwork Alternative

https://www.linkedin.com/company/paralect

https://medium.com/particles-by-paralect