Special Edition: Jev and Its Impact

What happens to the token economy when a model stops writing and starts deciding

There is a particular kind of Sunday morning that begins with two small silver boxes humming on a desk and a question. A question I am asking myself now. If the whole industry has spent three years learning to pay for tokens the way we once paid for long distance calls, priced by the minute and rationed accordingly, what happens the moment a model arrives that does not bill you for the talking at all. That was the week Jev showed up in my sandbox, and it rearranged more furniture than I expected.

Let me set the scene honestly, because the setup matters as much as the model. I had two NVIDIA DGX Spark units on the bench, each carrying a GB10 and 128GB of unified memory, joined by a single QSFP cable with no switch in the middle. NVIDIA Sync did the introductions, walked the ConnectX-7 topology, planned the addresses, and exchanged keys over the fabric while I made coffee. Two hundred gigabits of RoCE between the nodes, 256GB of unified memory once you add the pair together, and a combined compute budget that would have been a research grant not so long ago sitting quietly next to a plant that needs watering. On that cluster I was running Nemotron as my generator, the model that actually writes prose and code and long chains of reasoning. And then, off to the side, doing something entirely different, I wired in Jev.

The model that refuses to talk

The first thing you have to unlearn about Jev is the instinct to ask it for words. It will not give you any. TypeSafe AI, the San Francisco lab that launched it this month, built Jev as what they call a System One model, a nod to Kahneman that turns out to be more than marketing shorthand. System Two is the slow deliberate reasoning we now associate with frontier LLMs, the part that drafts your paragraph and argues with itself about the third clause. System One is the fast intuitive judgment your brain renders before you have finished forming the sentence. Jev is that second thing, cast in silicon and priced accordingly.

In practice you hand Jev a chunk of state and a list of typed questions, and it hands back exactly one answer per question. The questions come in three shapes. A Noul is a yes or no that returns a probability between zero and one. A Choice picks from a fixed set of options and gives you the distribution across them. A Score places the input on a defined scale. That is the entire vocabulary. No generation, no free text, no helpful little paragraph explaining its reasoning that you then have to parse with a regular expression at two in the morning. It evaluates every question in a request independently and in parallel, so one answer never becomes context for the next, and adding more questions barely moves the latency.

The numbers are what made me sit up. TypeSafe reports latencies of seventy to five hundred milliseconds end to end, with most queries landing near a hundred. Input runs about four cents per million tokens, and output is free, because there is no output to speak of in the generative sense. Their own measurements put it at roughly 193 times faster and 444 times cheaper than an LLM doing the same classification work, and while I always discount a vendor benchmark by a healthy margin, even a fraction of that gap is a different category of thing. The model behind all this, jev-1.13.0 while I was testing, was trained not with the usual preference tuning but with something they call Reinforcement Learning for Calibrated Decisions. The goal is not fluency. The goal is calibration, so that the answers it assigns ninety percent probability to turn out right about ninety percent of the time. When you are building on top of a decision layer, calibration is the property you actually wanted all along and rarely got.

Two systems, one cluster, and a very TypeScript afternoon

Here is where the two silver boxes and the model that refuses to talk finally meet. The natural architecture almost draws itself. Nemotron lives on the cluster as System Two, the expensive deliberate generator, spread across 256GB of unified memory and answering the hard open-ended questions. Jev sits in front of it as System One, the cheap fast gate that decides what even reaches the generator in the first place. One does the reasoning. The other decides whether reasoning is warranted, which model should handle it, whether the tool call is safe, and how confident we should be before we act. The division of labor is old. What is new is that the fast half finally costs almost nothing.

