# Jev: AI that makes decisions, not text

> Most AI tools hand you a string and leave your code to parse it. TypeSafe AI's first System One Model takes the opposite approach: unstructured state in, typed probabilistic decisions out, in under half a second. This is what Jev does, what TypeSafe claims, and which claims come with caveats.

- **Published:** 2026-10-02
- **By:** Leandro Barbosa
- **Categories:** Technology, Product

## An AI model that decides instead of writing

Most of the AI tooling we work with produces text. You send a prompt, you get back a string, and your code has to parse and validate that string before it can do anything useful with it. TypeSafe AI, founded by former OpenAI researcher Diogo Almeida, has built a model on the opposite premise.

Jev opened in early access in September 2026 after two years in stealth. It is the first of what TypeSafe calls System One Models, a model class designed to make fast, structured decisions that software can consume directly. Unstructured state goes in, typed probabilistic decisions come out. No prose, no parsing step.

## Where the name comes from

The class name borrows from Daniel Kahneman's Thinking, Fast and Slow, and its split between fast, intuitive System 1 thinking and slow, deliberate System 2 reasoning. The model itself is named after William Stanley Jevons, the economist behind the observation that efficiency gains tend to increase demand rather than reduce it. TypeSafe's bet is that every order of magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases.

## What Jev does, and what it gives up

Jev does not converse. It classifies, routes, scores, extracts, and branches. Every answer arrives with a probability and a confidence score, and the set of possible outputs is defined in advance by a schema, so type errors are impossible by construction rather than caught after the fact.

That is a real trade. Strings are general: the same model can write a chat reply, generate code, or produce a structured value. Giving up string generation means Jev cannot do most of what people currently ask an LLM to do. In exchange, TypeSafe reports comparable intelligence on this narrow class of tasks at two orders of magnitude more speed and efficiency.

## How it compares to an LLM

TypeSafe's own comparison, condensed:

|  | Existing LLMs | Jev (System One Model) |
| --- | --- | --- |
| Output | Generated strings that software must parse and validate | Type-safe structured values with calibrated probabilities |
| Sampling | Sequential, one token at a time | Parallel, all outputs in a single query |
| Input cost | $0.20 to $10 per million tokens | $0.042 per million tokens |
| Output cost | Roughly 5x the input token price | Free, per TypeSafe's pricing |
| Response time | 3 to 329 seconds for frontier models | 70 to 500 milliseconds |
| Confidence | Overconfident and inconsistent, even when asked for an estimate | Calibrated confidence reported on every output |
| Training method | RLHF and RLVR | Reinforcement Learning for Calibrated Decisions (RLCD) |
| Suited to | Chatbots, copilots, coding agents, verifiable problems | Classification, routing, scoring, extraction, real-time branching |

## Why calibration is the interesting claim

Speed and price are easy enough to verify. Calibration is the part that would change how AI gets used in production. A model that handles a task correctly 95% of the time but cannot tell you when it is in the remaining 5% cannot automate that task, because someone still has to check all of it. TypeSafe's claim is that higher confidence from Jev reliably means higher accuracy, and that similar inputs return similar answers.

Type safety matters for the same reason. A hallucinated tool call is an annoyance in a chat agent where a person is watching the output. Buried several layers deep in a dependency chain with latency guarantees, it is a failure.

## The evidence, with TypeSafe's own caveats

To TypeSafe's credit, the announcement publishes its nuances next to its numbers. Worth reading in that spirit.

**Workflow evals. **TypeSafe built an evaluation where every model runs the same compute graph, scored against the averaged predictions of GPT-6 Astra and Fable 5.1. That is where the headline figures of 193.6x faster and 444.6x cheaper come from. TypeSafe notes these sit at the high end of expected real-world gains, that the workflows were written by its own model capabilities team, and that using OpenAI and Anthropic models as the reference biases the comparison toward them.

**Side-by-side demo. **The live comparison against GPT-5.6 Terra uses a deliberately simplified query with short, dense input, which TypeSafe acknowledges favors its parallel sampling approach. On the recorded run, the only disagreement between the two was a single question TypeSafe itself calls genuinely ambiguous.

**Hallucination rates. **The LLM figures come from OpenRouter, so routing behavior may skew them. Jev's own 0% is not measured; it follows from guaranteed schema matching.

**Pricing. **Input is $0.042 per million tokens and output is free. TypeSafe says openly that it cannot prove the pricing is unsubsidized, and that only time will show whether it holds.

## The demos are the fun part

Two stand out. A Jev bot plays Doom from structured text game state at roughly 10 queries per second, which works out to about $7 an hour. TypeSafe is clear that a conventional bot would play better; the point is a bot that reacts to different representations of game state and follows instructions while doing it.

The other is Wikiracing: navigating from one Wikipedia page to another using only the links you encounter, choosing among hundreds or thousands of options at each step. It is a good stress test for high-cardinality decisions, where hallucinating a link that does not exist ends the run. Jev supports up to 255 options per choice; above that, TypeSafe scores candidates first, then makes an explicit second-stage choice, which costs some of the speed advantage.

## Where this fits

Jev is not a replacement for the models we use to draft, summarize, or write code. It is a different shape of tool, aimed at a gap that comes up constantly in client work: the smart if-statement. Classifying an incoming form submission, routing a support request, scoring content quality, deciding which variant to show, flagging something for human review. Hand-written rules are too brittle for these, and a frontier LLM is too slow and too expensive to sit in the request path.

The part that matches how we already build: structured outputs with explicit confidence scores are reviewable. A decision that arrives with a probability can be sent to a person when that probability is low. That is a better foundation for automation than a confident paragraph.

---

[More from the blog](https://www.1367studio.com/blog.md) · [Work with 1367 Studio](https://www.1367studio.com/contact.md)

---

Source: https://www.1367studio.com/blog/jev-ai-that-makes-decisions-not-text