What $1.26 bought: a real day of TypeSafe Jev

The usage page

Over 24 hours, one developer machine made 54,890 requests to TypeSafe’s Jev model, used 38,304,199 tokens, and the console estimated the spend at $1.2609.^[1]

That is the whole story in one sentence, and the screenshot below is where it comes from. It is the console’s Usage page, captured on 15 October 2026. We use it as raw material rather than as a boast: the aim is to show how to read such a page, what its numbers do and do not support, and what the same volume would have cost elsewhere.

How Jev bills

Jev is priced per input token: $0.042 per million, or $42 per billion. Output tokens are free.^[2] The Usage page repeats this in its footnote: “Estimated at $0.042/MTok input · Free output.”

That makes the bill easy to check. Multiply the input tokens on the page, 30,021,743, by the price.

It comes to $1.2609, exactly the figure shown. So the spend is the input tokens alone, at list price. Two things follow. First, the page’s spend is an estimate, as its asterisk says. Second, because output is free, the cost of a Jev call depends on how much you send, not on how much comes back.

What a request weighs

Divide the totals by the 54,890 requests and a typical request is small: about 547 input tokens, and about 698 tokens of all kinds. At the estimated price each costs about two thousandths of a cent, and a thousand requests cost about two cents.

The 8.3 million tokens that are not input, the difference between 38.3 million and 30.0 million, are presumably output, which Jev does not charge for. The screenshot does not label the two colours in the Tokens chart, so we treat that split as an inference.

The same tokens elsewhere

The natural question is what this would have cost on a general-purpose model. To answer it honestly we need real prices, not guesses. Anthropic publishes its list prices per million tokens: Claude Haiku 5.5 at $0.10 for input and $0.50 for output (for prompts up to 100,000 tokens), Sonnet 5.5 at $2 and $10, Opus 5.5 at $4 and $20, and Fable 5.1 at $10 and $50.^[3] Applying these to the same 30.0 million input and 8.3 million output tokens gives the comparison below.

The spread is large and the honest reading is nuanced. Against Anthropic’s smallest model the same tokens would cost about $7.14, roughly 5.7 times as much. Against the larger models it is 100 times or more. Which one is the fair comparator depends on what job you would otherwise give the model.

A price comparison also leaves a lot out. It assumes the other model would use the same number of tokens, that discounts do not apply, and, most importantly, that the answers are equally good.

Why a call is cheap

Jev is described by TypeSafe as the first “System One” model: built for fast, structured decisions that software can use directly, returning typed answers and probabilities rather than generated text.^[4] It does not write replies, produce code or explain its reasoning.^[4] It answers closed questions: pick one of these options, rate this against these levels, or give the probability that this is true.

That narrow job is the reason a request can be small and the output free. The docs’ advice follows from it: keep your code in control of the workflow and give the model narrow, structured decisions.^[5]

The second cost lever is batching. Jev reads the state once and evaluates every question against it in parallel. TypeSafe’s cookbook runs 13 questions over a long article both ways and reports that one batched call was 12.2 times cheaper and 10.0 times faster than 13 separate calls, with no change in answers.^[6] The reason is plain: with separate calls the document is paid for again each time.

We cannot tell from the Usage page whether the 54,890 requests were batched. If your own workload asks many questions about one input, batching is the first thing to check.

What about speed?

It is tempting to say Jev made the work faster, and it may well have. But the Usage page does not show latency or time saved, so it cannot support a number. What we have is TypeSafe’s own benchmark for batching, and the method for getting your own.

The fair test is simple: take a fixed sample of real inputs, run it through both setups, record start and end times for each call, and compare the medians and the slowest cases. Compare answers on the same sample at the same time. A fast wrong answer is not a saving.

Where it does not fit

Cheap and fast are only useful if the model is right for the job. TypeSafe’s own documentation lists the weak spots plainly: Jev reads literally, struggles with numeric precision and counting, handles dates poorly as ordered quantities, loses accuracy with indirection and with large amounts of irrelevant state, and does not generate text.^[7]

Each has the same remedy: do the exact or generative part elsewhere. Count and compare in code, filter the state before sending it, and hand writing to a generative model. The docs also note that accuracy depends on staying inside the context limits, 64k tokens per request and 32k per question by default.^[2]

Do the sum yourself

You do not need our figures. You need your own page and six steps.

Claims, checked

Posts about cost savings travel fast and lose their qualifiers on the way. These are the claims you are most likely to see about a page like this, and what the evidence supports.

The message

$1.26 for 54,890 requests is a real number from a real page, and it is cheap on any list price we could read. How much cheaper than the alternative depends on the alternative, from about six times against a small model to hundreds of times against a large one. What the page cannot tell you is whether every answer was good enough, or how much time you saved. Those are yours to measure.

Use the small, calibrated model for the narrow judgments and keep the big model, and your code, for everything else. Then check the meter.

Quick quiz

Tap a question to check your answer.

TypeSafe AI, Anthropic and Mintlify are independent of MSRX; this article is not affiliated with or endorsed by any of them. The usage figures are from the author’s own TypeSafe console. Anthropic makes Claude, which is among the AI assistants used to draft this article. Quotes are word for word from the linked sources. Prices and documentation were checked on 15 October 2026 and may change. The spend figure is the console’s estimate at list price; the comparison figures are our arithmetic from published list prices, not quotes or measurements.