New Jev Model is Insane! 200x Faster & 400x Cheaper Than Frontier Models

In less than 72 hours, TypeSafe AI launched Jev. A new model that skips text generation to achieve up to 200x faster and 400x cheaper performance than frontier models. People are calling it “the future” already.

My biggest problem as an indie dev is the rising cost of frontier models. Many other devs feel the same. Go check out the hate comments on social media.

I dumped Claude a few weeks ago because of how expensive Fable 5.1 is. When OpenAI Astra was released, Tibo gave us a handful of weekly resets, which was super cool! Even then, it was not enough now that the weekly resets are gone, it is not enough.

OpenAI needs a lot of improvement in terms of token management. Anthropic too. We are constantly charged for thousands of input tokens and verbose conversational output tokens when all our code actually wanted was a single boolean flag.

Tbh, I do not really mind the speed. Coding models are already fast enough for my coding use case. Cost is just not acceptable anymore. That is why I find Jev a very interesting model. It promises the biggest advantage I have been begging for, which is near-zero cost for structured decisions.

I spent time digging into the architecture, the benchmarks, and the early developer reactions.

What is Jev?

Jev is the first public entry in a category TypeSafe AI calls System One models.

The company was founded by Diogo Almeida, a former OpenAI researcher who worked on InstructGPT and the early foundations of Reinforcement Learning from Human Feedback.

“I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev”

To understand why this model exists, you have to look at the name and the underlying cognitive theory.

The name comes from William Stanley Jevons, the 19th-century British economist famous for the Jevons paradox. In 1865, Jevons observed that when steam engines made coal consumption vastly more efficient, overall coal usage did not decrease. It exploded. Making a resource radically cheaper made people deploy it everywhere.

TypeSafe is betting the exact same economic rule will apply to software decisions.

The term System One comes directly from Daniel Kahneman’s cognitive framework in Thinking, Fast and Slow.

Human cognition operates on two gears.

1. System 1 is fast, automatic, subconscious, and intuitive. When you glance at an angry facial expression or answer what two plus two equals, you do not sit down with scratch paper. Your brain surfaces the answer instantly.
2. System 2 is slow, analytical, deliberate, and effortful. If someone asks you to multiply seventeen by twenty-eight, you pause. You hold intermediate states in your working memory and calculate step by step.

Every major frontier language model we use today behaves strictly like System 2. They reason out loud, calculating one word after another in a linear sequence.

System 2 (Frontier LLMs):
Input Context -> Token 1 -> Token 2 -> Token 3 -> ... -> Verbose JSON Output
Cost: High ($3 - $15 per million tokens)
Latency: 3 to 15 seconds

System 1 (Jev Architecture):
Input State + Bounded Questions -> Single Parallel Forward Pass -> Typed Probabilities
Cost: Near Zero ($0.042 per million input, $0 output)
Latency: 70 to 300 milliseconds

Jev does not write essays for you. It does not produce marketing copy, and it will not write your next software feature. It takes unstructured state, evaluates bounded questions against that state, and returns typed decisions with calibrated probabilities.

How Jev works

The technical bottleneck of modern language models sits in how transformers generate tokens.

A standard transformer is autoregressive. If you ask a chat model to classify a customer email, the model has to project its internal vector state across a vocabulary of over 100,000 potential tokens.

It samples one token, adds that token back into the context window, and runs another entire forward pass through dozens of GPU transformer layers just to predict the next word.

If your model produces a 60-token JSON response, your hardware runs 60 separate sequential passes. Memory bandwidth bounds the process. Step 40 cannot physically run until step 39 finishes.

Check out the side-by-side comparison of Jev against an LLM:

Jev breaks that autoregressive loop by constraining the candidate answer space before inference begins.

Instead of predicting open-ended words across an enormous vocabulary, Jev evaluates three explicit typed primitives against an ingested state.

Jev’s three types of supported questions. Image from Langchain

