Every Jev post this week has the same line: up to 400x cheaper than an LLM.

So I built a 24/7 desk on it and priced every lane before scaling it up. Every post, email, alert and issue goes through Jev. Grok Bot writes only when it has to. Every decision goes into a ledger with a price next to it.

The decisions cost almost nothing. The bill didn't.

97% of that bill comes from a lane most people never measure: the 4% of events that go to a model that has to write something.

Jev is named after the Jevons paradox: make something cheaper and people use more of it, so the total bill goes up anyway. The idea is that Jev breaks that loop.

It doesn't break it. It moves it, from the decision to the escalation. Once you know where the bill ends up, one number controls it.

TLDR: Jev answers every route, score and yes/no. Code turns the answers into lanes. The daily bill is decisions x tokens x $0.042/M + escalations x cost per draft, and the second part is the one you tune. Code is in sections 5 to 8, the math is in section 3.

1. The numbers first

The second block is math on published pricing plus my own assumptions, not a real invoice. Every assumed number is marked as one.

2. What Jev actually is

Jev comes from TypeSafe AI. It is a System One model: you send it state and a narrow question with predefined answers, and it returns a typed answer with a probability and a confidence.

It does not write. No prose, no code, no reasoning. It also cannot answer outside the options you gave it, which is exactly why it works as a decision layer.

Two things from the docs that change how you build:

Jev does not see your question ID. Naming a field safe_to_publish adds no instruction. The requirement has to be in the question text and in each option's description.

Confidence describes the answer distribution. It is not the chance that the answer is right. Tune against labeled examples, don't read it as accuracy.

Public demos so far: Browser Use finding flights in 7 seconds for $0.0039, 1,018 research papers classified for $0.08, 500 emails triaged for 3.5 cents, a Claude session compacted from nearly 1M tokens to 86K in about a second. All of them are decision jobs. None of them asks Jev to write anything.

3. Where the paradox actually lands

Nobody in the launch threads writes this part down, so here is the formula.

Put the desk's numbers in:

The first part is so small that doubling it changes nothing. The second part depends on e, and Jev's price has no effect on it.

Now do what the paradox predicts. Decisions are cheap, so you watch 10x more sources and ask 5 questions per event instead of 3.

Usage went up 10x and so did the bill. Jevons was right. But look at where it went: $10.92 of the increase is Jev, $216 is writing.

So Jev doesn't break the Jevons paradox. It pushes it into your escalation rate. That is actually good news, because the escalation rate is the one number in the stack you fully control.

The bigger desk also changes time. At 500 ms worst case, 200,000 decisions take 27.8 hours on one worker, which is longer than a day. Plan for two workers first.

4. The desk

Four lanes, one decision layer, one writer, one person.

Grok Bot does two jobs. Its cloud machine runs the loop, because a desk that stops when you close your laptop is not a 24/7 desk. And a named bot handles the draft lane, the only lane that needs writing.

The Grok Bot to Jev wiring is my own setup, not an official integration. The loop is plain Python and runs on any box that stays on.

5. Setup

You need a TypeSafe account with API access and a key. Calls are billed to that account.

Test one question in the TypeSafe Playground before you write code. Paste a real event as state, ask "what should the desk do with this?", and read the probability it gives back. If you can't describe the four options clearly in the Playground, code won't fix it.

6. The decision: three questions, one lane

Every question here is a Choice, even urgency. Score would fit urgency better, but one question type means one answer format to read and fewer things to break when the SDK updates.

Most of the value is in those three if lines.

Parallel questions can't see each other's answers. That sounds like a limitation, but it gives you a free second opinion. When "urgency: now" and "lane: ignore" come back together, the desk is telling you it's confused, and it cost you zero extra calls.

7. The loop and the ledger

Every event adds one line to ledger.jsonl: what came in, all three answers, the lane, and an estimated token count. Without the ledger you just have a bot. With it you have a bill you can actually read.

I wouldn't ship this without the audit lane.

