Jev is a useful idiot

In May 2024 I wrote GenAI: Bringing intuition to IT. The idea: traditional IT has always been System 2 (deliberate, rule-based, reliable), and Large Language Models brought something new to that world: System 1, fast intuition.

That post has aged. Not because it was wrong at the time, but because the frontier models started to reason and became more like System 2. And now there’s Jev, a new kind of model on a serious hype run since TypeSafe AI launched it on 15 September. Its API buckled under demand within days, and the reactions range from breathless to dismissive (“it’s just a classifier”).

My take: Jev is a useful idiot. That’s not an insult. It’s a job description.

System 1 and System 2, revisited

Psychologist Daniel Kahneman described two modes of thinking in Thinking, Fast and Slow. System 1 is fast and automatic: recognizing a friend’s face in a crowd, knowing that 2 + 2 = 4, driving home on autopilot. System 2 is slow and effortful: working out 17 × 24, squeezing into a tight parking spot, filling in your tax return.

We use System 1 for most of the day. System 2 only steps in when System 1 can’t handle something, like when a child suddenly runs onto the road. And only System 2 can keep several things in mind at once. That’s why 17 × 24 takes effort: you have to remember that 17 × 20 is 340 while you work out 17 × 4.

System 1 has one big weakness. It hardly ever doubts itself. It quickly makes sense of what it sees and gives you an answer that feels right, even when it’s wrong.

Frontier models: from System 1 to System 2

In early 2024, an LLM started answering the moment you pressed enter; its first thought was the answer you got. Andrej Karpathy put it plainly at the end of 2023: LLMs only have a System 1. The dream was to let a model think about a hard problem for half an hour, and trade time for accuracy.

That dream came true. OpenAI’s o1 (September 2024) was the first widely used reasoning model, and every frontier lab followed. Today’s frontier models think before they answer, plan, use tools, check their own work, and can work on a coding task for hours. They’re slow, deliberate and expensive, just like System 2.

Ask a frontier model whether an email is a complaint, and by default it will think about it first. That’s System 2 doing a System 1 job, like catching a ball by first calculating its trajectory. You can switch the thinking off, although that gets harder with every new release. Then a frontier model answers straight away and is a System 1 thinker again. But it’s still a general-purpose model that answers in words. It spends tokens on text you’ll throw away, and you pay frontier prices for each of them. For a single email that doesn’t matter. For a million decisions a day, it does. That’s the job Jev was built for.

Jev: a natural fit for System 1

Jev comes from TypeSafe AI, co-founded by Diogo Almeida, who spent four years at OpenAI working on InstructGPT, ChatGPT and GPT-4. TypeSafe calls Jev a “System One model”, a direct reference to Kahneman. The name honors economist William Stanley Jevons, who noticed in 1865 that more efficient steam engines made Britain burn more coal, not less: make something cheaper, and we use far more of it.

Jev doesn’t write text, so it never burns tokens on words nobody reads. You give it a state (an email, a JSON object, a log line) and questions: pick one of these options, score this on that scale, is this statement true? It answers all of them in one go. For a choice, you get back the option it picked, a probability for every option, and a confidence score. It can be wrong, but it can’t make things up: it only chooses from what you defined.

Three numbers explain the hype:

• 70 to 500 milliseconds per answer. About the time it takes you to recognize that friend in the crowd. A frontier model thinking about the same question takes seconds, sometimes minutes.
• $42 per billion input tokens; output is free. Routing 10,000 emails of about 500 tokens each costs roughly 20 cents. TypeSafe claims Jev is 40 to 400 times cheaper than frontier models on its own benchmarks, and admits real-world gains will likely be smaller. Even a fraction of that changes what you can afford to automate.
• 70% means 70%. Jev is trained to be calibrated: when it says it’s 70% sure, it should be right about 70% of the time. Almeida’s point: a model that’s right 95% of the time is useless for automation if it can’t tell you which 5% it gets wrong. Where RLHF, which he worked on, rewards answers people like, Jev’s training rewards probabilities that match what actually happens.

It can be wrong, but it can’t make things up.

So why “useful idiot”?

Because Jev can’t explain why. It can’t write a sentence or plan ahead. It can’t make complex decisions either: the kind where you have to keep several facts in mind at once and reason from one step to the next.

Take a refund request where the order was partly delivered, the customer paid with a voucher, and the return period depends on the product. A reasoning model works through that step by step, just like you work out 17 × 24. Jev answers in one go, without a second step. You can split the decision into small questions and let your code combine the answers, but then your code does the thinking, not Jev. That’s why TypeSafe’s own documentation asks for small, self-contained questions.

And it can’t tell you that you asked the wrong question. If none of your categories fit an email, Jev still picks one. With low confidence, but it picks. A frontier model can tell you that you’re missing a category.