1. Choice: You provide a question and a closed set of options, up to 255 items per call. Jev evaluates the input state against those options in parallel and outputs the winning label alongside an exact confidence score.
2. Score: You establish a continuous scale or an ordered rubric, like evaluating customer sentiment from one to ten, or grading technical debt from low to critical. Jev places the state on that scale and returns the position with confidence metrics.
3. Noul: This is a binary probability primitive, which Vercel surfaces simply as a boolean. It determines whether a specific condition is true or false, returning a raw floating-point probability between 0.0 and 1.0.

Because the answer candidates are strictly defined, Jev does not generate arbitrary strings. It processes all questions against the state in a single, parallel forward pass.

// How a System One evaluation call looks in TypeScript
import { typesafe } from "@typesafe/sdk";

const decision = await typesafe.decisions.create({
  model: "typesafe/jev-1.13",
  state: {
    userTier: "free",
    daysActive: 4,
    lastAction: "export_csv_failed",
    ticketText: "My export button is broken and I have a client meeting in an hour!"
  },
  questions: {
    urgent: {
      type: "noul",
      instruction: "Does the user express urgent time sensitivity?"
    },
    intent: {
      type: "choice",
      options: ["bug_report", "billing_inquiry", "feature_request", "churn_risk"]
    },
    churnRisk: {
      type: "score",
      range: [1, 5],
      rubric: "1 means completely satisfied, 5 means actively looking to leave"
    }
  }
});

Here’s an easy to understand animation of how Jev works.

This architecture sparked a debate on the LocalLLaMA subreddit. Several developers pointed out that this structure looks identical to Natural Language Inference (NLI), a classic NLP task that researchers solved years ago using classification heads on top of BERT or RoBERTa.

In one Reddit post, someone claimed they built this exact setup a year ago with open-weight sequence classifiers.

Reddit: I literally built the Jev architecture one year back. Image by Jim Clyde Monge

I checked the details and found it almost similar to how Jev works, but there are, of course, differences. Fine-tuning a local BERT classifier requires collecting hundreds of labeled training pairs for every single business logic change, hosting dedicated endpoints, and babysitting model drift. Jev brings frontier-grade zero-shot reasoning to arbitrary programmatic questions without requiring a custom dataset or retraining.

Another interesting detail is how TypeSafe trained the model.

They discarded traditional Reinforcement Learning from Human Feedback (RLHF), which encourages models to sound polite and persuasive to human evaluators.

Instead, they developed Reinforcement Learning for Calibrated Decisions (RLCD).

Traditional RLHF:
Objective: Maximize human rater approval
Side Effect: Overconfidence, hallucinations, sycophantic agreement

TypeSafe RLCD:
Objective: Statistical calibration of probability distributions
Result: A 0.85 score means the model is verifiably right 85 out of 100 times

In standard chat models, confidence scores are notoriously unreliable. A chatbot will sound 100 percent convinced of a completely hallucinated citation.

RLCD forces statistical calibration. If Jev evaluates a batch of decisions and assigns them an 80 percent probability, roughly 80 out of 100 of those evaluations will be objectively accurate.

TypeSafe also touts a 0 percent structured output error rate.

It is guaranteed by construction. Because Jev never decodes text tokens, it is physically incapable of emitting broken curly braces, unescaped quotes, or invalid keys.

However, schema validity is not semantic truth. Jev will never break your JSON parser, but if your instructions are poorly phrased, it can still pick the wrong option.

In TypeSafe’s benchmarks, the error rate for Jev is literally 0%.

TypeSafe’s benchmarks on Jev’s error rate. Image by TypeSafe AI

How it achieves 20x to 200x speed

In official workflow evaluations, TypeSafe reports speedups ranging from 19.3x to 193.6x over frontier models.

On live public endpoints like OpenRouter and TypeSafe’s hosted API, measured end-to-end latency tells a very consistent story.

LLMs vs Jev in terms of end-to-end latency. Image by Jim Clyde Monge

One architectural leverage comes from what TypeSafe calls speculative fan-out.

In an autoregressive setup, asking five questions about an incident report means either chaining five separate API calls or packing them all into a giant prompt. With every added question, the model generates more output tokens, directly multiplying your latency.

