Cut yes/no LLM call costs as priced decisions

The trade-off is output tokens versus decision quality

A yes/no LLM call is often billed like generated prose, but it is closer to a priced decision. The trade-off is simple: you pay for input tokens, output tokens, latency, and the cost of the wrong class of error. If 1,000 calls use 100 input tokens each and output is free, the bill is $0.0042 before latency and error handling.

Jev, a decision model API from TypeSafe, takes text in and emits floats for category labels, yes/no answers, ratings, and confidence. That shape matters because a router, spam filter, or relevance scorer needs a number, not a paragraph.

TypeSafe prices Jev at $0.042 per million input tokens, or $42 per billion tokens, and does not charge for output tokens. The input price is below OpenAI's GPT-5 Nano, a small OpenAI model, at $0.05 per million tokens.

The decision contract comes before the benchmark

Name the decision in a single line: approve, reject, route, score. Done looks like a label a non-engineer can read. If the label needs a paragraph, the model is doing more than a decision.

Set the threshold before you look at accuracy. Done looks like a confidence cutoff and a fallback action. For a yes/no endpoint, the threshold is the decision point where a wrong yes costs less than a wrong no, or the reverse.

Log the raw score, not just the label. Done looks like a table with input, score, label, and downstream action. That log is what lets you reprice the error class after launch. Keep the contract in the same repo as the prompt, because the threshold is part of the model.

Five numbers decide the swap

Measure the current call on the numbers that determine cost. The test is five numbers, not a vibes check.

1. Count input tokens. Done looks like a p95 input token count per call and a monthly token total. If your yes/no prompt is a short classification prompt, input tokens dominate the bill.
2. Price output cost. Done looks like output tokens per call and dollars per 1,000 calls. If output is free, this line drops out; if not, it can offset the input savings.
3. Measure p95 latency. Done looks like p95 end-to-end time under load, not median. TypeSafe states Jev responds in 70 to 500 milliseconds end to end; comparable frontier queries run from 3 to 329 seconds.
4. Classify error cost. Done looks like a table of false positives, false negatives, and the dollar value of each. A wrong yes in fraud review costs more than a wrong yes in search ranking.
5. Price outage cost per call. Done looks like the revenue or support cost lost when the endpoint is down briefly. If the decision gates checkout, the outage cost can exceed the token cost by orders of magnitude.

Swap only when the decision is narrow

TypeSafe's workflow evaluations produced 193.6x faster and 444.6x cheaper results, and TypeSafe calls those multiples the upper end of what real deployments should expect. The benchmark reference averaged two frontier models, GPT-6 Astra and Fable 5.1; TypeSafe says that skews results toward OpenAI and Anthropic models. Treat the headline multiples as a ceiling, not a baseline.

The failure mode is routing date extraction, arithmetic, or prompt-injection-heavy traffic to Jev as if it were a general LLM. Jev currently struggles with numbers, dates, and adversarial content. If the decision needs free-form reasoning, keep the LLM. If it needs a calibrated probability for a narrow class, a structured-output endpoint can be the cheaper option.

Run the five-number test on your own traffic. If input tokens, output cost, latency, error class, and outage cost all point the same way, swap. The token price is only the first term in the total cost of the decision. Log the unknown number in the same table as the other four, then rerun the test after enough traffic to make the error class stable.