Jev is about to change the AI economy

Yesterday, the AI Disruption Weekly Award went to TypeSafe and their new System One model, Jev. Personally, I think this release will change how many products work with reasoning models. Not because it’s the best reasoning model. It’s actually not. Because it gives you a real incentive to move from one system that uses one expensive model to a system that uses two systems.

Jev is a System One model, and we’ll get to what that means in detail soon. But the AI economy is about to get another disruption in the way engineers meter and entitle credits and tokens. So this week I want to dive a little into the AI economy of tokens, how TypeSafe is going to disrupt this market with System One and System Two models, and how you should take care of it if you are the one metering the system.

What is Jev #

I think the first thing, before we dive in, is to give a short explanation for people who were sleeping on the internet yesterday. What is Jev, why is it making so much noise out there, and why you should care.

Today, LLMs are pretrained to predict the next token, then go through reinforcement learning. For the chat models, it’s RLHF, learning from human feedback. For reasoning models, it’s RLVR: learning from verifiable rewards, like math problems and unit tests that can be checked.

In both cases, you get back a string, and you don’t know in advance how long it will be or what shape it will take. You give an input, and somehow the LLM understands that it needs to give you more output than you aimed for. That happens because they are trained to be better and better at giving you what you need, and “what you need” was defined by human raters, and human raters like a full answer with an explanation. The reasoning models add a chain of thought on top of that, so even more output tokens before the actual answer.

Then we added harnesses, and I think this is where it got out of hand. An agent loop makes a lot of small decisions along the way: which tool to call now, is this ticket urgent, is this file relevant, and so on. Those are decisions, and we gave them to the same model we use to write code and essays. So the large language models, especially the reasoning ones, started to do a job that is not required from them.

It’s not that they shouldn’t do it. They should. But they weren’t built for it. If you are using a chain of thought, or one of the System Two models, which means the sophisticated reasoning models, to make those decisions, you are paying a lot of money for a result that doesn’t need that cost. It costs you in compute, in the time it takes, and in tokens. Output tokens especially, which are usually around five times the price of input.

So it became a problem, and TypeSafe got to a solution. Their founder is Diogo Almeida. He was at OpenAI; he co-invented ChatGPT and was a core part of RLHF in the last couple of years, so he knows exactly what he is complaining about.

Their solution is to stop asking one model to do everything and split the work into two systems.

The first system is what they call System One, the one that makes the decision. The name is from Kahneman's Thinking, Fast and Slow. System 1 is the fast, intuitive judgment; System 2 is the slow, deliberate reasoning. Today we are paying System 2 prices for System 1 work.

The training is new too. They call it Reinforcement Learning for Calibrated Decisions, RLCD. RLHF rewards the answer humans prefer. RLVR rewards the answer that passes the check. RLCD rewards a decision together with a probability, and the reward is about whether that probability was honest, meaning if the model says 80% it should be right about 80% of the time. So training is about making the best decision and knowing how sure it is, and that’s what the model is optimized for.

Because of that, it can act as System One. It gets unstructured data, so for example millions of emails, or a diff and your code review rules, and it gives you very fast, very accurate decisions on it, each one with a number that says how much to trust it.

Here I need to sharpen something I said in the beginning. I said it’s not the best reasoning model. It isn’t; it doesn’t reason at all in the output sense. But the claim TypeSafe makes- and it’s their claim- that nobody outside has reproduced yet is that, on this kind of task, Jev is roughly as smart as the frontier LLMs. They compare it to GPT-5.6 Terra. And it does that two orders of magnitude faster and cheaper. So it’s not a small model that is cheap because it’s small. If they are right, it’s frontier-level decisions at a price below the small models.

I also went through their docs and the launch post because they include details that change how you should think about metering. First, how you actually call it:

• Jev does not write text. You send it a state, which today is text only, and a list of typed questions, and you get typed answers back. That’s the whole API.
• Three types of questions, and you mix them in one call. Choice picks one option from a list you define, up to 255 options. Score rates the state against levels you define. Noul is a yes/no question, and the answer is the probability that it’s yes.
• All the questions in one call are answered in parallel, in one pass, not token after token. That’s why adding questions barely changes the latency, and why there is no output to bill. 70 to 500 milliseconds per call, against 3 to 329 seconds for the frontier reasoning models.
• $0.042 per million input tokens, output free. Closed API behind a waitlist, Python and JavaScript SDKs, no weights.

And second, what you can and can’t trust in the answer:

• Choice and Score come back with the full probability distribution over your options, plus a confidence number between 0 and 1 computed from its shape. Concentrated on one option means high; spread out means low. Noul has no separate confidence; the probability is the answer.
• Calibrated means that out of everything Jev gives 0.8 to, about 80% should be right. That’s across many predictions. One specific answer can still be wrong.
• “Can’t hallucinate” means the output is always one of the options you defined. No option that doesn’t exist, no broken JSON, no tool that isn’t there. It can still pick the wrong option. TypeSafe says this themselves; the 0% in their chart is a design property, not something they measured.
• They measured their numbers on their own laptops on the US West Coast, and they write that they can’t prove the price isn’t subsidized.

One design rule from their docs that I liked: a question should ask one thing. If you need to weigh several factors, ask each as its own question and combine them in code. The weighting lives in your code, not in a prompt, which is exactly where a metering guy wants the logic to be.