That’s the idiot part. The useful part: it’s instant, nearly free, and unlike our own System 1, it knows when it’s unsure, and tells you so in a number you can act on.

In politics, a useful idiot serves a cause without understanding it. For Jev, that’s the job. It doesn’t need to understand your business process. It needs to make the thousands of small calls inside it, fast, and raise its hand when it’s out of its depth.

Sending every small decision to a reasoning model is hiring a senior architect to sort the mail.

The hype goes wrong in two directions. Some treat Jev as a cheap replacement for an LLM, but anything that needs thinking, writing or planning is beyond it. Others wave it away as “just a classifier” and keep sending every small decision to a reasoning model: is this ticket urgent, is this tool call safe, which team should pick this up? That’s hiring a senior architect to sort the mail.

Use each for what it is:

	Jev (System 1)	Frontier model with thinking (System 2)
Answers in	70–500 milliseconds	seconds to minutes
Gives you	an option, a score or a yes/no, with probabilities	text, plans, code, explanations
Tells you how sure it is	as a probability trained to be calibrated	in words, by reasoning about it
Keeps several facts or steps in mind at once	no	yes
Can tell you that you asked the wrong question	no	yes
Use it for	the thousands of small calls	the few decisions that need real thought

Architectures for System 1 and System 2

In 2024 I described how traditional IT (System 2) could check GenAI (System 1). The roles have moved, but the patterns still work, now with three layers: plain code for the rules you can write down, Jev for the judgment calls you can’t write down but make thousands of times a day, and a frontier model for everything that needs real thought.

Intuition first, thinking on doubt: Let Jev handle every case and use its confidence to decide when to escalate, just like System 2 grabs the wheel when a child runs onto the road. Picture a service desk with 10,000 emails a day: Jev routes all of them, and the few percent it’s unsure about go to a frontier agent that reads the customer’s history, works out what’s really going on, and drafts a reply. Don’t rely on confidence alone, though: send complex decisions, like that refund, straight to System 2 by design, not only when Jev hesitates. LangChain shows a variant where Jev decides per request whether a cheap model will do or a reasoning model is needed: System 1 deciding when to wake up System 2.

The answer tells you what; confidence tells you whether to act.

TypeSafe AI documentation

Reflexes around the thinker: Let a frontier agent do the deliberate work (writing code, running commands, changing records) and let Jev check every step before it executes: is this command destructive, is this a prompt injection? Like the reflex that pulls your hand off a hot stove before you’ve had time to think. A second frontier model checking every step would double your costs and waiting time; a Jev check takes a fraction of a second and a fraction of a cent. Vercel reports that Jev checks commands for safety 5 to 18 times faster than the OpenAI model it used before, and more accurately.

The thinker trains the intuition: When you learn to drive, every gear change is System 2; a year later it’s System 1. Do the same in IT: let a frontier model do the thinking once (analyze the process, write the workflow, define the questions and options), then let Jev make those decisions a million times. Have the frontier model review a sample of Jev’s decisions every week, and rework the questions where Jev keeps doubting. As I wrote in 2024: checking an answer is far easier than finding one.

When to trust the idiot

Kahneman and Gary Klein found that intuition can be trusted in a regular environment with lots of practice and quick feedback: a firefighter’s intuition, not a stock picker’s. Same for Jev: use it for simple decisions you make over and over, where you find out afterwards whether it was right.

And measure. Calibration is TypeSafe’s promise, not yet independently proven: the benchmarks are its own, and it’s still unknown how well Jev holds up against input designed to fool it. Check on your own data whether 90% really means 90% before you let it act alone. Like any useful idiot, it can be played by the other side, so don’t make it your only line of defense.

Conclusion

In 2024 the story was that GenAI brings intuition to IT. Two years later, the frontier models have grown into deliberate thinkers, and Jev is built for intuition alone. Build systems where Jev makes the thousands of small calls and knows when to ask for help, so the frontier model can spend its expensive time where it matters. Our own brains have worked like that all along.

Don’t ask the idiot to think, and don’t make your thinker do the idiot’s job.

References:

• GenAI: Bringing intuition to IT – paarhu.is, May 2024
• Introducing System One Models & Jev – TypeSafe AI
• TypeSafe AI documentation
• A new kind of AI model from a ChatGPT inventor is thrilling developers – TechCrunch, September 2026
• Building a harness with Jev – LangChain
• Intro to Large Language Models – Andrej Karpathy, November 2023
• Thinking, Fast and Slow – Daniel Kahneman, 2011
• Conditions for intuitive expertise: A failure to disagree – Daniel Kahneman & Gary Klein, American Psychologist, 2009