Product Strategy

Jev: The Model That Decides in 70ms and Can't Write

The first System One models just shipped. How the math changes when a typed decision costs 70 milliseconds instead of two seconds, and three places it shows.

Published on September 21, 202614 min read

A customer writes to your support team at 11:12pm. Before a reply goes out, your product has to settle four things: sales question or technical one, urgent or not, does someone need to be paged, does the tone of the message signal a customer about to churn.

That is four closed-ended questions, asked through four calls to a reasoning model at two seconds and a cent each. Eight seconds and four cents go by before anyone starts writing the reply, even though none of the questions asks for writing: each one is a choice from a list.

TypeSafe just shipped Jev1, the first entry in a model class they call System One. It can't write: no text ever comes out, only a typed value with a probability attached. TypeSafe announces 70 to 500 milliseconds end to end, $0.042 per million input tokens, and free output.

This article looks at what that shift changes about scoping an AI product: what the "can't hallucinate" claim actually covers (less than it sounds like), three places where the math flips, and what you can do today, with the models you already have, to be ready for the day you plug in the other kind.

Three words before we start

  • system 1 and system 2: two modes of thought that psychology tells apart. System 1 judges fast and without conscious effort: recognizing a face, sensing that a sentence sounds off. System 2 reasons slowly: working through a division, comparing two contracts. Today's language models are System 2 machines used, at scale, for System 1 tasks;
  • a structured output is a response whose shape is known ahead of time: one value out of five, a boolean, a number between 0 and 100. Today you get it by asking a text-producing model for JSON, for instance with generateText with Output.object2, then validating that text. The shape is hoped for, not guaranteed;
  • calibration3 is the property that gives a confidence score its meaning. A calibrated model that claims 80% is wrong roughly two times out of ten. An uncalibrated model can claim 95% and be wrong one time in three.

That third point is the one that matters for a product. Without calibration, the score is just interface decoration. With it, it becomes a threshold, and therefore a rule for automation.

Count the decision share of your product

Take a typical user session and sort your model calls into two columns. On one side, the ones that produce text meant for a human. On the other, the ones that produce a value only your code reads: routing to the right agent, choosing a tool, classifying an attachment, deciding whether to rerun a search, scoring a reply before it's shown, extracting six fields from a document.

On the agentic products I ship, the second column is the longer one. A single loop turn holds one generation and several decisions.

What the call doesNatureWho reads the outputTolerable latency
Draft the reply to the customergenerationa humana few seconds, streaming keeps the user occupied
Classify the requestdecisionyour switchnone, it has to stay invisible
Choose which tools to loaddecisionyour orchestratornone, it precedes the work
Score the reply before sendingdecisionyour guardrailnone, it blocks rendering
Extract six fields from a PDFdecisionyour databasea few minutes in batch processing

A generation is allowed to be slow: streaming keeps the user occupied while it runs. A decision doesn't get that luxury: it sits before or after the visible moment, adding its latency with nothing to show for it. So you pay full price, in seconds and cents, exactly where the user sees no return.

What Jev gives up, and what it buys with it

Jev gives up producing text entirely. In exchange, it gets three things a generative model can't offer.

It computes everything at once. A language model writes token by token, each one conditioned on the ones before it. A forty-token output means forty sequential passes. Jev produces its entire output in a single parallel pass1. TypeSafe credits that parallel sampler for its speed.

Its output is typed by construction. The schema is the actual structure of what the model produces, with zero type errors by mathematical guarantee, according to TypeSafe1. The try/catch around JSON.parse goes away.

It states its confidence, and that confidence is trained. TypeSafe built a dedicated method, RLCD for Reinforcement Learning for Calibrated Decisions1, which optimizes for honest probabilities where the industry optimizes on RLHF4.

Reference modelsJev
End-to-end latency13 to 329s70 to 500ms
Input tokensfrontier pricing$0.042 / MTok
Output tokensfrontier pricingfree
Schema compliancevalidated after the factguaranteed
Confidence scoreabsent or uncalibratedcalibrated through training, per TypeSafe

On their own workflow benchmark1, TypeSafe claims 193.6x faster and 444.6x cheaper than GPT-6 Astra and Fable 5.1 used as references. These numbers are self-published, on workflows written by their own team, measured from west-coast laptops. They say so themselves in the post1, which still doesn't earn the numbers a place in a business plan. Keep the order of magnitude (two zeros) and wait for an independent replication before trusting the decimal.

