# Jev model routing: what 450 real calls revealed

_By Apoorv Khanna, September 19, 2026_

**Jev routing cut provider-reported usage cost by 33.2% in our 50-prompt test**, from **$0.250420 to $0.167287**. Frozen deterministic checks passed **80% versus 76%**, with p95 latency **61% slower**. Vaaya’s Jev price is **provider usage + 3%**; a separate live verification accrued **$0.000032**. The full benchmark has not been rerun at this rate.

We wanted to test a specific idea: let Jev assess the task, let code decide which answer model qualifies, and keep a receipt for every call. We compared that workflow with sending every task directly to a frontier model. Here is what happened, with the prompts, outputs and charges available to inspect.

![Jev classifies the prompt, deterministic code selects the answer-model lane, and Vaaya logs each call under the same run ID.](/blog/assets/jev-model-routing/architecture.svg)

*[Explore the actual prompts, decisions, answers and receipts](/blog/assets/jev-model-routing/explore.html). The walkthrough follows the saved benchmark calls and shows the separate live pricing verification.*

## How does Jev route an AI task?

**Jev returns a structured recommendation; ordinary code chooses the answer model.** Our single Jev request asked five questions: which lane fits, how complex the task is, whether a mistake could be high-stakes, whether tools are needed, and whether verification is needed.

| Lane | Answer model | Eligibility in this test |
| --- | --- | --- |
| Fast | Gemini 2.5 Flash Lite | Direct extraction and simple rewriting |
| Balanced | GPT-4.1 Mini | Minimum for multi-step tasks, tool plans or verification flags |
| Frontier | Claude Opus 4.6 | Minimum for deep tasks; destination for escalation |

After applying those minimums, high stakes **or** confidence below 0.8 raised the lane once, capped at frontier. Both flags together still meant one promotion. Invalid router output went to frontier.

```typescript
let tier = laneIndex[decision.route];
if (decision.complexity === "deep") tier = 2;
else if (decision.complexity === "multi-step" ||
         decision.needs_tools || decision.needs_verification) {
  tier = Math.max(tier, 1);
}
if (decision.high_stakes || confidence < 0.8) {
  tier = Math.min(2, tier + 1);
}
```

