What Is Jev? TypeSafe’s “System One” AI Model That Returns Decisions, Not Text

TL;DR — Jev is a new class of AI model from TypeSafe, launched September 15, 2026, that returns typed, probabilistic decisions instead of generated text. You give it program state plus typed questions, and it answers all of them in a single parallel pass in 70-500 milliseconds — at $0.042 per million input tokens with free output, running 40-200x faster and 40-400x cheaper than frontier LLMs like GPT-6 Astra. TypeSafe calls this category a “System One model,” after the fast, intuitive thinking in Daniel Kahneman’s Thinking, Fast and Slow. Because valid answers are defined in a schema before the call, Jev mathematically cannot hallucinate or produce a type error. On TypeSafe’s own four-workflow benchmark it scores 67.8% accuracy — tied with GPT-5.6 Terra and a few points behind GPT-5.6 Sol (74.1%) and Claude Opus 5 (73.1%) — but at roughly 1/200th the cost and 1/50th the latency. It’s the wrong tool for chat, code generation, or anything needing a written explanation. It’s the right tool for high-volume, repeated decisions where the possible answers are known in advance. This guide explains what a System One model is, how Jev works, its pricing and benchmarks, its honest limitations, and the real use cases developers shipped in the first 48 hours.

What Is a System One Model?

A System One model is a class of AI, introduced by TypeSafe with Jev in September 2026, that makes fast, structured decisions instead of generating text. You give it a block of state and a set of typed questions; it evaluates all of them in parallel and returns structured answers with calibrated confidence scores — with no string generation and nothing to parse.

The name comes directly from Daniel Kahneman’s Thinking, Fast and Slow. Kahneman’s System 1 is fast and intuitive; System 2 is slow and deliberate. Today’s large language models, with their chain-of-thought traces and multi-second reasoning, sit firmly in System 2 territory. A System One model is the missing counterpart: the fast, reflexive judgment layer.

The strategic argument behind the category comes from TypeSafe founder Diogo Almeida, who was a co-inventor of RLHF and InstructGPT at OpenAI. His thesis: the automation gap comes from everyone building System 2 models when most software decisions just want a fast System 1 answer. Most decisions inside software are simple judgments — “which bucket does this belong in?”, “is this urgent?”, “route this ticket” — and companies have been renting slow, expensive System 2 reasoning to make them.

TypeSafe raised $40 million led by DCVC to build this. Jev is the first public release in the category, named after economist William Stanley Jevons.

What Is Jev and How Is It Different From an LLM?

Jev is a frontier AI model built to make fast, structured decisions that software can consume directly, without a parsing or validation step. It’s the first System One model, available in early-access waitlist as of September 2026.

Architecturally, Jev is a genuine departure from a transformer LLM. Instead of generating strings one token at a time (autoregressively), it uses a parallel sampler that produces all outputs in a single query. And instead of the RLHF (Reinforcement Learning from Human Feedback) or RLVR (verifiable rewards) training that shapes models like GPT-6 and Opus 5, Jev is trained with what TypeSafe calls RLCD — Reinforcement Learning for Calibrated Decisions.

The distinction matters. RLHF optimizes for chat responses human raters prefer. RLVR optimizes for outputs a program can verify. RLCD optimizes for epistemically honest probabilities on decision tasks — which is why calibration (confidence that genuinely tracks accuracy) is a first-class property of Jev rather than something bolted on through prompting.

Here’s the core architectural contrast:

Every one of these differences follows from a single design choice: Jev gives up string generation entirely. That subtraction is what buys the speed, the price, and the type guarantees.

How Does Jev Work? The Three Question Types

Jev’s entire API is built on three “question type” primitives — Choice, Score, and Noul. You define them in a schema, pass your program state, and Jev fills them all in one parallel pass.

Choice — one option from a set. For categorical classification. It takes up to 255 options and returns the chosen option, per-option probabilities, and a confidence score. Example: routing a support ticket over {billing, technical, sales, spam}. Best practice is to add an explicit “other” option so the model can say nothing fits rather than picking the closest wrong answer.

Score — a position on a spectrum. Two to ten ordered levels described in words. It returns a score that can land between levels (like 1.035), plus probabilities and confidence. Example: rating customer frustration from “calm” to “very angry.”

Noul — yes or no, as a probability. Returns a single number from 0 to 1: the probability the answer is yes. There’s no separate confidence field, because the number already is the belief. Example: “The message conveys urgency” → 0.87.

The whole thing works like a frontier-intelligence function call: unstructured state goes in, typed probabilistic decisions come out. If you’re routing a ticket, you might define a Choice over departments and a Score for urgency, and Jev fills both in a single pass. There’s no JSON to parse and no risk the model wanders off and writes a paragraph.