I built the harness in TypeScript, which is where Jev clearly wants to live. The SDK gives you a DecisionSession, typed routers, and immutable DecisionProgram values, and the whole thing type checks against your questions the way a good compiler should have let us do with model outputs years ago. For the coding experiments I leaned on jev-code, an interactive CLI that generates programs through constrained AST construction rather than free text. That phrase deserves a moment. Jev does not write code either. It selects productions from a grammar, one bounded decision at a time, and because every choice is a valid node in a real syntax tree, the program is correct by construction before a single character touches disk. Each decision shows up as a card with the selected production and a confidence level, a live pane renders the file as it grows, and you approve tool calls per invocation or per session. It ships adapters for TypeScript, Python, Bash, JavaScript, C, Rust, Go, Lua, and Ruby, and watching it assemble a statistics module without ever once emitting a syntax error was a small uncanny pleasure. It is not faster because it types quickly. It is faster because it never has to be wrong and then corrected.

The mental model I settled on by lunch was this. Nemotron is the author. Jev is every editor, router, classifier, and safety officer standing between the author and the reader, and all of them now work for spare change and answer in a hundred milliseconds.

What I actually automated

A sandbox is only interesting if you point it at real work, so I pulled a few industry shaped problems off the shelf and wired each one as a Jev gate in front of the Nemotron generator. None of this is production. All of it is the kind of thing a product manager sketches on a whiteboard and then asks whether it is affordable, and the answer this time kept coming back yes.

The first was document intake for a financial services flow, the unglamorous front door of half the enterprise. Every incoming item gets a Choice for its type, a Score for completeness, and a Noul for whether it needs a human. Only the genuinely ambiguous cases, the ones where Jev’s confidence sagged below the threshold I set, ever woke Nemotron. The rest were routed, scored, and filed before the generator finished loading its context. The second was support ticket triage, the same shape wearing a different costume, where Jev classified intent and urgency and I let it fan out dozens of typed questions per ticket because doing so cost me almost nothing. The third was the one I care about most given how I spend my days, a code review gate in a CI sandbox, where Jev scored diffs for risk and flagged the tool calls that deserved a second look before any expensive agent run began. The fourth, and the one that felt most like the future, was using Jev as the auto mode safety classifier the LangChain folks describe, evaluating each proposed tool call for danger and blocking the reckless ones proactively rather than apologizing for them afterward.

What struck me was not any single result. It was the change in how I wrote the code. I stopped rationing decisions. When a classification is effectively free and lands faster than a network round trip, you stop asking whether a check is worth a model call and simply add the check. I found myself inserting decision points everywhere, gating things I would never have gated when each gate cost a real inference. Which is precisely the moment an economist would have tapped me on the shoulder.

Jevons walks into the token factory

William Stanley Jevons noticed in 1865 that better steam engines did not reduce Britain’s appetite for coal. They increased it. Every gain in efficiency made coal more useful, more uses appeared, and consumption climbed rather than fell. We have spent a century and a half rediscovering his paradox in every efficient technology we have ever built, and we are about to rediscover it again inside the data center.

Think of the modern inference fleet as a token factory, because that is what it is. It takes in electricity and capital and produces tokens, and for three years the entire economic conversation has assumed those tokens are precious. We prompt carefully to save them. We cache to avoid regenerating them. We route to cheaper models to spend fewer of them. The whole discipline of building on LLMs has been, quietly, an exercise in rationing an expensive output. Jev breaks that assumption at the root. When a decision costs four cents per million inputs and returns nothing you have to pay for, the rational move is not to make fewer decisions. It is to make oceans of them.

So the factory does not go idle. It runs hotter. This is the part that trips up the intuition that cheaper inference means smaller bills and cooler racks. The unit price of a decision collapses, and total decision volume explodes to fill the space, and the aggregate load on the fleet goes up rather than down.

My own sandbox was a miniature proof. The moment gating became free I added an order of magnitude more gates, and my two little boxes were busier at the end of the afternoon than they had any right to be. Multiply that instinct across every enterprise that suddenly finds classification, routing, scoring, and safety checking too cheap to meter, and the token factory of 2027 is not a leaner operation. It is a far larger one running a different product mix.