This is a simplified excerpt. The [published runner](/blog/assets/jev-model-routing/benchmark.mjs) contains the full validation and the actual Vaaya `openrouter/decisions` request. It uses OpenRouter’s **`POST /api/alpha/decisions`**, rather than chat completions, through Vaaya’s provider connection. The client never receives an OpenRouter key. See the [official Decisions API example](https://openrouter.ai/docs/client-sdks/typescript/sdks/decisions/README.md).

A tool or verification flag only affected model selection. **This test executed no external tools, purchases or money movements.** Spending limits and action permissions remain separate controls.

### Where does Jev come from?

TypeSafe describes Jev as a System One model trained with **reinforcement learning for calibrated decisions (RLCD)**. Its three question types are `choice`, `score`, and `noul`—a probability that a statement is true. Questions within one request are evaluated in parallel. [TypeSafe’s launch post](https://typesafe.ai/blog/introducing-system-one-models-and-jev) explains the training approach; [LangChain’s introduction](https://www.langchain.com/blog/building-a-harness-with-jev) shows the `TypeSafeClassifier` interface.

LangChain reports **TypeSafe’s claims of up to 200× faster inference and 400× lower cost on classification tasks**. Our router-plus-answer test did not verify those multipliers. We used Vaaya’s OpenRouter integration, and the answer call waited for Jev to finish.

## What did we test?

We froze **50 synthetic prompts** across five buckets: lookup, rewriting, tool planning, multi-step reasoning and high-stakes policy exercises. Each ran **three times per arm**. Control always used Claude Opus 4.6. Treatment used Jev, the policy above, and the selected answer model.

That produced **150 control calls, 150 Jev calls and 150 routed answer calls**. No additional fallback calls executed. Before running, we declared success as a lower total Vaaya bill with no more than a five-percentage-point loss on the frozen checks.

The [saved run manifest](/blog/assets/jev-model-routing/run/manifest.json) records the start time and hashes of the [prompts and checks](/blog/assets/jev-model-routing/prompts.json), [protocol](/blog/assets/jev-model-routing/protocol.json), and [runner](/blog/assets/jev-model-routing/benchmark.mjs). Those hashes match the downloadable files. This is our published execution record, not an independently timestamped public preregistration.

:::details Methodology: controls, grading and escalation

Both arms received the same task text, a 512-token output limit and temperature zero. We used seeded prompt order, randomized arm order within each pair and four concurrent paired-prompt workers. End-to-end latency includes routing and answer calls; local queue wait and grading are excluded.

All required checks had to pass. Forty prompts used exact-field checks; ten rewrites used required strings, forbidden strings and word limits. These checks do not cover every aspect of correctness or prose quality. Three repeats reuse 50 tasks; they are not 150 independent tasks.

The policy takes the lower route/complexity confidence, falling back to selected-choice probability if confidence is missing. Missing confidence is treated as low; yes/no fields use a 0.5 threshold. A failed provider call, truncated response or unusable JSON could trigger one higher-lane fallback, except at frontier. Grader feedback could not trigger another call.

Four access preflights cost 3¢ total and are excluded from both arms. [Their receipts](/blog/assets/jev-model-routing/preflights.json) are separate. [Reproduction instructions](/blog/assets/jev-model-routing/README.md) include the original accounting and runtime limits.

:::

## What were the measured results?

![Provider usage fell 33.2%; p95 latency was 61% slower; frozen checks passed 76% versus 80%. Current Jev pricing is provider usage plus 3%: a live verification accrued $0.000032, and the 150 saved router calls calculate to $0.005151.](/blog/assets/jev-model-routing/results.png)

*Three panels show the measured benchmark. The pricing panel shows the agreed Jev rate, a separate live billing verification, and a calculation from saved router usage.*

| Metric | Frontier control | Jev treatment |
| --- | --- | --- |
| Total provider-reported usage cost | $0.250420 | $0.167287 |
| Frozen deterministic-check pass rate | 76% (114/150) | 80% (120/150) |
| End-to-end p95 latency | 12.47 seconds | 20.07 seconds |
| Provider usage cost per passing answer | $0.002197 | $0.001394 |

Treatment provider usage includes all 150 Jev calls as well as the selected answer models. It measures the provider-reported cost of the work. Current Jev pricing is shown separately below; these results do not establish a lower customer bill at that rate.

**The routed workflow was 61% slower at p95.** It first waited for Jev, then requested an answer. The measurement includes both calls and gateway overhead; this test did not isolate each component’s contribution.

The policy promoted 104 of 150 recommendations, leaving **29 fast, 23 balanced and 98 frontier** answer calls. That is the effect of our declared thresholds, not a guarantee of model suitability. [Download the recorded summary](/blog/assets/jev-model-routing/summary.json) for every repeat and bucket.

## What does Jev cost through Vaaya?

**Jev costs provider usage + 3%, with no per-call cent minimum.** A separate [live billing verification](/blog/assets/jev-model-routing/pricing-verification.json) returned $0.000030828 in provider usage and **$0.000032 in metered Vaaya usage**. Applying the agreed rate to all **150 saved Jev calls** gives **$0.005151 total**, averaging **$0.00003434 per call**; this is a calculation from saved usage, not a newly charged transaction. Provider cost and marked-up price round up to whole micro-dollars, then accumulate for settlement.

[Download the Jev pricing calculation](/blog/assets/jev-model-routing/jev-pricing.json), including each saved call’s provider usage and calculated price.

:::details Pricing method and historical receipts

For each Jev call, `price_usd = ceil(ceil(provider_usage_usd × 1,000,000) × 1.03) / 1,000,000`. The live verification is separate from the 450-call benchmark and is excluded from its cost, latency and quality totals. The [calculation script](/blog/assets/jev-model-routing/price-jev.mjs) reproduces the router-only total; it does not combine current Jev prices with historical answer-call settlements.

The original run recorded **$1.64 for treatment versus $0.18 for control**, including $1.50 under the former flat Jev charge. Some answer calls returned zero-cent charges through MPP. The original lower-customer-bill acceptance rule failed. Those historical receipts remain unchanged; they do not describe the agreed current Jev price.

:::

## What failed?

**The four-point pass-rate difference was partly a formatting difference.** Control had 33 responses that could not be parsed as the requested JSON object; treatment had 16. The multi-step bucket passed 0/30 versus 9/30. Some control answers contained correct arithmetic with extra prose, which failed the frozen parser. We kept those scores; they do not establish a general reasoning advantage.

**Valid JSON could still contain a wrong answer.** For `multi-step-09`, GPT-4.1 Mini returned $7.80 for a plan that cost $6.80. Because the response was parseable, the policy did not request another answer. [Inspect the actual comparison](/blog/assets/jev-model-routing/explore.html?prompt=multi-step-09&repeat=1), including both model outputs and the failed checks.

## What did Vaaya make visible?

Every request carried the same run ID: `jev-20260919-50x3-v1`. The log connects each prompt to Jev’s recommendation, the policy’s choice, the model output and the recorded charge. A receipt verifies a call and charge; the separate grader checks the answer.

![Actual Vaaya Transactions dashboard showing a successful Jev verification call with $0.000032 in metered usage at provider cost plus 3%.](/blog/assets/jev-model-routing/pricing-dashboard.png)

*Actual dashboard capture of the separate pricing verification, with the account sidebar excluded. The [metered-price filter](https://vaaya.ai/transactions?agent=jev-meter-preflight-20260919) shows the $0.000032 usage entry. It is one billing check, not a new benchmark run.*

:::details Original benchmark dashboard and receipt trail

[View the original benchmark dashboard capture](/blog/assets/jev-model-routing/dashboard.png). It preserves the charges recorded under the pricing in effect during that run.

The authenticated [benchmark run filter](https://vaaya.ai/transactions?agent=jev-20260919-50x3-v1) shows its latest 100 matching rows. The downloadable log contains all 450 calls. These are the original historical amounts, not the current Jev price.

:::

Download the [receipt CSV](/blog/assets/jev-model-routing/receipts.csv), [raw model responses](/blog/assets/jev-model-routing/run/calls.jsonl), [answers and checks](/blog/assets/jev-model-routing/run/answers.jsonl), and [all failures](/blog/assets/jev-model-routing/failures.json). We also [matched the latest 200 receipts](/blog/assets/jev-model-routing/ledger-check.json) against the authenticated transactions API. These are inspectable transaction records, not cryptographically signed attestations.

## Questions

**Does Jev replace an LLM?**

Jev doesn't replace an LLM, it makes the fast typed decisions around it. In this test, Jev classified each task, code selected an answer model, and that model generated the response.

**Can I use Jev through OpenRouter?**

Yes. Jev uses OpenRouter's alpha Decisions API with model typesafe/jev-1.13, rather than chat completions. This test called it through Vaaya's openrouter/decisions action.

**How much does Jev cost through Vaaya?**

Vaaya charges OpenRouter's reported usage cost plus 3%, rounded to whole micro-dollars and aggregated for settlement, with no per-call cent minimum. A live verification accrued $0.000032. Applying that rate to the 150 saved Jev calls gives $0.005151 total, or $0.00003434 per call on average; that total is calculated, not a new transaction.

**How was answer quality measured?**

We froze deterministic checks before running 50 synthetic prompts three times per arm. Control passed 114 of 150 responses; treatment passed 120. Required fields and JSON formatting counted. These scores do not measure general model quality.

**Did this benchmark demonstrate a lower customer bill?**

No. The historical run used the former Jev charge and recorded $1.64 for treatment versus $0.18 for control, failing its lower-bill rule. Current Jev pricing is provider usage + 3%; a full benchmark has not been rerun at this rate.

**Who controls model escalation?**

Code does. High stakes or confidence below 0.8 raises the eligible lane one tier, capped at frontier. A failed call or unusable JSON can trigger one higher-lane fallback; a wrong but parseable answer cannot.