Jev inverts this dynamic. The input state is encoded once into GPU memory. Every declared question is then evaluated concurrently across that same cached state representation.

Asking Jev ten questions takes almost the exact same wall-clock time as asking it a single question. In real-world workflow evals, batching thirteen distinct analytical questions across a large document is completed ten times faster than asking those questions sequentially with a chat model.

To prove how low this latency really is, TypeSafe showcased Jev running inside real-time interactive game loops.

In one demo, Jev played Doom in real time by reading game memory state as structured text and firing off action choices ten times a second.

In another demo, it piloted a character in Subway Surfers, making split-second obstacle dodging decisions in milliseconds.

No developer in their right mind would plug Claude or GPT into an active game loop. Jev turns AI evaluation from an asynchronous background queue into an inline operation.

Jev is almost free

For developers like me who get annoyed watching their monthly API expenses climb, the pricing sheet for Jev feels impossible.

TypeSafe lists input tokens at $0.042 per million. That works out to roughly $42 per billion tokens. Output tokens are listed at exactly $0.00.

Output is free because the model produces zero output tokens. It never runs a decoding sampler to generate text. It simply populates an array of float probabilities and typed indices.

TypeSafe reports total workflow cost reductions of up to 444.6x compared to frontier chat models.

LLMs vs Jev in terms of cost. Image by Jim Clyde Monge

When you use Claude Sonnet 5 or Opus 5 for classification, you are paying a massive premium for capability you do not even use. You pay to stream English sentences when all your database needs is a category tag.

This is why indie hackers feel so squeezed right now. When Anthropic or OpenAI tweak their pricing or tighten usage windows, solo developers get hit hardest. We cannot afford enterprise volume agreements.

With Jev, you can evaluate 10,000 user inputs, classify them against your custom schema, run safety checks, and pay less than five cents total. That completely changes what an indie dev can realistically ship.

How to access the Jev model

The direct platform access is currently gated through an early-access waitlist. Here’s the link to join the waitlist.

You have three primary integration routes available today.

• Direct TypeSafe API: Hosted directly at api.typesafe.ai, with official client SDKs for Python and TypeScript. You pass your API key, define your shared state, and configure your question schema.
• Vercel AI Gateway: Vercel has integrated Jev directly into their AI SDK via an experimental evaluation endpoint. If you are already building on Next.js or hosting on Vercel, you can swap your evaluation logic over with minimal configuration.
• OpenRouter: If you already route traffic through OpenRouter, Jev is accessible under the model identifier typesafe/jev-1.13. OpenRouter forwards requests straight to TypeSafe with zero markup, maintaining the native $0.042 per million input pricing.

Here’s what’s fun: Jev is currently available for free on Vercel AI Gateway until September 25.

The usage is very simple. Here’s an example:

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?',
    },
  },
})

Vercel CEO Guillermo Rauch even said that it could be the new default on Vercel AI Gateway. How cool is that?

I have yet to set up and experiment with this model, but I found a comprehensive post from Moritz Kremb that you can check out below.

More things to know about

Before you switch models or tear down your production pipelines to rewrite everything around Jev, there are several hard engineering constraints you need to keep in mind.

First, context windows are bounded. Jev supports up to 64,000 tokens total across the input state and all declared questions combined, with a cap of 32,000 tokens for the state plus your single longest question. If you are analyzing massive codebases or multi-hundred-page PDFs, you still need an upfront chunking or retrieval strategy.

Justin Schroeder put it well in one of his posts about the cost constraint.

Second, the option space is capped. A Choice primitive can accept up to 255 options per question. If you run an e-commerce platform with 10,000 product categories, you cannot pass the entire catalog into a single question. You have to build a two-stage hierarchical funnel where Jev narrows down the department first before selecting the specific shelf.

Third, remember that Jev does not eliminate generative models. It liberates them.

When your application needs to write a thoughtful response, summarize a nuanced argument, or generate code, you still need a frontier reasoning model. But using a 70-billion-parameter chat model to decide whether a user clicked a button or needs a password reset is engineering malpractice.