Why this name

Jev comes from William Stanley Jevons, the economist who observed5 in 1865 that improving the efficiency of steam engines drove coal consumption up instead of down. That's the Jevons paradox, and TypeSafe is openly betting on it1.

For a founder, that's the idea worth keeping from the post: making a decision a hundred times cheaper won't shrink your bill, it will multiply the number of decisions you allow yourself to make. The use cases in the next section were waiting for the price to let them through.

"Can't hallucinate": the exact promise

The phrase is already circulating outside its context and needs boundaries.

What Jev guarantees is that its answer belongs to the schema. If you ask for a choice among urgent, normal and low, you'll get one of those three values, always. No stray text, no invented field, no truncated JSON.

What Jev doesn't guarantee is that the answer is correct. An urgent ticket classified as normal is still a mistake, one the schema lets through without flinching because it has the right shape. TypeSafe is explicit about this1: the absence of hallucination is a structural guarantee, not an empirical measurement.

The distinction changes what you have to build. A model that can't be malformed spares you syntactic validation. It spares you no business-level evaluation. The test case set that the MVP playbook calls for from day one remains exactly as necessary, with the same twenty to fifty real cases.

Calibration brings something else, to my mind more useful than a truth guarantee that no system actually has: it tells you the size of the error zone, ahead of time. If the model is calibrated, you know decisions announced above 0.9 are wrong one time in ten or less. You can then decide, with full knowledge, how much volume you let through without human review.

Three places where the math flips

1. The if no if can write

Is this lead qualified? Does this expense report deserve a review? Does this message signal a customer about to churn? Fuzzy answer, closed output: the worst combination for a developer.

Today, two options. Write three hundred rules by hand, ones that age badly and that nobody dares touch after a year. Or call a model, too slow and too expensive for a step that runs a thousand times an hour.

A calibrated decision opens a third path. The value sits in the threshold. Above 0.9, the machine decides alone. Below 0.6, a human looks. In between, you choose based on the cost of being wrong. Above all, you know ahead of time what share of volume falls into each bucket, so you know how many human hours your automation requires before you even ship it. That's the number your client asks for, and no rules engine can produce it.

2. The backlog you never got to

It exists at every company I work with: four hundred thousand support tickets, two million product listings with no clean category, ten years of sales archives. The project has been scoped for a long time and it never ships, because the quote runs several thousand euros and several days of processing.

The math with published pricing, assumptions stated: 400,000 tickets at 800 tokens each is 320 million input tokens. At $0.042 per million, the full pass costs $13.44. The same volume on Claude Opus 5.5, at $4 per million input6, costs $1,280, output not included. Two public price lists and one division, redo it with your real volume before you take my word for it.

What this unlocks is the permission to be wrong. At $13 a pass, you rerun the full enrichment three times a week because your taxonomy shifted on Tuesday. At $1,280, you run it once and live with the result for two years.

3. The decision that fits inside the interface

Under 100 milliseconds, a decision stops being a network request and becomes an interface behavior: reordering a list while the user types, pre-filling a field from what was just pasted, flagging that a form will likely be rejected before submission, or sorting an inbox as it fills up.

The threshold has been documented since 1993 by the Nielsen Norman Group7: about 0.1 second is the limit for a reaction to feel instantaneous, and one second is the limit for the user's flow of thought to stay uninterrupted. A 70-millisecond decision sits under the first threshold. A two-second decision exceeds the second.

This is the hardest category to picture on paper. The gap in perceived quality shows most here: nothing about it looks like an AI feature, the screen simply responds better. A polished interface and the model stop being two separate subjects.

Two others deserve a line, for teams that already run an agent in production. The judge first: scoring a model's outputs adds a call per reply, so you score only part of the traffic, offline. With free output, the scorers from the agentic guide move inside the request and cover all of it. The router next: picking two tools out of fifty, or the right sub-agent, is still a frontier call on every loop turn, whether that's the tool catalog, the supervisor in the multi-agent architecture or agent discovery in MCP and A2A. In both cases the gain is the one described above, moved inside the loop.

What this doesn't settle

You can't try it. Early access, waitlist1. Everything above is reasoning built on announced numbers. I haven't run Jev.

The measurements are in-house. Workflows chosen and written by the vendor's own team, reference models chosen by them too, measurements taken from laptops. No independent replication to date. I found no calibration measurement in the post.