A key efficiency property: because questions run in parallel over the state, a tenth question costs tokens but almost no extra time. TypeSafe’s cookbook reports that batching 13 questions into one call runs 12.2x cheaper and 10x faster than asking them one at a time, with identical answers.

The obvious caveat: this only works when the space of valid answers is bounded and known up front. Jev is useless for open-ended generation, and it doesn’t write the schema for you.

Why Jev Can’t Hallucinate (and What That Actually Means)

Because Jev’s outputs are constrained to values defined in your schema, it is mathematically impossible for it to produce an invalid value or a type error. TypeSafe reports a 0% structured-output error rate and 0% tool-call error rate.

For comparison, on TypeSafe’s structured-output test, OpenAI’s Luna and Terra sat at 0.58%, Anthropic’s Opus 5 at 5.73%, and Claude Haiku 4.5 at a striking 45.5%. On tool calls, GPT-5.6 Sol was the worst at 17.0%. Those aren’t obscure edge cases — they’re exactly the failures that break an unattended pipeline the moment it runs at volume.

But here’s the honest nuance that the marketing glosses over: “cannot hallucinate” is narrower than it sounds. Jev cannot return a value outside your schema — but it can absolutely return the wrong valid value. If you ask it to classify a ticket as billing, technical, or sales, it will never invent a fourth category or write an essay. It can still put a billing ticket in the technical bucket. The 0% figure is a guarantee about output format, not output correctness, and TypeSafe is fairly candid that the number is asserted from the schema design rather than measured empirically.

The other genuinely useful property is calibrated confidence. Standard LLMs are notoriously overconfident even when you explicitly prompt them for a probability. If a model classifies correctly 95% of the time but can’t tell you which 5% it’s unsure about, you can’t safely automate around it. Jev’s calibration lets you set a confidence threshold and only auto-act above it, routing uncertain cases to a human or a slower LLM. That’s the feature most likely to change how you architect a system.

The limitation to flag: Jev gives you a number, not a rationale. There’s no natural-language explanation of why it scored a case the way it did, which matters for debugging and for audits in regulated domains. If a compliance team needs to know why a loan application was scored a certain way, a bare confidence number won’t satisfy them.

Jev Pricing: How Much Does It Cost?

Jev costs $0.042 per million input tokens (about $42 per billion), and output tokens are unmetered and free. TypeSafe describes the output as “too cheap to meter” because the model returns structured decisions rather than long text.

For scale, that input rate is roughly 1/48th of GPT-5.6 Terra’s $2.00 per million input tokens — and Terra also bills $12.00 per million output tokens on top, which Jev doesn’t charge at all. At the workflow level, TypeSafe’s internal evaluation puts Jev at about $0.0004 per decision case, versus $0.0304 for Terra and $0.0836 for GPT-5.6 Sol.

Billing is input-only, which is why two of Jev’s best patterns are cheap: adding options to a Choice costs almost nothing, and “speculative fan-out” (asking every question you might need up front and letting code decide what was relevant) barely moves the bill.

The honest caveats on price: TypeSafe is candid that it can’t prove the pricing isn’t subsidized, and says the long term will have to demonstrate sustainability — though it expects prices to fall rather than rise. As with any early-access model priced this aggressively, treat the rate as a launch figure, not a guarantee.

Jev Benchmarks: The Trade Is Cost, Not Accuracy

On TypeSafe’s four-workflow benchmark, Jev lands roughly where mid-tier frontier LLMs do on accuracy, while beating everything on cost and latency by one to two orders of magnitude.

TypeSafe built a custom evaluation across four workflows — security incident response, agent-trace observability, invoice processing, and customer service — scoring each model against consensus answers. The results:

• Jev: 67.8% accuracy, $0.0004 per case, 0.4s latency
• GPT-5.6 Terra: 67.9%, $0.0304, 10.1s
• Claude Sonnet 5: 67.8%, $0.117, 78s
• Claude Opus 5: 73.1%, $0.1761, 37.8s
• GPT-5.6 Sol: 74.1%, $0.0836, 23.3s

The pattern is consistent: Jev trades a few points of accuracy against the very best models for enormous cost and latency savings. The line that lands hardest is that Claude Sonnet 5 scores exactly 67.8% too — at 293x the cost per case and 195x the latency. Where peak accuracy matters on a low-volume task, GPT-5.6 Sol and Opus 5 keep a real 5-6 point edge and the LLM still wins.

Four honest caveats you should hold onto before trusting these numbers:

