What Does a Jev Decision Actually Cost? The Math Behind $0.042 per Million Tokens 💸🧮

""100x cheaper than an LLM"" is the kind of claim that makes any developer squint. Cheaper at what? Per token? Per request? Per useful result? Pricing pages love a headline number and hate a worked example. So let's do the worked example. 🧾

TypeSafe AI's Jev, the ""System One"" model that returns typed decisions instead of text, publishes a pricing page on the Jev showcase site, madewithjev.com/jev-pricing, with real numbers from published builds. This post walks through them, shows the one billing detail that changes how you should design calls, and gives you a small Python calculator so you can estimate your own bill before you write any integration code.

The Core Pricing

💵 Input: $0.042 per million tokens
🆓 Output: free
🚫 Free tier: none listed on the pricing page
🏷️ Model: Jev 1.13, with jev-latest pointing at the current version
⏱️ Latency: 70 to 500 ms per call
🚦 Limits: 250,000 tokens per second and 1,200 requests per minute
📏 Context: 64k per request, with 32k for state plus the longest single question

Output is free because Jev returns a choice, a score or a probability, so there's almost nothing to meter. On a chat LLM the output side is the expensive part; here it simply vanishes from your bill.

What Real Builds Actually Paid

The pricing page collects figures from 15 published implementations. These are self-reported by the builders and gathered by the showcase site, so treat them as field data, not an audit:

Median cost per decision: $0.000068, about 14,727 decisions per dollar
Range: $0.000006 to $0.0007 per decision
Largest published bill: $12.69 for 123,805 requests
100,000 posts analyzed in 20.4 seconds: $0.67
500 emails triaged: $0.035
26-sheet construction plans: $0.0052

Let me sanity-check those with my own arithmetic (derived, not published). At $0.042 per million tokens, $0.67 buys about 16 million tokens, which spread over 100,000 posts is roughly 160 tokens per post. That's a believable short social post. And $12.69 across 123,805 requests works out to about 2,400 tokens per request, which suggests those requests carried substantial documents. The numbers hang together, which is more than I can say for many pricing claims. 🙂

The One Line That Changes How You Design Calls

""The state is billed on every call.""

Read that twice. You pay for the text you send (the document, ticket, transcript), and you pay for it again on every call. Questions, by contrast, are cheap. The page notes one project asked 61 questions for $0.0004.

The design consequence is simple and it's the opposite of how many people write LLM code:

✅ Batch questions into one call per item. Ask everything you might need about a document at once.
❌ Don't loop one question per call over the same big state. You'd pay for the same 5,000-token document ten times.
✅ Trim the state. Send the relevant fields, not the whole record. This cuts cost and helps accuracy, since irrelevant material hurts.

Estimate Your Own Bill (Python)

PRICE_PER_MTOK = 0.042  # USD per million input tokens; output is free

def est_tokens(text: str) -> int:
    return max(1, len(text) // 4)   # rough rule of thumb: ~4 chars per token

def cost(state_tokens: int, question_tokens: int, n_items: int, calls_per_item: int = 1):
    per_call = state_tokens + question_tokens
    total_tokens = per_call * calls_per_item * n_items
    usd = total_tokens / 1_000_000 * PRICE_PER_MTOK
    return total_tokens, usd

# 200k support tickets, ~600-token state, 15 questions (~300 tokens), ONE call each
tokens, usd = cost(600, 300, 200_000)
print(f""{tokens:,} tokens -> ${usd:.2f}"")            # 180,000,000 tokens -> $7.56

# The same job asking each question in its own call: state is re-billed 15 times
tokens, usd = cost(600, 20, 200_000, calls_per_item=15)
print(f""{tokens:,} tokens -> ${usd:.2f}"")            # 1,860,000,000 tokens -> $78.12

Same questions, same tickets, roughly 10x the cost, purely from repeating the state. That's the billing insight in one comparison. (The token counts are my own estimates. Measure your real prompts before budgeting.)

How Does It Compare to an LLM?

Vendor and third-party posts quote wide ranges of 40x to 400x cheaper than frontier models. One published comparison from a pricing roundup: 1,000 eight-way routing decisions cost $0.0151 on Jev versus $0.6089 on a frontier model, about 40x. That's a single third-party data point, and the ratio depends on the model you compare against, how long your state is and how much a frontier model would output. The honest takeaway: for repeated classification, routing and scoring, Jev's cost is small enough that it usually stops being the thing you worry about. For tasks it can't do (writing, reasoning, arithmetic), the price is irrelevant because it's the wrong tool.

Where You Can Pay for It

🔑 A direct TypeSafe API key
🔀 OpenRouter
☁️ Cloudflare AI Gateway
🟩 Netlify AI Gateway
🧰 A LiteLLM proxy

Gateways are handy if you already centralize keys, logging and budgets. I've also seen reports that Vercel's AI Gateway offered Jev free for a limited window in late September 2026. Promotions like that expire fast, so check the current terms before you plan around one.

Cost Traps to Watch ⚠️

Re-sending big state. Covered above. This is the number one way to overspend.
Retries and rate limits. A 429 means you retry, and a retry re-bills the state. Keep concurrency below 1,200 requests per minute.
Unpinned model versions. jev-latest can change behavior, and possibly pricing. Pin a version like jev-1.13.0 in production.
Cheap decisions at massive scale. $0.000068 is tiny, but at 100 million decisions a month it's about $6,800. Do the multiplication.
Cost is not accuracy. A 100x saving that misroutes 10% of tickets can cost far more in human cleanup. Measure error rates alongside cost.

Frequently Asked Questions about Jev Pricing

Q: How much does Jev cost?

$0.042 per million input tokens, with output tokens free, according to the published pricing.

Q: Is there a free tier?

The pricing page lists none. Some gateways have run limited-time promotions, so check the current terms with your provider.

Q: What does one decision cost?

Across 15 published builds, the median was about $0.000068 per decision, with a range from $0.000006 to $0.0007. TypeSafe's own benchmark estimate is around $0.0004 per case.

Q: Why is output free?

Jev returns short typed answers (a choice, a score or a probability), so output is tiny and not metered.

Q: What is the biggest factor in my Jev bill?

The size of the state you send, because it's billed on every call. Questions add comparatively little, so batch them into one call per item.

Q: How do I reduce my Jev costs?

Batch questions per item, trim the state to the relevant fields, avoid needless retries and pre-filter items with cheap code before sending them.

Q: What are the rate limits?

250,000 tokens per second and 1,200 requests per minute. Exceeding either returns a 429, and the SDKs retry with exponential backoff.

Q: Can I access Jev through OpenRouter or LiteLLM?

Yes. The pricing page lists a direct API key, OpenRouter, Cloudflare AI Gateway, Netlify AI Gateway and a LiteLLM proxy as payment routes.

Q: Is Jev really cheaper than GPT or Claude?

For classification, routing and scoring, published comparisons show large savings, on the order of 40x in one example. It can't replace them for text generation or reasoning, so compare on the tasks you actually run.

Q: How do I estimate my monthly bill?

Multiply average tokens per call (state plus questions) by calls per month, divide by one million and multiply by $0.042. The calculator above does exactly this.

Your Turn 💬

If you're running Jev in production, I want your real number: what's your cost per decision, and how many tokens of state do you send per call? And if you're still on an LLM for classification, what does that bill look like today? Drop your figures below. A comment thread of real invoices beats any pricing page. 👇

Jev Pricing Explained: $0.042 per Million Tokens, Free Output and What a Decision Really Costs (2026)