Loading theme preference
Ilia Bukin
← Back to blog

Jev: the System One model that answers software with probabilities instead of prose

Sep 19, 2026
AI
models
agents
TypeSafe
Jev

Frontier LLMs have been superhuman at chatting for years. The automation hasn't followed, and TypeSafe AI thinks it knows why: the output format. A model that writes prose can tell you whether a support ticket is urgent, but its answer arrives as tokens wrapped in a JSON blob that needs parsing, validation, and a faith that the model didn't just invent something. Chat-grade models also take seconds per response, which is fine for a human reading a screen and brutal for a hot code path.

TypeSafe's answer, announced out of stealth this week, is a model that simply doesn't generate text. It's called Jev, it's the first of what TypeSafe calls System One models, and it does one thing: read unstructured state, answer typed questions about it, and hand back calibrated probabilities your code can branch on.

What a System One model is

Jev was released on September 15, 2026 by TypeSafe AI, a San Francisco lab founded in 2024 by Diogo Almeida, who worked on the reinforcement learning from human feedback research behind ChatGPT at OpenAI, with Erik Gafni and Sasha Sheng. The company emerged from stealth with a $40M seed round led by DCVC 1 2. The pitch is that people aren't the only consumers of intelligence; software should get a vote.

Mechanically, Jev diverges from the LLM stack in three places: a new model architecture, a parallel sampler, and a training method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD) 3. Where an LLM optimizes to produce text a human rater prefers, RLCD optimizes for decisions with epistemically honest probabilities. In the company's words, Jev is "a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out" 3.

What Jev gives up is string generation. Outputs are type-safe structured values whose shape is defined in advance, with the possible values of every question pinned down before the request goes out. TypeSafe argues that hallucination and type-safety are intrinsically related, and that existing models, no matter how smart, still hallucinate and have type errors 3. The company claims Jev can't hallucinate, and that type errors are mathematically impossible because schema matching is guaranteed 3. Sceptics should note that's the vendor's claim, and the architecture details are still under wraps. TechCrunch's reporting notes outside observers suspect an open-weight LLM base 4.

The model class takes its name from Daniel Kahneman's Thinking, Fast and Slow: System 1 is fast, intuitive judgment; System 2 is slow, deliberate reasoning. Jev itself is named after William Stanley Jevons, the economist. The Jevons paradox is that making steam engines more efficient increased coal consumption, and TypeSafe bets the same holds for intelligence: every order of magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases 3.

How you call it

Jev is a plain POST to https://api.typesafe.ai/v1/systemone with a model, a state (the material being judged, text or structured data), and a map of questions 5. Each question is one of three types: Noul answers yes or no, returning the probability the statement is true; Choice picks one option from a defined set, returning a distribution over the options plus a confidence score; Score rates against ordered levels, returning a continuous score, the underlying distribution, and confidence.

A support-ticket example from the quickstart 5:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions"
      }
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

And the response, where every answer carries its probability (or distribution) and confidence alongside it:

{
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": {
        "billing": 0.84,
        "technical": 0.159,
        "sales": 0.001
      },
      "confidence": 0.596
    },
    "is_urgent": {
      "type": "noul",
      "noul": 0.999
    }
  }
}

The headline property is parallelism: all questions in a request are evaluated at once, in a single query, rather than token by token. LangChain's write-up notes that adding questions barely changes response time 6. TypeSafe quotes end-to-end response times of 70-500ms against 3-329 seconds for frontier chat models, 40x-200x faster on their numbers, at an input price of $0.042/MTok with output tokens "too cheap to meter" at $0 3. Vercel's model catalog lists typesafe-ai/jev at $0.042/1M input tokens with a 32,000-token context window and, tellingly, a maximum output token count of zero 7. A single question's choice set tops out at 255 options, with a two-stage "score then choose" path for bigger sets 3.

Where it fits in the agent loop

Jev is not a replacement for an LLM, and the integrations don't pretend otherwise. It slots in alongside one. The agent loop (model decides, tool runs, model evaluates) is slow and expensive because every decision costs a full generation call. Jev's pitch is that the decisions inside that loop are mostly classifications: which model should answer this, is this tool call safe to run, does this ticket need a human.