1. That column isn’t really “accuracy.” There’s no ground truth. TypeSafe builds consensus labels by averaging GPT-6 Astra and Claude Fable 5.1 at high reasoning, then scores everyone against those. It measures agreement with two frontier models — which is why neither of those models appears in the results, and TypeSafe admits it biases toward OpenAI and Anthropic.
2. It’s entirely self-run. TypeSafe designed the workflows, built the harness, and ran the evaluation. No independent reproduction on a neutral harness has surfaced yet.
3. The “0% hallucination” comparison leans on an outlier. The dramatic 45.5% figure is a single model (Haiku 4.5); most models sit between 0.58% and 13.2%.
4. The price may not hold if the current rate turns out to be subsidized.

Until an independent suite reproduces this, read the accuracy parity as promising rather than settled — and evaluate on your own traffic.

Real Jev Use Cases: What Developers Built in 48 Hours

The most useful signal after launch wasn’t the benchmark table — it was what people actually shipped. Here are the standout community projects from Jev’s first 48 hours. (All figures are self-reported by their authors, so treat them as launch-week artefacts rather than production case studies.)

1. 1,018 research papers classified for $0.08. The site 1kpapers.com (by Hassan El Mghari) summarized 1,018 papers with DeepSeek V4 Flash for $3.99, then sent each title and summary plus 24 candidate topics to Jev for a single Choice classification — total classification cost $0.08, median latency 256ms per paper. It’s the clearest demonstration of the “different models for different parts of the workflow” economics: a generative model for the summaries, a decision model for the routing.

2. A browser agent that books a flight in 7.1 seconds. The browser-use/jev-ultrafast project turns each web page into a numbered element table, then uses one Jev request to pick both the operation (CLICK, TYPE_TEXT, SCROLL, etc.) and its target. It booked Zürich to London on real Google Flights in 7.1 seconds for $0.0039, page loads included — with a small LLM running only when free text needed typing.

3. Computer use at $0.0002 per step. The typesafe-computer-use project drives a Mac toward a plain-English goal without sending screenshots to a large model: OCR reads the screen, Jev picks the next action, and a writing model is called only for free text. Cost per 12-step task was $0.003 versus $0.40-0.90 for Opus 5 on bare screenshots. The author’s most useful caveat: “Every piece of reasoning the frontier model does for free has to be rebuilt here as deterministic state” — Jev needed explicit date parsing where the LLM read dates off pixels unaided.

4. Real-time loops: trading, drones, and games. A market-maker bot decides buy-or-sell once per ~300ms blockchain block at ~81ms model latency. An autonomous drone uses Jev for tactical judgment at 2.5Hz — but explicitly advisory only, with a code-owned flight controller at 500Hz and safety reflexes at 50Hz. And hobbyists have Jev playing Doom, Super Mario Bros, and StarCraft from structured game state translated to text.

The pattern across every project is identical: keep the loop, the safety, and the arithmetic in ordinary code, and use Jev for the narrow judgment in the middle that code finds hard to phrase — then escalate the hard, open-ended minority to a frontier LLM.

When Should You Use Jev vs a Frontier LLM?

Jev isn’t competing with GPT-6 Astra or Claude Opus 5 for the same jobs. The useful question is which class of model to reach for, and it comes down to whether your task needs a bounded decision or an open-ended answer.

Reach for Jev (a System One model) when:

• The decision is repeated, high-volume, and the possible answers are known in advance
• You’re routing or triaging tickets, messages, or requests at scale
• You need to score or guardrail LLM outputs quickly and cheaply
• You need a real-time decision inside an app loop (70-500ms vs 3-30s)
• You’re tagging or filtering at volumes that were previously uneconomic
• You want to filter or classify before an expensive context window sees the data

Reach for a frontier LLM (GPT-6 Astra, Opus 5) when:

• You need generated text, code, or a written rationale
• The task is one-off, complex, multi-step reasoning
• An auditor or compliance process needs an explanation, not just a score
• The space of valid answers is genuinely open-ended

The most powerful pattern is a cascade, where the two compose. Use Jev as the fast decision layer that classifies, scores, and routes; let ordinary code handle what it can; and hand the small slice of hard or open-ended cases to a model like GPT-6 Astra or Opus 5. Jev’s calibrated confidence is what makes that handoff clean — you route on a confidence threshold. On a million support tickets, TypeSafe’s figures put a Jev cascade at roughly $6,480 instead of $30,400, with around 800,000 answered in under half a second.

Jev’s Limitations: What It’s Bad At

TypeSafe publishes an unusually honest “jaggedness” page listing what Jev is bad at. Reading it before you build will save you a week. These are the failure modes that will bite you:

