Jev System One models: typed answers compared with LLMs

TypeSafe AI released Jev on September 15, 2026 and calls it the first System One model. It never writes a sentence. You hand it a state and a set of questions, and it returns typed answers with probabilities that your code branches on directly. The name comes from the economist William Stanley Jevons, and the pitch is his: every order of magnitude that intelligence gets cheaper unlocks an order of magnitude more uses for it.

Here is the body analogy. An LLM is the brain: it thinks before it speaks. Jev is closer to the reflex arc in the spinal cord. Input arrives, a movement command leaves, and no language happens in between. Where that analogy holds and where it breaks down is worth spelling out, so that comes later.

It is not a smaller LLM

Language models have been adapted in two main ways. RLHF taught them to say what people like, which gave us chat assistants. RLVR uses verifiable rewards to train reasoning, which makes a model stronger at math and code and more expensive to run. TypeSafe built a third path called RLCD, Reinforcement Learning for Calibrated Decisions, which optimizes probabilities against outcomes instead of human preference.

That changes the output contract. An LLM generates a string that you parse, validate, and hope it did not invent a field; Jev picks from an answer space you defined up front, so the company can claim zero type errors by construction. That only fixes the shape of the answer, not its correctness.

TypeSafe's diagram of three training paths: pretrained language models branch into RLHF, RLVR, and RLCD, and only the last one leads to a decision model
RLHF produced chat models, RLVR produced reasoning models, and RLCD is the third path TypeSafe added. Diagram from the TypeSafe AI docs, AI primer.

One call: state in, decisions out

There is one endpoint, POST /v1/systemone, and a request carries a state plus questions. The default model is jev-latest, currently version 1.13. Only three question types exist. Choice picks one option out of up to 255. Score places the state on a 2 to 10 level scale you describe in words, and it can land between levels, such as 1.4. Noul answers a yes or no question with a probability from 0 to 1.

All three can be mixed into a single request. They run in parallel and in isolation, so adding questions barely changes response time and more topics do not interfere with each other. This is the request from the official docs, asking in one pass which team should take the ticket, how frustrated the customer is, and whether the message is urgent:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration 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"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated the customer appears",
      "criteria": [
        "Calm, just stating facts",
        "Frustrated but civil",
        "Very angry, strong language"
      ]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

What comes back is decisions and probabilities, with no prose to parse. This is an excerpt of the matching response from the same page, minus the level descriptions:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "technical",
      "confidence": 0.78,
      "probabilities": { "technical": 0.85, "sales": 0.0, "billing": 0.15 }
    },
    "frustration": { "type": "score", "score": 1.0, "confidence": 1.0 },
    "is_urgent": { "type": "noul", "noul": 1.0 }
  }
}

Choice and Score come back with confidence, which is what your code uses to decide between acting now, escalating to a person, or handing the case to a reasoning model. A Noul has only two outcomes, so its single probability already describes the whole answer. The docs call the pattern a smart if-statement: classify, route, score, extract, or branch wherever hand-written rules are too brittle.

The brain, the reflex arc, and the muscles

An LLM is like the cortex. It reasons, writes, and explains, but it has to think the whole thing through every time, which is slow and expensive, and occasionally it is confidently wrong. Jev is like a spinal reflex arc. Sensory input goes in, a motor command comes out, and no language layer exists in between. Tapping your knee does not produce an explanation of the knee, and Jev does not explain its judgment either. It generates no text at all, so there is nothing plausible-sounding to be invented.

The part that actually does something is still ordinary code, which plays the role of muscle and bone. The reflex arc only carries the signal: this ticket belongs to engineering, this post gets taken down, this comment crosses a line. Separating judgment from execution is the core of the design.

The analogy stops being accurate here. A human reflex is hard-wired, one stimulus to one response. Jev is trained, and it handles semantic judgments that were never written down, which is why it can answer on inputs it has not seen. The cost is right there with it: reflexes do not make mistakes, models do. TypeSafe also states that calibration is a group property, so probabilities matching reality across many predictions does not guarantee that any single answer is correct.

A TypeSafe docs illustration comparing three architectures: traditional software branches on hand-written rules, agents route the whole flow through a model, and AI-powered software keeps the flow in code and calls a model only for judgments
Traditional software branches on hand-written rules, agents hand the flow to a model, and AI-powered software keeps the flow in code and calls a model for individual judgments. Illustration from the TypeSafe AI docs, How to build with TypeSafe.

What it cannot do

It does not write copy, generate code, or explain its reasoning, which puts all three outside its scope. It also has no world knowledge. It only knows the state you hand it and cannot look anything up, so the state you build sets the ceiling. Input is text only, either strings, JSON objects, or arrays of text. Images, audio, and video are not supported, and a single request can hold up to 64k tokens of context.

Test any non-English workload yourself. The docs state that English is the primary training language and where accuracy is best, and that CJK scripts are handled but not equally well.

When it is worth wiring in

The fit is high-volume, repeated decisions over a known answer set: ticket triage, intent routing, content moderation, extraction, scoring, and guardrail checks on other models. The common shape is three tiers. Jev classifies and routes for very little money, deterministic code handles what it can, and the small remainder goes to a frontier model or a person. What you save is expensive model calls, and what you get back is a clear boundary between decisions the machine makes and cases that require a human.

Jev is still in early access. The input price of $0.042 per million tokens, free output, and 70 to 500 millisecond latency are vendor claims: the evals ran on the company's own laptops, the benchmark uses the average of GPT-6 Astra and Fable 5.1 as its reference answer, and TypeSafe says it cannot prove its pricing is sustainable. The practical way to judge it is still to take one high-volume judgment call of your own and run it against the same data with whatever you use today.

Related posts

Comments

Loading comments…

Music