LangChain shipped first-class support within days of the launch 6:

  • TypeSafeClassifier exposes Jev through LangChain's model interface. Pass state and questions, get classifications back instead of a chat response.
  • ModelRouterMiddleware uses Jev to pick which model answers a request, sending lookups to a cheap model and architecture questions to an expensive one.
  • AutoModeMiddleware risk-gates tool calls before they execute. This is the "classify dangerous actions before they're taken" pattern that coding harnesses like Claude Code and Cursor have been shipping as closed-source internals, now available to any agent. The blog post's own example guards a bash tool.

Pydantic's AI framework integration goes further down the same path 8: every field of a Pydantic output_type becomes a question, a nested model fans out into multiple questions in one request, and the framework can fall back to a language model when Jev's confidence drops below a threshold. You can even route per step, having Jev re-pick the model for each turn of an agent run, which is only affordable because the routing call is cheap.

For coding agents there's also an official agent skill (npx skills add typesafe-ai/skills --skill typesafe-ai) so agents don't make the usual two mistakes: asking one question per call and inventing request fields.

The receipts

TypeSafe published workflow evals rather than the usual benchmark leaderboard 9. The setup treats a business task as a compute graph: decompose it into narrow questions (Noul/Choice/Score) plus deterministic code that makes the final decisions, then compare every model on the same harness. Instead of optimizing for ground truth labels, they measure against the consensus of the largest frontier models, the average of GPT-6 Astra and Claude Fable 5.1 at high thinking, as reference probabilities.

Across four workflows (security incident triage, agent trace observability, invoice processing, customer service), Jev lands at 67.8% mean accuracy at $0.0004 per case and 0.4 seconds per case. The accuracy is mid-pack against the frontier; the headline result is that nothing else is both cheaper and more accurate, or both faster and more accurate. The nearest rival on cost, luna, runs $0.0033 per case to Jev's $0.0004, and the fastest chat model in the eval, terra, takes about 10 seconds per case to Jev's 0.4. That's where the "193.6x faster, 444.6x cheaper" claims on the marketing page come from, figures TypeSafe itself says are probably on the high end of real-world gains 3.

The caveats matter:

  • The reference labels average OpenAI and Anthropic models, which the company admits biases the comparison 3.
  • The LLM comparison numbers come via OpenRouter, where harder queries tend to get routed to better models, a bias against LLMs 3.
  • The eval workflows were written by TypeSafe's own model capabilities team. "Some bias could exist" is the company's own phrasing 3.
  • The 0% type error rate is a guarantee, not a measurement: it follows from schema matching being enforced, not from testing 3.

The demos are the fun part. A Doom bot makes about 10 decisions per second on structured game state, costing roughly $7/hour. A wikiracing bot plays the find-a-path-from-one-Wikipedia-article-to-another game, where each step means picking among hundreds or thousands of links, a stress test for high-cardinality choices that don't hallucinate 3.

Treat it as a complement, and measure

Jev's sweet spot is decision-shaped work at volume: classify, route, score, extract, gate, verify. TypeSafe lists use cases like map-reducing petabytes of data into features, real-time applications where 100ms latency matters, and scoring, judging, and jailbreak-detecting other LLMs' outputs 3. The surrounding deterministic code constrains the model, which is the point: it reads like a learned, far more flexible version of an if-statement.

Two things to keep in mind before wiring it into production. First, confidence is a margin, not a guarantee. As the Pydantic docs put it, a confidence value is how far the answer sat from the decision threshold, so calibrate it against your own labeled examples rather than trusting the raw number 8. Second, the numbers are all early-access and vendor published, and in some cases explicitly priced too cheap to sustain; real-world gains will land lower, and the waitlist is the only way in right now. If you want to sanity-check the economics yourself, the open-source system-one-adapter-python repo swaps TypeSafe's API for an LLM backend, which is exactly the tool for building your own cost/speed/intelligence comparison instead of taking theirs on faith.

Jev is the first serious attempt at a model whose outputs are designed to be consumed by code, not by people. Whether "two orders of magnitude faster" survives contact with real workloads is an empirical question. The design bet, that automation needs decision-shaped outputs at decision-shaped latency, is the interesting part.

  1. TypeSafe AI emerges from stealth with $40M in funding
  2. TechCrunch: a new kind of AI model from a ChatGPT inventor is thrilling developers
  3. Introducing System One Models & Jev, TypeSafe AI
  4. The Register: TypeSafe AI debuts model for machines that plays Doom
  5. TypeSafe docs: Quickstart, state, questions, and the API
  6. LangChain blog: Building a Harness with Jev
  7. Vercel AI Gateway: Jev model page
  8. Pydantic AI docs: TypeSafe (Jev) model integration
  9. TypeSafe workflow evals