Mistakes in human and draft get caught, because someone reads them. Mistakes in ignore don't, because nobody ever looks at those events again. That silent lane is where a decision layer hides its errors.

At 20,000 events a day with about 70% ignored, 1% is 140 audits. At $0.03 each, that's $4.20 a day to know your false-ignore rate. Cheapest line on the bill, and the most useful one.

8. The daily bill

bill.py reads the ledger and prints the split. This is what Grok Bot sends me every morning.

For the desk day from section 3, the output would be:

Same picture as the hook, now with the audit included. Jev is under 3% of the total. If you only optimise the decision model, you're optimising 3% of the bill.

9. The threshold is a cost dial, not a safety dial

The first instinct is to raise FLOOR to make the desk "safer". But here every answer under the floor goes to human. A higher floor means more events in your queue, not fewer mistakes in the silent lane.

There's public data on this. The jev-harness repo, a community project under the TypeSafeAI org, benchmarked a coding-agent gate on 20 synthetic fixtures with live jev-1.13.0. Validation alone caught 7 of 20 bad proposals; with Jev review, 20 of 20. Then they swept the confidence threshold from 0.50 to 0.90, and it permitted zero bad proposals at every level. The threshold didn't catch anything by itself. It only blocked good proposals.

Different job, same lesson. The answer itself does the catching. The threshold only decides how much work ends up on a person.

So tune it like a budget:

Change one thing a week and check the audit lane after each change. That's the whole tuning process.

10. Grok Bot on top

Two named bots on the same Grok Bot machine, one job each. I set them up with plain English messages:

Grok Bot doesn't pick lanes, Jev does. It doesn't approve its own drafts, I do. And it doesn't post, because nothing in this desk posts.

The morning message is the whole interface. Six lines, and the last one tells me if yesterday cost more than it should have.

11. The guards

Every guard sends uncertainty up to a person, never down into silence.

12. What I haven't tested

The bill numbers are math on published pricing and assumed rates, not a month of invoices. Your T, e and C will be different, and C alone can change 10x depending on the writing model.

The 4% escalation rate and 70% ignore share are example assumptions, not measurements. Real feeds are noisier or quieter, and the audit lane tells you which.

The way the code reads answers follows the SDK Quickstart. Check the attribute names against your SDK version before leaving it running on its own.

I haven't measured Jev's accuracy on this kind of triage. The public numbers cover flights, papers, emails and code proposals. This is a different job, and the audit lane is there because I don't trust a decision layer I haven't checked.

13. The playbook

If it creates text, it goes to a writing model. If it picks, scores or answers yes/no, it goes to Jev. If it is an exact rule, it goes in code.

Put all your questions in one request. Parallel is almost free, and when the answers disagree, that's a signal you get for nothing.

Fail closed. An error is a human review, never an ignore.

Audit the silent lane. It is the only place a mistake can stay hidden.

Treat the threshold as a cost setting and tune it against the audit, not your gut.

Price the desk with the formula before you scale it. The bill lives in e, not in Jev.

The point

Jev brings the cost of a decision down to about four thousandths of a cent. That changes what an agent can afford to check.

But cheap decisions don't make the Jevons paradox go away. You'll watch more, ask more and escalate more, and the bill will follow the escalations, not the decisions.

So the question is no longer "which model is cheapest?" It's "how many events actually need a model that writes?" You set that number, you see it every morning, and it's the one that moves the bill.

$42 buys a million decisions. What you pay after that depends on your escalation rate.

Jev pricing, latency and question types are from TypeSafe AI's documentation and launch posts as of September 2026. Demo figures are from the public posts by Browser Use and early testers. The jev-harness numbers are from its own README. The Grok Bot wiring is my own setup, not an official integration.

If you want more breakdowns like this, I post one every couple of days on Telegram and X. Both free.

[X - https://x.com/gippp69

Telegram - https://t.me/GipArcAI](https://x.com/gippp69)

[X - https://x.com/gippp69

Telegram - https://t.me/GipArcAI](https://t.me/GipArcAI)

X - https://x.com/gippp69

Telegram - https://t.me/GipArcAI