What Is Jev AI? TypeSafe’s System One Decision Model

Jev (often searched as Jev AI) is TypeSafe AI’s first System One model: you send program state plus typed questions, and it returns calibrated decisions—choices, scores, or yes/no probabilities—without writing chat text. It is built to be called by software and agents, not read by an end user.

If you are evaluating decision models for routing, scoring, guardrails, or agent control loops, this guide covers what Jev is, how it differs from LLMs, the three question primitives, pricing and latency claims, and how to call it through TypeSafe’s API or Vercel AI Gateway.

Official entry points:

• Launch post: Introducing System One Models and Jev
• Product site: typesafe.ai
• AI Gateway + AI SDK: How to classify, route, and score with Jev

Key Takeaways

• Jev returns typed choice, score, and boolean/noul answers with probabilities—not free-form prose—so your code can branch without parsing chat.
• TypeSafe prices input at $0.042 per million tokens with free output, and reports end-to-end latency in the 70–500 ms range on System One–shaped tasks (TypeSafe launch post, Sep 15, 2026).
• On Vercel, use model ID typesafe-ai/jev with AI SDK 7’s experimental_evaluate API (Vercel changelog, Sep 16, 2026).
• Use Jev for classify / route / score / verify loops. Keep a frontier LLM (or an editor like Cursor) when you still need generation, planning, or tool-calling prose.

What problem does Jev AI solve?

Most production “AI in the product” work is not chat. It is a flood of small judgments: which queue owns this ticket, how urgent is this event, should the agent retry or stop, does this output look unsafe.

Large language models can approximate those judgments, but they were trained to produce strings. Your app then parses, validates, retries, and hopes the format holds under load. Probabilities in the text are usually prompted estimates, not a first-class output.

Jev flips that interface. TypeSafe describes it as a frontier-intelligence function call: unstructured or structured state in, typed probabilistic decisions out (TypeSafe). Because the answer shape is fixed by your request, the model cannot invent a new enum value or emit an invalid type—it can only choose among the options you declared, place a score on your scale, or return a probability in [0, 1].

That is why developers searching “Jev AI” are usually comparing it to structured-output LLM calls, not to coding copilots.

Why “System One”—and why the name Jev?

TypeSafe borrows Daniel Kahneman’s framing from Thinking, Fast and Slow: System Two is slow, verbal, deliberative reasoning (what LLMs imitate when they write out an answer); System One is fast judgment. Jev is aimed at the software equivalent of that fast path—millions of small decisions that should not require a paragraph of generated text.

The product name nods to William Stanley Jevons and Jevons paradox: as the cost of a resource falls, demand for it often rises. TypeSafe’s thesis is that cheaper, machine-native intelligence will unlock far more in-product decision volume, not just better chatbots (TypeSafe FAQ in the launch post).

The company emerged from stealth in September 2026 with about $40M in seed funding led by DCVC. Founders include former OpenAI researcher Diogo Almeida (linked to RLHF / ChatGPT-era work), with Erik Gafni and Sasha Sheng (SiliconANGLE, Sep 16, 2026). TechCrunch covered the developer reaction and the “not an LLM” positioning a few days later (TechCrunch, Sep 18, 2026).

How Jev works: RLCD and three question types

TypeSafe trains Jev with a method it calls Reinforcement Learning for Calibrated Decisions (RLCD). The stated goal is calibration: when the model reports high confidence, accuracy on that band should track that confidence, so your code can set thresholds and escalate the uncertain remainder (What is Jev).

Every question you send is one of three primitives (names differ slightly by channel):

You can ask several questions in one request. TypeSafe and Vercel both emphasize parallel evaluation: questions are scored against the same state without forcing one autoregressive essay that answers everything at once (Vercel AI SDK guide).

Naming tip: TypeSafe’s native API uses noul for the yes/no probability. AI SDK over AI Gateway maps the same idea to boolean with a probability field. When you port examples, rename the type—do not copy paste blindly.

Jev vs a large language model

Use this table when someone asks “is Jev just a smaller LLM?”

TypeSafe’s launch materials claim Jev sits near frontier intelligence on System One–shaped workflow evals while being up to roughly two orders of magnitude faster and cheaper; homepage figures such as 193.6× faster and 444.6× cheaper come from those workflow evals and sit at the high end of expected real-world gains (TypeSafe; echoed by Vercel). Treat those as vendor evals: useful directional signal, not a substitute for measuring your own ticket or agent traces.

Important honesty check: schema-matching and “no type errors by construction” do not mean the semantic answer is always correct. Your application still needs thresholds, human review paths, and labelled samples for calibration (Vercel guide).

Calling Jev: TypeSafe API vs Vercel AI Gateway

Direct TypeSafe System One API

TypeSafe exposes evaluation on a System One endpoint (commonly documented as POST /v1/systemone). You send:

1. A model id (jev-1.13.0, or aliases such as jev-latest)
2. A state (string, JSON object, or text array)
3. A questions map keyed by your own IDs

Auth is a Bearer API key from TypeSafe early access. Pin a versioned model id once you tune thresholds—aliases move when TypeSafe ships releases.

Vercel AI Gateway + AI SDK 7

Since September 16, 2026, Jev is available on AI Gateway as typesafe-ai/jev (Vercel changelog). AI SDK 7.0.105+ exposes experimental_evaluate.

Minimal boolean example (adapted from Vercel’s docs):

import { experimental_evaluate as evaluate } from 'ai';
 
const result = await evaluate({
  model: 'typesafe-ai/jev',
  state: 'The support agent issued a full refund to the customer.',
  questions: {
    refunded: {
      type: 'boolean',
      instructions: 'Was a refund issued?',
    },
  },
  providerOptions: {
    gateway: { zeroDataRetention: true },
  },
});
 
console.log(result.answers.refunded.probability);

Gateway docs also list a TypeSafe-compatible base URL (https://ai-gateway.vercel.sh/typesafe) if you keep the TypeSafe SDK and only change auth/base URL (AI Gateway TypeSafe docs).

At-a-glance Gateway numbers from Vercel’s guide (verify on the live model page before budgeting):

• Context window: 32,000 tokens
• Pricing: $0.042 per 1M input tokens; no output charge
• Data controls: Zero Data Retention and No Training, per request when enabled

Practical patterns that fit Jev well

These are the jobs where “typed decision + confidence” beats “ask ChatGPT and parse JSON”:

1. Support triage — department choice, severity score, refund intent boolean in one round trip.
2. Agent control — continue / retry / ask user / stop as a choice over the latest tool trace.
3. Guardrails — score jailbreak risk or policy violation before a write action.
4. Map-reduce style labeling — fan out many independent questions over logs or tickets where latency and unit cost matter.
5. Real-time loops — demos like TypeSafe’s Doom bot highlight sub-second reactive decisions on structured state (still text/state today, not raw pixels).

Pairing tip: keep generation and long-horizon planning in an LLM or coding environment such as Cursor. If you care about the agent runtime layer (tools, sandboxes, traces), compare harness designs like DeepSeek Harness and our DeepSeek Harness plugin runtime guide. Jev is a decision primitive you drop into those loops—not a replacement for the editor or the harness.

When not to use Jev

Skip or demote Jev for:

• Drafting emails, docs, or marketing copy
• Writing or refactoring code as the primary output
• Open-ended research that needs long reasoning traces as the product
• Multimodal inputs (current public positioning is text / structured text state; do not assume vision)

Also skip if you cannot define options or rubrics in advance. System One models shine when the decision space is declared. If you do not know the label set yet, you still need discovery work—often with an LLM—before Jev can encode the policy.

Getting started checklist

1. Write down 3–10 decisions your code already makes with brittle rules or LLM JSON.
2. Encode each as choice, score, or boolean/noul with crisp instructions and criteria.
3. Collect a small labelled set and tune thresholds (auto-act vs review) per decision, not one global cutoff.
4. Call via AI Gateway if you already ship on Vercel; otherwise use TypeSafe early access.
5. Log the resolved model version, probabilities, and your branch so you can re-calibrate when aliases move.

Frequently Asked Questions

Is Jev AI the same as ChatGPT or other chat models?

No. Chat models optimize for fluent text people read. Jev optimizes for typed decisions software can branch on. Many teams will use both: an LLM for generation, Jev for high-volume judgment.

Is Jev open source? Can I run it locally?

Public materials describe a hosted early-access model; TypeSafe has not published weights as a local open model. Community projects advertise “Jev-like” interfaces on commodity models, but those are not official TypeSafe releases—evaluate calibration yourself.

What does Jev cost?

TypeSafe’s launch post and Vercel’s AI Gateway guide list $0.042 per million input tokens with free output. Per-decision cost depends on how large your state and question text are; TypeSafe’s consumer-facing explainers often cite roughly $0.0004 per decision as an illustrative average—measure on your payloads.

How do I try Jev without building a full product?

Join TypeSafe early access at typesafe.ai, or call typesafe-ai/jev through Vercel AI Gateway with AI SDK’s evaluate helper if you already have a Vercel project.

Closing

Jev AI is best understood as a new interface class, not a faster chatbot: state and declared questions in, calibrated typed answers out. If your roadmap is full of classify / route / score / verify steps that currently abuse JSON-mode LLMs, System One models are worth a serious prototype—with thresholds, review paths, and your own labelled evals before you trust automatic action.

Next reading on this site: DeepSeek Harness plugin-first agent runtime for the surrounding agent loop, and Cursor overview when the job is still editor-native coding help.