# How Jev cuts the cost of AI decisions: the arithmetic

URL: https://infro.io/blog/jev-cost-per-decision
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-06
Last modified: 2026-10-06
Last reviewed: 2026-10-06 (next review due 2026-11-05)
Topic: Cost and FinOps
Format: Analysis

> Jev 1.13 is billed at $0.042 per million input tokens with output free, so a decision costs only what you send. At list rates, 100,000 ticket triages of 1,200 input tokens come to about $5 on Jev against $120 on Gemini 3.8 Flash and $320 on Claude Sonnet 5.5; the gap against the smallest chat models is a few dollars. The larger reductions come from asking many questions per request, sending only uncertain cases to a large model, and checking LLM calls for a small fraction of their cost — all of which need cost per correct decision, measured on your own data, to confirm.

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 free[1].

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

[Diagram: Illustrative, per 100,000 decisions at list rates: 1,200 input tokens each; the chat model returns an 80-token answer, plus 500 thinking tokens in the third row.]

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 answers[1][2].

## The rate cards side by side

[Diagram: List rates per million tokens from TypeSafe, OpenAI, Google and Anthropic, read 2026-10-06; they match the INFRO model catalog.]

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.25[3]. 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 2027[4]. Claude Haiku 4.5 is $1 and $5, and Claude Sonnet 5.5 is $2 and $10[5], which Anthropic's launch note calls introductory pricing[6].

Two dates in that table matter to anyone planning on it. OpenAI has deprecated GPT-5.4 nano, which shuts down on 1 April 2027[7], and Anthropic lists Claude Haiku 4.5 for retirement no sooner than 15 October 2026[8].

## Cost per decision, worked

[Diagram: Illustrative, at list rates: 100,000 ticket triages of 1,200 input tokens each. Chat models also return 80 output tokens and use no reasoning. Real token counts differ by tokenizer.]

> **Example: 100,000 ticket triages a month**
> Illustrative arithmetic on list rates. Each ticket is 1,200 input tokens including instructions; a chat model answers in 80 tokens of JSON with no reasoning.
> 
> Jev 1.13: 1,200 × $0.042 / 1M = $0.0000504 a ticket, $5.04 a month.
> 
> GPT-6 Luna: 1,200 × $0.10 + 80 × $0.50, per 1M = $0.00016 a ticket, $16.00 a month.
> 
> Gemini 3.8 Flash: 1,200 × $0.75 + 80 × $3.75, per 1M = $0.0012 a ticket, $120.00 a month. With 500 thinking tokens added, $307.50.
> 
> Claude Sonnet 5.5: 1,200 × $2 + 80 × $10, per 1M = $0.0032 a ticket, $320.00 a month.
> 
> With GPT-6 Luna's cached input rate of $0.01 per million applied to 800 tokens of stable instructions, its month falls to about $8.80.

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 tokens[2], 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 request[1]. 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 answers[9]. Another page of the same documentation quotes the result as 11.5 and 9.6 times[10]; 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 use[10]. 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.

[Diagram: A confidence cascade. The split between the second and third steps comes from your own threshold and data; the figures shown are an example.]

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.

[Diagram: Illustrative, at list rates, per 100,000 tickets: Claude Sonnet 5.5 on every ticket against Jev on every ticket plus Sonnet 5.5 on the escalated share.]

> **Example: A cascade against a single large model**
> Illustrative arithmetic on list rates, using the per-ticket costs above. Sonnet 5.5 on all 100,000 tickets: $320.00. Jev on all of them ($5.04), with 40% escalated to Sonnet 5.5 (40,000 × $0.0032 = $128.00): $133.04. At 20% escalated: $69.04. The escalation rate comes from your threshold and your data, and the escalated tickets are, by design, the hard ones, so check the large model's accuracy on that subset rather than overall.

## 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.

> **Example: A guardrail on a Sonnet 5.5 call**
> Illustrative arithmetic on list rates. A call with 3,000 input and 800 output tokens on Claude Sonnet 5.5 costs 3,000 × $2 + 800 × $10, per 1M = $0.014. A Jev check that reads the prompt and the reply, with its questions, at about 4,100 input tokens costs 4,100 × $0.042 / 1M = $0.00017, about 1.2% of the call.

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.0195[12]. TypeSafe discloses that the reference favours OpenAI and Anthropic models and that the workflows are its own[12]. 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 Coast[13]. 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 capacity[1]. 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](https://infro.io/blog/cost-per-successful-task):

1. **Label a sample** of a few hundred past decisions with their real outcomes.
2. **Run each design** — chat model alone, Jev alone, Jev with a cascade — on the same sample, recording tokens and cost per item.
3. **Count escalations and human reviews** as part of the design's cost, at what they really cost.
4. **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](https://infro.io/providers/typesafe) shows the setup, and the [System One reference](https://infro.io/docs/api/systemone) 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.

```bash
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.

## Sources

1. Models — TypeSafe. https://docs.typesafe.ai/models (accessed 2026-10-06)
2. API reference — TypeSafe. https://docs.typesafe.ai/api (accessed 2026-10-06)
3. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-10-06)
4. Gemini Developer API pricing — Google. https://ai.google.dev/gemini-api/docs/pricing (accessed 2026-10-06)
5. Pricing — Anthropic. https://platform.claude.com/docs/en/about-claude/pricing (accessed 2026-10-06)
6. API release notes — Anthropic. https://platform.claude.com/docs/en/release-notes/api (accessed 2026-10-06)
7. Deprecations — OpenAI. https://developers.openai.com/api/docs/deprecations (accessed 2026-10-06)
8. Model deprecations — Anthropic. https://platform.claude.com/docs/en/about-claude/model-deprecations (accessed 2026-10-06)
9. Parallel questions — TypeSafe. https://docs.typesafe.ai/cookbooks/parallel_questions (accessed 2026-10-06)
10. Primitives — TypeSafe. https://docs.typesafe.ai/primitives (accessed 2026-10-06)
11. Classification using confidence — TypeSafe. https://docs.typesafe.ai/cookbooks/classification_using_confidence (accessed 2026-10-06)
12. Workflow evals — TypeSafe. https://evals.typesafe.ai/ (accessed 2026-10-06)
13. Introducing System One Models & Jev — TypeSafe. https://typesafe.ai/blog/introducing-system-one-models-and-jev (accessed 2026-10-06)

## Revision history

- 2026-10-06: TypeSafe connections opened in production: linked the setup page and the System One reference.