It reads literally. Jev answers the question you wrote, not the one you meant. Negations, scoping words, and implied conditions land at face value. If you catch yourself explaining what you “really meant” by a wrong answer, that explanation is the missing half of your instruction.

It is not a calculator. It doesn’t count reliably, and error grows with the size of the thing being counted. Do arithmetic in code and ask one Noul per item instead.

Dates are text to it, not ordered quantities. Which date came first, how far apart two dates are, whether one falls in a window — all unreliable. Extract dates with a Choice over enumerated options, then order and compare them in code.

Context rot is real. Accuracy falls as the state fills with material the question doesn’t need. Retrieve and filter in code first, sending only the fields each question requires.

State is not treated as hostile. Text engineered to argue for its own classification can move the answer. If you put user-controlled content into state, that’s your threat model to handle and test.

It does not generate anything. No text, no code, no summaries. If you need a value extracted from free text, get candidates with a regex or a generative model and let Jev pick among them.

The meta-rule from TypeSafe’s own docs is good design advice generally: avoid asking the model something code can compute exactly, and avoid hiding several judgments inside one question.

How to Access Jev

Jev is a proprietary, hosted model reachable through TypeSafe’s HTTP API, in waitlisted early access as of September 2026. The endpoint is POST https://api.typesafe.ai/v1/systemone, and the early-access model route is jev-latest. TypeSafe provides official SDKs for Python (pip install typesafe-sdk) and JavaScript/TypeScript (npm install @typesafe-ai/sdk), and keys are available via the TypeSafe console or the Vercel AI gateway.

Here’s the minimal shape of a request:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
client = TypeSafeClient()
response = client.system_one(
    state="Customer emailed twice about a failed refund on order A-104.",
    questions={
        "category": Choice(instructions="Which team should handle this",
                           criteria={"billing": "Payment or subscription issues",
                                     "technical": "Bugs or integration problems",
                                     "sales": "Pricing or account questions"}),
        "urgency": Score(instructions="How urgent is this",
                         criteria=["Not urgent", "Somewhat urgent", "Very urgent"]),
        "refund_requested": Noul(instructions="The customer is asking for a refund"),
    },
)
print(response.answers["category"].choice, response.answers["category"].confidence)

One operational note: pin your version (jev-1.13.0) if you tune confidence thresholds, because jev-latest will move when a new release ships and can change answers under you. The response’s model field reports the versioned ID that answered, so log it.

Frequently Asked Questions

What is Jev?

Jev is a frontier AI model from TypeSafe that returns typed, probabilistic decisions instead of generated text. Launched September 15, 2026, it’s the first “System One model” — a new category named after Kahneman’s fast, intuitive thinking. You send program state plus typed questions, and it answers all of them in a single parallel pass in 70-500 milliseconds.

What is a System One model?

A System One model is a class of AI, introduced by TypeSafe, that makes fast, structured decisions rather than generating text. The name references Daniel Kahneman’s fast, intuitive System 1 thinking (versus the slow, deliberate System 2 that today’s LLMs represent). It takes unstructured program state as input and returns typed values with calibrated probabilities, so software can use the output directly without parsing.

How much does Jev cost?

Jev charges $0.042 per million input tokens (about $42 per billion), and output tokens are unmetered and free. That input rate is roughly 1/48th of GPT-5.6 Terra’s $2.00 per million. At the workflow level, TypeSafe reports about $0.0004 per decision case, versus $0.0304 for Terra and $0.0836 for GPT-5.6 Sol.

Can Jev hallucinate?

Jev cannot return a value outside your schema, so producing an invalid value or a hallucinated category is mathematically impossible — TypeSafe reports a 0% structured-output error rate. However, it can still return the wrong valid value (for example, putting a billing ticket in the technical bucket). The 0% guarantee is about output format, not output correctness.

How does Jev compare to GPT-6 Astra and Claude Opus 5?

On TypeSafe’s four-workflow benchmark, Jev scores 67.8% accuracy — tied with GPT-5.6 Terra (67.9%) and a few points below GPT-5.6 Sol (74.1%) and Claude Opus 5 (73.1%). But Jev costs about $0.0004 per case versus $0.03-0.18 for those LLMs, and runs in 0.4 seconds versus 10-38. It trades a few points of peak accuracy for one-to-two orders of magnitude in cost and latency savings. It’s not competing for the same jobs — Jev makes bounded decisions, LLMs generate open-ended answers.

What are Choice, Score, and Noul?

They’re Jev’s three question types. Choice picks one option from a set (up to 255 options) and returns probabilities plus confidence. Score returns a position on a 2-to-10-level ordered spectrum described in words. Noul returns a single 0-to-1 probability for a yes/no question. You define these in a schema, and Jev fills them all in one parallel pass.

