Jev and the Arrival of Model Tetris: System One Models Change the Game

On September 15, a model shipped that does not write anything — and within three weeks more than a dozen imitators followed, from OpenAI, Cloudflare and Perplexity to open-source projects that run on a laptop. The category is now called System One models, and it changes how product teams should choose AI for every decision inside an agent.

The first mover is Jev, from startup TypeSafe AI. Its founder, Diogo Almeida, says he helped build the instruction-following research at OpenAI that became ChatGPT, then spent two years in stealth on a different question: if models have been superhuman at chat for years, where is all the automation? The framing borrows from Daniel Kahneman's Thinking, Fast and Slow. Today's reasoning LLMs are System Two: slow and deliberate. Jev targets System One: route this ticket, score this risk, take this branch.

What does a System One model actually do?

A System One model generates no text. You hand it a piece of state and typed questions; it returns structured answers with calibrated probabilities. There are three question types: a Choice among options you define, a Score against a rubric you write, and a yes-or-no probability TypeSafe calls a Noul. TypeSafe calls it a frontier-intelligence function call; the author calls it a smart if-statement.

Launch pricing is aggressive: $0.042 per million input tokens, output free, responses in 70 to 500 milliseconds.

One claim needs precision. TypeSafe says Jev cannot hallucinate — meaning it cannot return an answer outside your schema. It can still pick the wrong answer from inside it, and it reports how confident it was when it did.

The name is a nod to William Stanley Jevons: every drop in the cost of intelligence unlocks more uses for it.

How did three weeks make it a category?

One model is a product; the follow-on wave made it a category:

• At DevDay in late September, OpenAI previewed a Decisions API built on GPT-6 Luna; on October 6 it opened it to all developers in public beta at $0.10 per million input tokens, output free, claiming it decides roughly ten times faster than the same model through its regular API.
• On October 1, Cloudflare released Clef, open-weight decision models; the smaller version returns a median decision in under 40 milliseconds.
• The same day, Perplexity opened its own Decisions API on open weights and claimed a narrow win over Jev on its own benchmark panel.
• Amazon's Strands Labs reportedly shipped an open-source decider; Liquid AI's d1 and Upstage's Solar Decide joined the list.
• On October 2, llama.cpp added an endpoint speaking the same request format Jev introduced; Cloudflare's Clef speaks it too.

Two facts matter for CIOs. The interface standardized before the market did, the way containers made runtimes interchangeable. And published prices range from $0.02 to $0.24 per million input tokens across vendors — when prices for the same thing span an order of magnitude, nobody knows what it really costs yet. TypeSafe itself says it cannot prove its pricing is not subsidized.

Does a fast, suboptimal answer beat a slow, better one?

No production customers are known. The category is barely two months old, so the author ran a test: agents playing Pac-Man through the MAME emulator, where decisions arrive every 17 milliseconds and success is unambiguous. The harness — built with Claude Code — used a tactical loop for turning and a planning loop picking goals from 11 options. Three planners ran 100 times each on the same tactical loop:

Planner	Mean score	Best score	Cleared level 1	Median frames missed per decision
code-planner (plain code)	5,100	15,640	51%	0
jev-planner	4,499	9,480	27%	21
haiku-planner (Claude Haiku)	3,406	9,090	10%	59

The outcomes rank exactly with latency. Jev likely beat Haiku because it answered sooner, not because it was smarter. The lesson: a correct answer delivered after the window closes is a wrong answer. Card authorizations, ad bids, guardrails and agent-loop tool dispatches all have the same windows; enterprises just cannot see them in frames. The latency budget belongs on model-selection criteria next to accuracy and cost, and most teams leave it off.

How should teams sort each decision?

The ordering is simple. Known, stable rules: write code. A known option set with fuzzy rules: use a System One model. Output that must be written or explained: use an LLM and accept the wait. Four questions sort any decision:

1. Output shape — must the answer be written, or chosen from predefined options?
2. Latency budget — milliseconds, or is three minutes fine?
3. Explainability — a System One model returns a probability, not a rationale.
4. Stakes — is a calibrated threshold with human review safer than one confident guess?

Keep the model choice behind an interface you control. Running every model at once is sprawl; being able to swap one in an afternoon is flexibility. Lock-in used to be denominated in egress fees — now it is denominated in model usage patterns.

What are the caveats?

Nearly every benchmark in the category is vendor-reported; TypeSafe's own launch post notes its workflow evaluations were written by its own team. A probability with no rationale is a real audit problem in regulated work, so expect System One models to route and screen rather than decide alone. Cloudflare's hosted Clef reads only about the first 2,000 tokens of text state, making retrieval quality the bottleneck. And where a decision has no deadline — contract review, quarterly forecasts — the better answer should win. Fast does not beat smart; fast beats late.

The industry has built databases for about 60 years and agents for about 18 months; nobody should be confident today's model usage pattern survives the next 18. Sometimes the best piece on the board is an if-statement.