Free output is a commercial position. "Too cheap to meter"1 describes a market-entry strategy, not a cost structure. Building unit economics on that line repeats the mistake in principle four of the MVP playbook, with one more vendor.

It's one more dependency: a proprietary, closed model, from a single vendor, sitting at the center of your pipelines.

Most of the work is still System Two: writing, summarizing, reasoning across multiple steps, writing code, holding a conversation. Jev takes away a task your language model was oversized for.

Getting ready without waiting for the waitlist

The most useful thing to do right now doesn't depend on any early access: pull your decisions out of your prompts and give them an interface of their own.

Here's what a decision looks like in most codebases I inherit. Written inline, right where it was needed, with the provider's SDK sitting exposed in the middle of the business logic.

// Today: decision inline, provider hardcoded, shape hoped for
import { generateText, Output } from 'ai'
import { anthropic } from '@ai-sdk/anthropic'
import { z } from 'zod'

const { output } = await generateText({
  model: anthropic('claude-opus-5-5'),
  output: Output.object({
    schema: z.object({
      urgency: z.enum(['urgent', 'normal', 'low']),
    }),
  }),
  prompt: `Classify the urgency of this ticket:\n${ticket}`,
})

if (output.urgency === 'urgent') await pageOnCall(ticket)

Three problems, none of which wait on Jev to show up. The provider is hardcoded in the middle of the business logic. The decision has no name, so it has no test set. And you don't know how confident the model is, so you treat a borderline case exactly like an obvious one.

The same decision, named and isolated:

// The contract, independent of the engine
export type Decision<T> = { value: T; confidence: number }

export interface DecisionEngine {
  decide<T extends string>(
    input: string,
    choices: readonly T[],
    instruction: string,
  ): Promise<Decision<T>>
}

// The call, business side
const urgency = await engine.decide(ticket, URGENCIES, URGENCY_INSTRUCTION)

// The threshold exists right now, even if its value will move
if (urgency.confidence < 0.6) return humanReviewQueue(ticket)
if (urgency.value === 'urgent') await pageOnCall(ticket)

What you get right away, with today's models behind the interface: the decision has a name, so it gets its own evaluation set, in the spirit of the scorers that Mastra ships standard8. You can count how many decision calls a session makes, what they cost and what they add to latency. You have a single place to set a threshold and wire up a human review queue.

One caveat to write in plain sight in your code: the confidence you return in this interim implementation, derived from the model's logprobs or from a self-assessment, is not calibrated. Treat it as a provisional value. What matters is that the threshold exists in your code, not that its value is already the right one.

The day a calibrated engine becomes available, you swap one implementation behind an interface, rerun the same evaluation set, and compare two columns of numbers. This is the decision version of the rule this blog has applied to model choice from the start: isolate the dependency, don't lock yourself in early.

What to take away

  • A meaningful share of your model calls doesn't produce text, it produces a value only your code reads. Count that share, it's bigger than you think, and it's billed at reasoning-engine rates.
  • Jev gives up text generation to gain three things: a parallel pass instead of sequential decoding, output typed by construction, a probability trained to be honest.
  • "Can't hallucinate" guarantees the shape, never the correctness. Your business-level evaluations remain entirely necessary.
  • The published numbers, two orders of magnitude in both speed and price, are self-published and unreplicated. Order of magnitude, yes. Business plan, no.
  • The effect to expect is the one Jevons described: a decision a hundred times cheaper won't shrink your bill, it will multiply the number of decisions you allow yourself to make.
  • The useful action today needs no early access: name your decisions, put them behind an interface with a confidence threshold, give them an evaluation set.

This is the kind of tradeoff we settle during scoping, before half the latency budget goes into decisions nobody counted. It then gets implemented on an engagement around agents and workflows powered by language models, or inside an AI-first web product.

Sources

  1. TypeSafe, Introducing System One Models & Jev, 2026-09-15.
  2. Vercel, AI SDK Core, Generating Structured Data, accessed 2026-10-29.
  3. Guo et al., On Calibration of Modern Neural Networks, arXiv, 2017-06-14.
  4. Ouyang et al., Training language models to follow instructions with human feedback, arXiv, 2022-03-04.
  5. Jevons, The Coal Question, Macmillan, 1865.
  6. Anthropic, Claude API, Pricing, accessed 2026-10-29.
  7. Nielsen Norman Group, Response Times: The 3 Important Limits, 1993.
  8. Mastra, Evals, Overview, accessed 2026-10-29.