What a Jev decision costs

What the vendor publishes

Read from the announcement on 2026-09-23. It is a launch post rather than a pricing page, so the figures arrive in a comparison table against frontier models — which is also why they are worth reading carefully: the contrast is the point, and the absolute number is small enough that it is easy to skip past.

The one line in the post that reads like a cost model: an engineer "was worried about making 10 queries a second (which ends up costing ~$7/hour)". That is the figure we run backwards below — with the caveat that it is a sentence in a blog post, not a rate card.

What one call cost us

We have paid for this. On 2026-09-20 we sent 20 identical requests — one support-ticket state, three questions at once — with a key we own, and recorded what came back. The state was 420 tokens:

420 tokens ÷ 1,000,000 × $0.042 = $0.0000176 per decision

That is $0.04 per million decisions, or $ 0.02 per thousand. The whole experiment — every call in it — cost $ 0.0003528. At that price the model is not a line item; the engineering time you spend deciding when to call it is, and that is the honest way to read this page.

The sentence that tells you your own bill

That aside in the launch post — a loop making 10 calls a second at about $7 an hour — is a worked example of the only thing that moves this cost. Run it backwards at the published rate and the state being sent is roughly 4600 tokens:

$7 ÷ (10 × 3,600 calls) = $0.000194 a call ÷ $ 0.042 per million ≈ 4600 tokens

We are not claiming that is the number their engineer sent — the $7 may include other compute, and the sentence is a blog post. We are claiming it is the right shape of question, because it produces the only arithmetic that matters:

Sorted by what actually changes: the last two rows are the same loop with a different state strategy, and they differ by roughly 9×. The per-call price is the same in both.

Which is why the teams we have read spend their effort on the state rather than on the model: index the page and send the elements that could be acted on (browser-use, 7.1 seconds for a flight search), trim tool results before they fill a context (a Claude plugin, 1M → 86K tokens), or accept a bigger state and cap the rate.

What is not on the price list

The published rate is per input token, and the things that decide a real invoice are not tokens:

• Retries. A decision you have to ask twice for costs twice, and the cheap way to avoid that is the option set, not the model.
• The confidence threshold. If you route to a second model below a threshold, that model's price is in your loop's price — see the routing patterns in the guide.
• Latency, which you pay for in a different currency. Our own calls had a median wall time of 783 ms from a machine in Asia, against the vendor's 70–500 ms on their own machines; the difference is network and TLS, and it is the number your users feel.
• Volume terms. We do not have them and cannot quote them. Nothing here is a contract.

What this page cannot tell you

It cannot tell you your monthly bill, because the state is yours. It cannot tell you whether Jev is worth its price, because that depends on what a wrong decision costs you — the same $0.0000176 is free in a moderation queue and expensive in a trading loop where being 300 ms late is the whole risk. It cannot confirm the vendor's speed numbers either: theirs are measured on their machines, ours include a network from Asia, and neither is your production.

And it is a pricing snapshot: read 2026-09-23. Rates change without notice, and this page will not update itself — the arithmetic above survives it, because a rate is one factor and the state is the other.