Can Jev write code or text?

No. Jev is not trained to generate text at all — no code, no prose, no summaries, no rationales. It only returns typed decisions defined in your schema. If you need text extracted or generated, use a regex or a generative LLM to produce candidates and let Jev pick among them.

When should I use Jev instead of an LLM?

Use Jev for high-volume, repeated decisions where the possible answers are known in advance: routing and triage, moderation, relevance filtering before an expensive context window, scoring or guardrailing LLM outputs, and real-time decisions inside an app loop. Use a frontier LLM when you need generated text, code, a written rationale for an auditor, or one-off complex reasoning. The best architecture is often a cascade: Jev classifies and routes cheaply, code handles what it can, and an LLM takes the hard minority.

Who created Jev and TypeSafe?

Jev was built by TypeSafe AI, founded by Diogo Almeida, who was a co-inventor of RLHF and InstructGPT at OpenAI. The company raised $40 million led by DCVC. Jev is named after economist William Stanley Jevons, and the “System One” category name references Daniel Kahneman’s Thinking, Fast and Slow.

How do I get access to Jev?

Jev is in waitlisted early access as of September 2026, reachable through TypeSafe’s HTTP API at POST https://api.typesafe.ai/v1/systemone using the model route jev-latest, with official Python and JavaScript/TypeScript SDKs. Get a key from the TypeSafe console or the Vercel AI gateway. There was no explicit free-credit program described in the launch materials.

Are Jev’s benchmark numbers reliable?

Treat them as promising but unproven. All the figures are self-reported by TypeSafe, which designed the workflows, built the harness, and ran the evaluation itself, with no independent reproduction yet. The “accuracy” column measures agreement with GPT-6 Astra and Claude Fable 5.1 as consensus labels rather than ground truth, and TypeSafe acknowledges this biases toward OpenAI and Anthropic. Evaluate Jev on your own traffic before relying on the numbers.

Final Thoughts

TypeSafe is making a genuinely interesting bet: that a large share of what people currently ask LLMs to do is really structured decision-making dressed up as chat. If that’s right, Jev’s 40-400x cost advantage and 0% type-error guarantee reset the economics of high-volume automation in a way GPT-6 Astra and Opus 5 can’t match on price — not because Jev is smarter, but because it’s a fundamentally different primitive.

That’s the mental shift worth internalizing. Jev isn’t a cheaper LLM. It’s a typed function call that happens to be intelligent, returns a value your code can use directly, and tells you how much to trust it. Once you have that, a lot of code that exists only to survive and validate string output stops needing to exist at all. The calibrated confidence is the part most worth building around — it’s what lets you automate the confident majority of decisions and escalate only the uncertain few.

The honest open questions are the ones TypeSafe itself flags. Will an independent benchmark confirm the accuracy parity on a neutral harness? Will the aggressive pricing hold once any subsidy runs out? And is the “System One” framing a durable new category or a clever wrapper around constrained decoding that others will replicate? The community’s early answer to that last question is telling: within days, an open-source project reproduced the interface pattern on a small open model, reading typed option probabilities off the logits. The pattern may prove more durable than any single vendor’s model.

For now, the practical takeaway is clear. If you’re running bounded, high-volume decisions — routing, scoring, filtering, guardrailing — Jev or a System One model like it is worth a serious look, as the fast decision layer in front of your expensive models rather than a replacement for them. Just build the eval on your own traffic first, keep the loop and the arithmetic in code, and reserve the frontier LLM for the hard, open-ended minority where it genuinely earns its cost.

Published September 2026 · The AI & Tech Society · digitalstrategy-ai.com

Sources: TypeSafe AI’s launch materials and documentation (typesafe.ai, including the “jaggedness” model-limitations page and cookbooks); DataCamp, “Jev: TypeSafe’s System One Model Explained” by Matt Crabtree (September 16, 2026); dev.to, “How to Use Jev: A Practical Guide to TypeSafe’s System One Model” by Prosper Otemuyiwa for Valyu AI (September 17, 2026); community projects including 1kpapers.com (Hassan El Mghari), browser-use/jev-ultrafast (Gregor Zunic), typesafe-computer-use, jev-trader, jev-drone, and openjev. All performance, pricing, and benchmark figures are self-reported by TypeSafe or by individual project authors and have not been independently reproduced; the benchmark “accuracy” measures agreement with GPT-6 Astra and Claude Fable 5.1 as consensus labels rather than ground truth. This article is analysis, not investment or procurement advice. Verified September 2026.