So these System One models can now act as the decision layer on top of the extensive reasoning models and make it way cheaper. How much cheaper? This is crazy. I saw a GitHub repository that compares code review agents. The agent takes the code, creates the test spec, uses the code review rules, and classifies whether the code passes the review. With a 98% success rate, it is 45x cheaper than the Gemini Fast model, and the Gemini Fast model is super cheap and 272x cheaper than Fable 5.1.

These are one repo’s numbers on one workload, not a benchmark, but they are in the range TypeSafe publishes itself: 238x lower input price than Fable 5.1 on their homepage, and up to 444x cheaper on their workflow evals, which they say is the high end. It means that even if you give the 2% you are not sure about to Fable to make the decision, you’d still get a very cheap result. And this is what is disrupting the AI economy, on multiple levels.

How it disrupts the AI economy #

1. The assumption that we meter the AI economy per token and compute cost. Many engineers built the credit system into their product with the assumption that they are metering input and output tokens. So they put a metering component on Langfuse or something like that, or they put it on their AI gateway, on OpenRouter for example, and this metering component meters how the input and the output happen. With this new type of model, there is no output pricing anymore. Jev doesn’t charge you for any type of output (their pricing table literally says “too cheap to meter”, which for someone who works on metering is a fun sentence to read), and the input is $0.042 per million tokens, so way cheaper. It means for one dollar you get way more results than what you have today.
2. Canceling the one-to-one between tokens and credits. I think this is the most important one. When you give credits to your customer, it’s never a token itself, but you usually have some constant currency exchange between how much a token costs and how much a credit is. Now, if we give the power to the engineers, if we have the power to control System One and System Two, then there is a way more complex currency exchange here. If our system does classification, or something else that Jev is good at, then we have one currency for the decisions that we made and succeeded with, but we also have another currency for the ones that require either a human or an LLM decision. TypeSafe actually documents this as a pattern. They call it confidence-gated routing: the answer tells you what, the confidence tells you whether to act, and below some threshold you route to a bigger model or to a person. So the routing is yours, and it lives in your code. And this disruption means you can’t anymore trust not only the currency exchange, but the piece of code you built to do this currency calculation. You need to build a more abstract layer for your metering, in a way that is more robust and can actually run this calculation.
3. Another power that AI engineers are getting now. With LLMs, the model provider can truly blow up your output volume to get more money from you. No provider has said this, but if Anthropic, for example, wants to charge more while using less compute, they can put a small model on top of the reasoning model to make the output bigger. Okay, it might even be good for the customer. But at the end, it creates an overhead you can’t control. If we’re moving into models that, by definition, can predict how the output will look, we get into an economic principle that is way more sophisticated than this one.
4. Prediction. I think this one is one of the hardest problems today in metering, entitling, and monetizing AI tasks. Of course, Jev doesn’t charge for output today, but at some point we’ll price it. Interesting detail from the SDK: the usage object already returnsoutput_tokens ; the number is just priced at zero right now. The idea that we now have models where we can predict the output, because it’s structured, is a game changer for AI products that run mostly on decisions and less on content creation. Not only that, many of the existing AI providers can move into System One and get predictable output. When you know where AI companies at scale leak millions a month, that’s something that changes the whole picture.

One more thing, and I take this from their FAQ. Jev is named after William Stanley Jevons, the guy who noticed that making steam engines more efficient made coal consumption go up, not down. TypeSafe expects the same for intelligence: every order-of-magnitude drop in cost opens orders of magnitude more use cases. If they are right, and I think they are, cheaper decisions don’t mean less to meter. They mean a lot more decisions, at a price per decision that the metering you have today was never designed for.

Where to meter AI usage #

So, where should we meter? One outcome of this disruption by TypeSafe is the question we always ask ourselves at Stigg, and also try to answer: what is the right endpoint where users can meter and entitle their product?

At first, we thought metering should sit only on inference, on the AI gateway, which makes sense because that is where your compute cost goes. But at some point we also got harnesses. A harness's output also costs a lot of money. So, for example, a harness that opens a browser, especially a browser in the cloud, can sometimes cost even more than your AI tokens. And then we got to a point where AI applications need to add metering and entitlement enforcement in the harnesses too. And with tooling, we got another layer.

Now System One adds one more. A Jev call is one request, but it can carry many questions, all evaluated in parallel against the same state, and adding questions barely changes the response time or the input tokens. So what unit do you meter? The call? The question? The tokens in the state? I don’t have a final answer here, and I don’t think TypeSafe has one either. That's why you can’t hardcode it.

I think this disruption - models that change the way AI consumption metering works- shows that you should definitely not tie your metering, entitlement, and enforcement solution into one layer of your application. You need a composable layer where you can meter from anywhere and still have one source of truth. That’s the ledger. And on top of it you can create something that works well for your setup.

One interesting thing I investigated last week was connecting a metering solution to my Langfuse observability instance. And I found one place where I can meter, and of course it doesn’t help enforce entitlement if someone runs out of credits, but it still gave me a single source of truth for logging metering. So I think that’s a direction. But you should still think about where your entitlement enforcement lives, especially now that we've had this disruption.

I’m super bullish on System One models, and I think we’ll see many AI engineers in the next couple of weeks migrating to this architecture, now that they've got the control in their hands. Super interesting times.