Most AI spend inside a company is not long-form writing. It is many small decisions: route this ticket, flag this post, score this lead, check this reply. On a chat model each of those decisions pays three times — for the prompt, for the JSON answer, and often for reasoning tokens the answer never shows. TypeSafe's Jev bills only the first: $0.042 per million input tokens for jev-1.13.0, with output tokens free1.
This article works through what that means at published list rates, for three common designs. It also marks where the gap is small, because a cost case that only holds against expensive models is not a cost case.
Where a decision's cost comes from
- Input
- Answer (output)
- Reasoning (output)
- USD per 100,000 decisions
- Jev 1.13$5.04
- Gemini 3.8 Flash, no thinking$120.00
- Gemini 3.8 Flash, 500 thinking tokens$307.50
A decision on a chat model has three cost lines. Input is the instructions, the schema and the content. Output is the answer, priced at around five times the input rate for the chat models below. Reasoning is billed as output on models that think before answering, and on a short classification it can be several times the size of the answer itself. Retries for malformed or schema-violating answers add to all three.
Jev has one line. There is no free text to parse, so there is no malformed output to retry, and output is not charged however many questions the request answers12.
The rate cards side by side
| List rates, USD per 1M tokens | Input | Output | Billed output in a decision |
|---|---|---|---|
| Jev 1.13 (TypeSafe) | $0.042 | $0 | None |
| GPT-6 Luna (OpenAI) | $0.10 | $0.50 | JSON answer, plus any reasoning tokens |
| GPT-5.4 nano (OpenAI) | $0.20 | $1.25 | JSON answer, plus any reasoning tokens |
| Gemini 3.8 Flash (Google) | $0.75 | $3.75 | JSON answer, plus any thinking tokens |
| Claude Haiku 4.5 (Anthropic) | $1.00 | $5.00 | JSON answer, plus any thinking tokens |
| Claude Sonnet 5.5 (Anthropic) | $2.00 | $10.00 | JSON answer, plus any thinking tokens |
Jev's input rate of $0.042 per million sits below the smallest chat models in this table: GPT-6 Luna at $0.10 input and $0.50 output, and GPT-5.4 nano at $0.20 and $1.253. Gemini 3.8 Flash is $0.75 and $3.75 at its introductory price through 31 December 2026, doubling to $1.50 and $7.50 from 1 January 20274. Claude Haiku 4.5 is $1 and $5, and Claude Sonnet 5.5 is $2 and $105, which Anthropic's launch note calls introductory pricing6.
Two dates in that table matter to anyone planning on it. OpenAI has deprecated GPT-5.4 nano, which shuts down on 1 April 20277, and Anthropic lists Claude Haiku 4.5 for retirement no sooner than 15 October 20268.
Cost per decision, worked
Illustrative: 1,200 input tokens per ticket; chat models also return 80 output tokens
USD per 100,000 tickets
- Jev 1.13input only$5.04
- GPT-6 Luna$16.00
- GPT-5.4 nano$34.00
- Gemini 3.8 Flash$120.00
- Claude Haiku 4.5$160.00
- Claude Sonnet 5.5$320.00
Read the example in both directions. Against mid-tier and large models the difference is one to two orders of magnitude, and a team that classifies with Sonnet-class models because "it works" has a real reduction available. Against the smallest chat models, especially with prompt caching, the per-call difference is a few dollars per hundred thousand decisions. At that end the case for Jev rests on the other terms: accuracy per dollar, latency, calibrated confidence and the designs below.
Token counts are the weakest input to any comparison like this. Each vendor counts the same text differently, and the TypeSafe API's own examples show a short sentence with one question reporting about 300 input tokens2, so a fixed per-request overhead makes tiny requests relatively expensive. Measure real usage on your own content before relying on any of these numbers.
Many questions, one state
Jev reads the state once and evaluates every question against it in parallel, within 64k tokens per request1. When several decisions concern the same content, asking them together means paying for the content once.
TypeSafe's parallel-questions cookbook measures this on jev-1.12: 13 questions about one long document, asked in one request rather than 13, cost 12.2 times less and returned 10.0 times faster, with no change in the answers9. Another page of the same documentation quotes the result as 11.5 and 9.6 times10; either way the effect is roughly an order of magnitude. Chat models can approach the same effect by returning all answers in one JSON object, but every answer then becomes billed output.
The design consequence is TypeSafe's "speculative fan-out": ask every question code might need, including ones that only matter for some inputs, and let code ignore the answers it does not use10. On an input-billed model, an extra question costs a few dozen tokens of instructions.
The cascade: Jev first, a large model for the rest
The biggest reduction usually comes from not replacing the large model at all, but sending it only the cases that need it. Every item goes to Jev; answers above a confidence threshold are acted on; the rest go to a larger model or a person.
100,000 tickets
Every item goes to Jev
e.g. 60,000
Confident answers act
e.g. 40,000
Uncertain answers escalate
a small remainder
Still uncertain: a person
TypeSafe's SEC-filings cookbook shows why this works. Across 60 annual reports, a confidence cutoff of 0.9 split them in half: the confident half was classified correctly 90% of the time, the other half 40%11. Acting on the confident half and escalating the rest keeps accuracy where it is high and spends the large model where it is needed.
Illustrative: Sonnet 5.5 on every ticket against Jev first, Sonnet 5.5 on 40%
USD per 100,000 tickets
- Sonnet 5.5 on every ticket$320.00
- Jev on all, Sonnet on 40%$5.04 + $128.00$133.04
- Jev on all, Sonnet on 20%$5.04 + $64.00$69.04
Checking LLM calls for a fraction of their cost
Guardrails and output checks run on every call they protect, so their cost is a percentage of the protected traffic. Because Jev bills input only, a check over a prompt and its reply costs a small share of the call that produced them.
The same arithmetic applies to routing. A Jev call that decides whether a prompt needs a large model costs about six cents per thousand prompts of 1,500 tokens; one prompt correctly kept on GPT-6 Luna instead of Sonnet 5.5 pays for about two hundred routing calls.
What the rate card leaves out
Accuracy. A decision that is wrong costs whatever the wrong decision costs: a misrouted ticket, a missed fraud flag, a blocked customer. TypeSafe's own workflow evaluations, which score models against the average of GPT-6 Astra and Claude Fable 5.1 on four workflows its team built, report Jev at 67.8% agreement for $0.0004 and 0.4 seconds per case, beside Claude Sonnet 5 run as a workflow at 67.8% for $0.1174 and 78.1 seconds, and Claude Haiku 4.5 at 53.6% for $0.019512. TypeSafe discloses that the reference favours OpenAI and Anthropic models and that the workflows are its own12. The figures describe TypeSafe's tasks; yours need their own measurement.
Latency. TypeSafe reports end-to-end response times of 70 to 500 milliseconds for Jev, against seconds to minutes for frontier models on comparable decisions, from evaluations run from the US West Coast13. Latency is not on an invoice, but it decides whether a check can run inline on a user request or has to move to a queue.
Limits. Jev 1.13's published rate limits are 80 requests and 100K tokens per second, and TypeSafe warns they may change without notice while it adds capacity1. A workload that needs more needs a conversation with TypeSafe before it needs a budget.
Engineering. Jev works best with atomic questions and arithmetic kept in code. Decomposing a prompt that asks a chat model for "the analysis" into a dozen typed questions is real work, and it is where most of the accuracy comes from.
Measuring cost per correct decision
The number that compares designs is cost per correct decision, the decision-level version of cost per successful task:
- Label a sample of a few hundred past decisions with their real outcomes.
- Run each design — chat model alone, Jev alone, Jev with a cascade — on the same sample, recording tokens and cost per item.
- Count escalations and human reviews as part of the design's cost, at what they really cost.
- Divide total cost by correct decisions, and compare at the accuracy the business needs, not at the highest one available.
Repeat it when a vendor changes a rate or ships a version; Gemini's 1 January price change and Haiku 4.5's retirement are both inside the next quarter.
Tracking Jev spend beside the rest of your AI spend
INFRO implements TypeSafe's endpoint, POST /v1/systemone, with TypeSafe's request body, so Jev decisions run through the same gateway as the chat calls they replace or escalate to. TypeSafe bills the customer's own account; INFRO estimates the charge from the catalog rate and the reported input tokens, and returns it as usage.cost on each response. TypeSafe connections are available in production: Jev through INFRO shows the setup, and the System One reference the request, the response and the errors.
With a connection in place, the same metadata value on the Jev request and on its escalations — {"workflow": "support-triage"} — lets one usage query show what each workflow costs, the Jev calls and their escalations together; group_by=model shows the split between them.
curl "https://api.infro.io/v1/usage?group_by=workflow&from=2026-10-01T00:00:00Z&to=2026-11-01T00:00:00Z" \
-H "Authorization: Bearer $INFRO_API_KEY"Spend limits apply to Jev requests before the call, as they do to every other request, and a negotiated TypeSafe rate entered for the organization replaces the catalog rate in every estimate. Provider cost stays separate from INFRO's own charge: TypeSafe bills for Jev, INFRO bills a subscription for the control plane, and nothing INFRO sells is priced per token.