---
license: mit
pretty_name: "Jev AI benchmark: billing, latency and limits"
language:
- en
tags:
- jev
- typesafe
- benchmark
- llm-pricing
- decision-model
- latency
- tokenization
size_categories:
- n<1K
configs:
- config_name: fanout_savings
  data_files: fanout_savings.csv
- config_name: latency_by_size
  data_files: latency_by_size.csv
- config_name: chars_per_token
  data_files: chars_per_token.csv
- config_name: billing_coefficients
  data_files: billing_coefficients.csv
- config_name: limits
  data_files: limits.csv
- config_name: confidence_stability
  data_files: confidence_stability.csv
- config_name: laya_mlx_m4pro
  data_files: laya_mlx_m4pro.csv
---

# Jev AI benchmark: what 3,455 billed requests cost, token overhead, latency, and Laya on an M4 Pro

Aggregate results of [jev-fanout-bench](https://github.com/blowxian/jev-fanout-bench), an open, reproducible measurement of how Jev (TypeSafe AI's decision model) is billed and how fast it answers. Each table below is a config of this dataset; full code, raw logs and reports are in the GitHub repository (MIT).

*Independent benchmark, not affiliated with or endorsed by TypeSafe AI, which makes Jev.*

Jev is TypeSafe AI's "System One" decision model: instead of generating text, it reads an input once and answers typed questions about it, as a **Choice** (an option plus a probability for every option), a **Score** (a position on a rubric) or a **Noul** (a yes/no probability). The list price is simple: **$0.042 per million input tokens, output free**. What a real request is *billed* is not published, so I measured it.

This post summarises [jev-fanout-bench](https://github.com/blowxian/jev-fanout-bench), with the code and raw logs public. Two API rounds on 23 September 2026 made 3,455 billed requests to `jev-1.13` through OpenRouter's System One endpoint, routed to provider TypeSafe, for $0.192 in total: round 1 made 2,976 requests ($0.156), round 2 479 billed requests plus eight over-limit probes ($0.036). A third round runs the open-weight alternative, Laya, locally on an Apple M4 Pro.

## TL;DR

- **Every request billed ~260 tokens on top of the text and questions**, with zero spread across 2,976 requests. On short inputs that overhead is most of the bill.
- **The text is billed once per call, however many questions you ask.** Batching 8 questions into one call cut input tokens by **77–86%**, and the answers moved no more than when the same request is sent twice.
- **Chinese and Japanese cost ~5× more tokens per character than English** (1.0 vs 4.9 characters per token).
- **The context cut-offs bracket at 32,768 tokens** (text + longest question) and **65,536** (everything); a call with 1,000 questions still worked.
- **Latency: 375 ms at 1K tokens, 734 ms at 32K** on a reused connection; a fresh connection cost ~1.6 s.
- **Confidence is informative:** the least confident third of answers moved **15.6×** more under rewording than the most confident.
- **Laya-MLX answers a short question in 7.8 ms on an M4 Pro**, but self-hosting only beats Jev's bill at very high volume.

## 1. The hidden overhead: ~260 tokens per request

Sending a one-word state with one question billed about 270 input tokens. In round 1, all 2,976 requests carried a fixed **261-token overhead, with zero spread** across question counts and question sets; TypeSafe's own API example (296 input tokens for one sentence and one question) agrees.

That overhead does not count toward the context limits, but it is on every bill. It changes the maths most for small inputs: a 25-token ticket with one yes/no question is about 85% overhead.

## 2. Batching: the text is billed once per call

Jev reads the state once and answers every question against it, so N questions in one call cost the state once instead of N times. Median input-token saving, batched vs one call per question:

| State size | 2 questions | 4 questions | 8 questions |
|---|---:|---:|---:|
| ~25 tokens | 44% | 66% | 77% |
| ~680 tokens | 48% | 72% | 84% |
| ~3,000 tokens | 49% | 74% | 86% |

Billing was exactly linear: `separate − batched = (N − 1) × (state + overhead)`. And batching did not change the answers beyond run-to-run noise: Noul probabilities moved 0.005 on average and Score answers 0.01, exactly as much as sending the identical request twice, and no Choice answer changed its top option. Even 120 unrelated questions in the same call left the target answers unmoved.

## 3. What a question costs, and why language matters

Each question adds about **8 tokens of framing plus ~1 token per English word** of instructions. A Choice option costs ~8 tokens (bare) or ~21 (with a short description); a Score level costs 8.

The state's cost depends heavily on its language. Measured characters per billed token:

| English | Spanish | Russian | Hindi | Arabic | Korean | Japanese | Chinese | JSON |
|---:|---:|---:|---:|---:|---:|---:|---:|---:|
| 4.92 | 4.44 | 1.78 | 1.72 | 1.49 | 1.44 | 1.01 | 1.00 | 2.4 |

**Keep the questions in English** even when the text is not: translating the questions as well as the text cost 9–48% more tokens and moved yes/no answers further from the English baseline in all seven languages we tried. The repository includes these coefficients and their validation: estimated against 365 billed requests, the median error is 1.4%.

## 4. Limits, measured

TypeSafe documents 64K tokens per request and 32K for the state plus the single longest question. By bisection, requests passed at 32,688 and 65,388 content tokens and were refused (HTTP 400) just above, which brackets binary limits of **32,768** and **65,536**. The ~260-token overhead does not count toward either. There was no question-count cap: a single call with **1,000 questions** succeeded. Gateways (OpenRouter, Vercel, Cloudflare, Netlify) list about 32K of context in total.

## 5. Latency by request size

One question, warm connection, median of three:

| State tokens | Billed tokens | Latency |
|---:|---:|---:|
| 1,000 | 1,286 | 375 ms |
| 4,000 | 4,317 | 382 ms |
| 8,000 | 8,354 | 478 ms |
| 16,000 | 16,429 | 571 ms |
| 32,000 | 32,579 | 734 ms |

The same small request on a fresh HTTPS connection took **1,630 ms**, handshake included. For a model this fast, connection setup can be most of the wait: reuse connections. Batching 8 questions was 7.7–8.6× faster than 8 sequential calls.

## 6. Confidence tells you which answers are fragile

We reworded, reordered and translated questions and compared 960 paired answers. Split by Jev's reported confidence, the **least confident third of Choice answers moved 15.6× as much** as the most confident third (Spearman ρ −0.79), and every change of top option happened in that low third. Score answers showed the same pattern (7.5×). Practically: gate on confidence, and route low-confidence answers to a fallback or a human.

What rewording does: reordering Choice options never changed the top option; removing option descriptions or paraphrasing a yes/no question moved probabilities by 2–10 points on average. If you act on a probability threshold, re-check it after rewording.

## 7. The open-weight alternative: Laya on an M4 Pro

[Laya](https://github.com/NandhaKishorM/laya) is an Apache-2.0 typed-decision model whose server exposes `/v1/systemone` with the same request schema used here; [Laya-MLX](https://github.com/mizorewww/laya-mlx) runs it on Apple Silicon. On an M4 Pro (20 GPU cores, 64 GB), FP16, three processes × 200 samples per test:

| P50, end to end | Multilingual 322M | English 421M |
|---|---:|---:|
| One short question | 7.8 ms | 17.5 ms |
| ~420-token text, one question | 23.0 ms | 57.1 ms |
| 50 questions in one call | 183 ms | 519 ms |
| Sustained, questions/s | 107 | 43 |
| Peak memory | 688 MiB | 944 MiB |

Two caveats before switching. Laya re-reads the text for every question, so it does not get Jev's batching discount, and its context is 512 or 1,024 tokens instead of 32–64K. On accuracy, the one independent head-to-head I found ([gazelle93](https://github.com/gazelle93/decision-models-under-pressure), 64–128 candidate answers) had Jev at 60% and Laya at 39% at 128 candidates; I did not measure accuracy myself.

On cost: at 400,000 decisions a day (100K items × 4 questions, 500-token text), Jev bills about **$126 a month**, while one always-on cloud L4 costs about $509. On price alone, one GPU only breaks even at roughly **1.6 million decisions a day**. The trade-off is laid out, with a calculator, in [Jev vs Laya: API cost vs self-hosted Laya](https://jevpricing.com/compare/jev-vs-laya/).

## 8. What Jev costs in practice

For that same support-triage workload, Jev comes to about **$10.50 per million answered questions**, overhead included. The cheapest LLM in the comparison bills ~5× more for the same work, and the most expensive frontier models 100–240× more, though an LLM can do things Jev cannot (write, summarise, answer open questions).

Access, as of 26 September 2026: TypeSafe paused new direct signups on 22 September; existing accounts keep working, and OpenRouter, Vercel AI Gateway, Netlify AI Gateway and Cloudflare Workers AI serve the same model without a TypeSafe account, at about 32K context.

## Limitations

One client, one location, sequential requests, all through OpenRouter (provider TypeSafe), on one day; limits and latency may change as TypeSafe tunes capacity. No accuracy is measured here, and answers were used only to compute differences, never published. The Laya numbers are one Mac. Everything is reproducible from the repository: [code, raw logs and reports](https://github.com/blowxian/jev-fanout-bench).

*Disclosure: I maintain jev-fanout-bench and [jevpricing.com](https://jevpricing.com/jev-ai/), an independent cost calculator for Jev. Neither is affiliated with or endorsed by TypeSafe AI.*