That product mix is the real story, and it changes where the factory needs to sit. The expensive System Two reasoning, the Nemotron sized work, still wants the big centralized fleets with their power and their cooling and their capital intensity. But the System One decisions, now that they cost almost nothing and run in a hundred milliseconds, no longer need to make the trip to the cloud at all. They can live on two silver boxes on a desk, on a QSFP cable, at the edge, next to the plant that needs watering. The decision layer detaches from the generation layer and comes home. The factory keeps the smelting. The stamping moves to wherever the work happens to be.

From sparse tokens to cheap ones

Underneath the paradox is a shift in what a token even is, and this is the part I think we will still be talking about in a year. LLM tokens are sparse in the economic sense. Each one is generated sequentially, each carries reasoning, each has a real marginal cost, and because of all that you spend them the way you spend anything scarce, with care and with guilt. The entire architecture of prompting grew up around the sparseness. You compress, you truncate, you summarize, you beg the model to be concise, all of it a response to the fact that every token on the way out costs you something and takes its turn in line.

Jev tokens, if we can even call them that, are volume tokens. They flow in cheaply, they return as typed decisions rather than generated prose, they evaluate in parallel rather than in sequence, and the marginal cost of one more question rounds to nothing. We have seen this movie in other industries and we know how it ends. Long distance minutes gave way to packets that cost effectively zero and we stopped counting them. Mainframe cycles gave way to commodity compute we now spray at problems without a second thought. Artisanal scarcity gives way to industrial abundance, and the abundance reshapes everything built on top of it.

The center of gravity of the whole token economy is sliding from a small number of expensive, deliberate, sequential tokens toward an enormous number of cheap, structured, parallel ones, and most of the mental models we carry into architecture reviews were built for the world we are leaving.

This is a topology story, not a feature story, which is the lens I keep returning to. The headline is not that Jev is fast, though it is, and it is not that it is cheap, though it is that too. The headline is that the decision boundary in an AI system has just become almost free to place, and almost free to place anywhere, and that quietly relocates half the workload out of the expensive room and into the cheap one. When you can afford to ask a thousand calibrated questions for the price of one generated paragraph, you stop building systems that reason and occasionally decide, and you start building systems that decide constantly and reason only when a decision tells them to. Same compute graph. Different rooms. A very different bill.

The Sunday

I turned the cluster off around dusk, which felt faintly absurd given that the whole point had been how little any of it cost to run. Two boxes, one cable, a model that will not say a word, and an old Victorian economist standing in the corner nodding at all of it. The engineers among you will want the benchmarks and I will bring them, properly measured, in a follow up. The product managers among you already know what to do with a decision that costs four cents a million and answers before the page finishes loading. And the philosophers among you, my usual company on a Sunday, might sit for a moment with the strangeness of a model whose entire contribution is to know when to stay quiet.

We spent three years teaching machines to talk. The next interesting move was teaching one to decide and then, blessedly, to shut up.

Cheap decisions. Expensive reasoning. Learn where each one lives.

Sources and further reading

Flavio Copes, deep dive on Jev, TypeSafe’s System One model, https://flaviocopes.com/jev/

LangChain, building an agent harness with Jev, https://www.langchain.com/blog/building-a-harness-with-jev

Vercel Knowledge Base, classify, route, and score with Jev and the AI SDK, https://vercel.com/kb/guide/typesafe-jev-and-ai-sdk

rhighs, jev-code, interactive TypeScript coding CLI over Jev typed decisions and constrained AST generation, https://github.com/rhighs/jev-code

NVIDIA Technical Blog, run local AI agents with faster models and multi-node clustering on DGX Spark, https://developer.nvidia.com/blog/run-local-ai-agents-with-faster-models-and-multi-node-clustering-on-nvidia-dgx-spark/

LMSYS Org, NVIDIA DGX Spark in-depth review, https://www.lmsys.org/blog/2025-10-13-nvidia-dgx-spark/

Search This Blog

Patterns that Connect: AI, Management, Metaverse, Quantum, Philosophy, and Physics