The Other Half of Agentic Thinking

For two years the industry has been shipping better writers. Every model release does more: longer migrations, deeper refactors, documents that draft themselves. Agents write most of the code in my working week now, and the writing stopped being the problem a while ago.

The problem was everything waiting in front of the writing. Work arrives messy. A bug report pasted from a customer email. A voice note with three ideas in it, one contradicting the other two. A Slack thread that ends with “can we just make it work like before?” Someone has to read the pile, sort what is real, order what matters, and decide what needs a human answer before any code changes.

That part is decision-making, and every agentic stack I have seen runs it at human speed. The models got fast. The deciding did not.

The missing piece is a decider. That is what Jev is.

Jev: a new kind of model

Jev is a new model from TypeSafe, and it is a genuinely new category rather than another point on the generation curve: a decision model. Not a smaller or cheaper generation model, and not a clever prompt on top of one. It does not write text and it does not write code. It decides. Question in, decision out.

I feed it the raw input verbatim, along with the facts I already have. Which project, what changed recently, what constraints are in play. One call, and back comes typed judgment:

• What the input actually is, underneath the phrasing
• A priority order across everything in flight
• Risk gates: what can proceed now, what should wait
• What needs clarification from a human before it deserves work

It classifies and scores, near-instantly, at a fraction of what a generation call costs. Decision latency went from “whenever I got to it” to seconds. The pile still gets read. It just no longer gets read by me, first, every time.

Model one and model two

Kahneman split human thinking into a fast system and a slow one. The fast one judges instantly and cheaply. The slow one is deliberate, effortful, expensive, and lazy about waking up. My working week now runs the same way, in software.

The frontier models are model two, excellent at writing, migrating, refactoring, reasoning through a gnarly bug. Spending model two on sorting a pile of requests is a category error: you are paying slow, expensive thinking to do fast, cheap deciding.

Jev is model one. It answers the sorting questions instantly so the slow model never has to. Model two writes. Model one decides what is worth writing, and in what order.

The bottleneck was me

I run several codebases in parallel now, with agents doing most of the writing. Persistent terminals keep every session alive across days, so the work never waits for a machine to get ready.

It waited for me. Months were not slow because model two could not write the code. Months were slow because deciding what to write was a human-rate task sitting in front of machine-rate work.

That is why I keep saying that what used to take months is now a week of careful orchestration. It is an orchestration claim, not a model claim. The week became possible when decision speed stopped depending on my calendar. The mess becomes a typed plan in seconds, model two starts on the right thing instead of the loudest thing, and every diff still crosses my desk.

What a fast decider does not replace

A fast decider has a failure mode worth respecting: it will confidently gate the wrong thing if the questions it answers are wrong. So tuning those questions is real engineering. When a gate keeps misfiring, the fix is to change what the fast model is asked, in one reviewable place, and watch it for a week. That work does not do itself.

The division of labor in my working day is now explicit. Jev decides. Pi executes. Herdr keeps the terminals alive across days. Obsidian holds the plans. I bring the judgment: what gets built, what gets rejected, what is good enough to ship. The decision model removed me as the bottleneck. It did not remove me as the judgment, and the judgment is the part my clients actually rent.

If your bottleneck moved instead of disappeared

Plenty of teams adopted agents and discovered the bottleneck did not vanish. It moved, to whoever feeds the machines. If that is your team, a bigger model will not fix it. The writing was never the missing piece.

The other place this shows up is verification. When model two produces faster than you can check its work, checking becomes the constraint. I wrote about that side separately in When AI Gets Faster, Verification Becomes the Bottleneck, and about the work I still insist on doing myself in What We Still Do Manually When Building With AI.

Fast decisions and slow writing, both running, are what a modern engineering week looks like from the inside. If you want to know whether your codebase and your workflow are ready for that week, that is exactly what the codebase AI audit checks.