Is Jev Router Free

Jev Router, OpenRouter's managed typesafe/jev-router endpoint, launched on September 25, 2026. It is a chat endpoint that chooses which model should answer each turn. That is a different product from the original Jev decision model and from the similarly named open-source CLI wrapper.

Is Jev Router Free? The Verified Answer

The verified answer is narrower than the green “free” badge suggests: Jev Router is advertised at $0 for both prompt and completion tokens, but the total cost of the model it selects is not documented clearly enough to call every routed session free.

The live Jev Router page was checked on September 26, 2026. Its FAQ says yes, the router is free, and says prompt and completion tokens are not charged. The page also describes a 1,000,000-token context window and a single endpoint that selects a model and reasoning effort as the conversation changes.

Two catalog details prevent a stronger claim. On the same date, OpenRouter's public Models API returned -1 rather than a normal fixed number for the router's prompt and completion pricing. Its endpoint record returned no provider endpoints. Those machine fields do not prove a charge, but they also do not turn the page's $0 label into an itemized session bill.

This publishing environment did not expose an authorized OpenRouter API key or a signed-in OpenRouter session, so no billable request was made. There is therefore no observed usage.cost or Activity record behind this answer. The defensible budget call is to treat $0 as the advertised endpoint price, then verify the whole call before promising free inference to a customer or finance team.

What Actually Changed on September 25

The change is that Jev moved from being a component you could use to build a router into the decision layer inside a managed chat endpoint.

Jev 1.13 is a System One model, meaning it returns constrained decisions instead of prose. Your application supplies a state and asks a typed Choice, Score, or yes/no Noul question. The model can decide “use the strong tier,” but your code still has to call that tier, preserve the conversation, and account for both requests.

The managed router collapses that into typesafe/jev-router. According to OpenRouter's launch thread, Jev scores the prompt's difficulty and precision before each turn, considers whether a larger model or more reasoning would help, and checks whether the task changed. OpenRouter then sends the turn to the selected model and returns its text.

The open-source gargpratyush/jev-router is especially easy to confuse with the new endpoint. That project launches the real Claude Code or Codex CLI, makes one Jev decision for each fresh turn, maps the result onto account-specific tiers, and forwards the CLI's existing authentication. It is not the managed OpenRouter model slug, and its billing follows a different path.

The distinction changes the build. The original Jev workflow gives you a decision primitive. The DIY router gives you a local policy around coding subscriptions. The managed endpoint gives you one API call whose output is generated by a model it chose.

How Jev Router Handles a Conversation

Jev Router is designed to avoid changing models merely because the next message looks different. That matters because a switch can discard a provider's cached conversation and force the new model to read the full history again.

OpenRouter says the router keeps a model that works for the rest of a session, can raise or lower reasoning effort without switching models, and switches only when the expected improvement is worth the cost of the cache it would lose. It reads the conversation text to make that decision. The launch thread says attachments are not sent to Jev, and requests using zdr: true are supported.

This is more than per-prompt classification. A cheap model can stay in place for an easy follow-up because preserving its cache may be worth more than switching. A difficult turn can receive more reasoning effort without paying the context-reset cost of moving the entire conversation. When the task truly changes, the router can move.

There is also a production wall. If the Jev decision times out or returns invalid output, OpenRouter says the request fails instead of falling back to another router. The separate DIY project is fail-open and keeps a current or fallback model. A builder choosing the managed endpoint is therefore accepting a new dependency in the critical path, not merely adding a price optimizer.

What the $0 Listing Covers, and What It Does Not Prove

The $0 listing covers exactly what OpenRouter publishes: prompt and completion pricing on the Jev Router page. It does not provide an itemized explanation of how a selected paid model, reasoning tokens, cache reads, tools, and credit funding resolve inside that number.

OpenRouter's general billing rules say an ordinary request is charged at the selected model and provider's rate. Its new Jev page says the router is free. Neither source explicitly says whether the managed endpoint temporarily subsidizes the selected model, passes that inference through as a separate line, or uses another launch-specific arrangement. Applying the ordinary Auto Router rule here would be an assumption, just as declaring all paid-model inference free would be an assumption.

The response is the first source of truth. OpenRouter's usage-accounting documentation says every response includes prompt, completion, reasoning, cached-token, and cost information. usage.cost is the total amount charged to the account. The response's model field identifies the model that answered.

The generation record is the second source. OpenRouter Logs exposes model, provider, cost, token counts, latency, cache discounts, BYOK cost, and charges for web search, web fetch, or file processing. The aggregate Activity dashboard then shows spend, requests, token types, and cache hit rate, filterable by model, provider, key, app, or user.

That gives each disputed line a home:

• Selected model: compare the returned model with usage.cost and the generation's total_cost.
• Reasoning: save completion_tokens_details.reasoning_tokens and the routing explanation for the turn.
• Cache reuse: save prompt_tokens_details.cached_tokens, then check the generation detail for any cache discount.
• Tools: exclude them from the baseline test, then read their separate generation lines before enabling them in production.
• Credit fee: allocate the purchase fee separately. OpenRouter's current FAQ lists 5.5% with a $0.80 minimum for card-funded credits and 5% for crypto. That is a funding fee, not evidence of a Jev Router surcharge.

The Numbers: A Free Router Decision Is Not a Free Session

The router-decision line is already tiny. The bigger economic question is whether Jev chooses an appropriate model, preserves useful cache, and produces an accepted result.

Start with the old explicit-decision route. Jev 1.13 costs $0.042 per million input tokens and $0 per million output tokens. Assume 500 input tokens for each routing decision and 100,000 turns. That is 50 million Jev input tokens, or $2.10 for the decision layer. The generative model that answers each turn remains additional.

At the managed page's advertised rate, that same router line is $0. The apparent saving is therefore $2.10 per 100,000 decisions in this workload. That is useful, but it is not enough to choose the product. One poor model switch can matter more than thousands of Jev decisions.

Consider a conversation with 20,000 prior prompt tokens. At an illustrative selected-model input rate of $2 per million tokens, making a new model reread that history costs $0.04 before cache discounts or new output. Fifty-three unnecessary switches cost $2.12, slightly more than the entire Jev 1.13 decision line in the 100,000-turn example.

That is the durable cost case for a session-aware router: preserving the right cache can matter more than making the routing classifier free. The calculation is an explicit scenario, not a claim that Jev Router will choose a $2 model or avoid 53 switches.

The performance evidence is promising and incomplete. OpenRouter reports that Jev Router solved 237 versus 130 of 423 tasks, or 82% more, than its Auto Router across four agent benchmarks. It also reports a faster median time to first token than every other router it tested across five agent benchmarks. Those are vendor results, not an independent reproduction.

Theo Browne offered a useful counterweight in a September 26 benchmark report. He said he spent $1,000, found DeepSWE performance roughly equal to GPT-6 Astra on low effort, paid slightly more, and waited almost five times longer. That is an attributed benchmark result. It is not evidence of a $1,000 router fee, and the post does not expose enough per-request billing data to settle this article's cost question.

For a buyer, cost per accepted task is still the deciding number:

(selected-model cost + tools + allocated funding fee + retries + review time) / accepted tasks

A $0 routing line can improve that numerator. It cannot make the rest of the equation disappear.

What It Means for Builders, Operators, and Buyers

Builders get a simpler integration and a harder dependency. One OpenAI-compatible model slug can replace a hand-built classifier, policy table, model call, and some session logic. In exchange, the router sits before every answer. The documented fail-closed behavior means you need an application-level response for a Jev failure, such as retrying once, asking the user to try again, or deliberately calling a fixed model under your own policy.

The minimum useful log is response ID, requested slug, selected model, routing reason, reasoning effort, prompt tokens, cached tokens, completion tokens, reasoning tokens, usage.cost, latency, and outcome. Without those fields, a model switch looks like random price movement and a quality regression looks like an agent bug.

Operators should manage it by session, not by token sticker. A support copilot, research agent, or coding workflow can contain easy turns, difficult turns, and a task pivot inside one conversation. The valuable behavior is spending more only when the harder turn earns it while keeping the cache when it does not. Measure accepted tasks, retries, human corrections, and session total together.

Buyers should separate inference, routing, and funding on the budget sheet. The endpoint's advertised $0 belongs on the routing line. The selected-model total belongs on the usage line once observed. Search, fetch, file processing, and other tools stay on their own lines. The 5.5% card fee belongs to credit acquisition, not to a fictional per-request markup.

For the broader platform bill, the existing OpenRouter pricing analysis covers shared credits, BYOK, and funding fees. For the original decision-model workflow, How to Use Jev covers typed ticket routing and the $0.042/M Jev 1.13 rate.

Who Should Act Now, Who Should Wait, and Who Is Unaffected

Act now if you have a bounded, reversible agent workflow, can cap the evaluation spend below $1, and already log each generation. A non-critical coding task, internal research loop, or shadow-mode support assistant is a reasonable evaluation surface. The goal is not to prove that routing feels clever. It is to compare accepted-task cost and latency with a fixed model on the same prompts.

Wait if a customer-facing request cannot tolerate an extra fail-closed dependency, if finance needs a signed billing rule before any variable route goes live, or if your prompts contain regulated data that has not passed a privacy review. Zero data retention support is useful, but it does not replace your own data-flow approval.

You are largely unaffected if one fixed model already meets the quality and latency target, if your workload is a narrow typed decision that belongs on Jev 1.13, or if you deliberately route Claude Code and Codex subscriptions through the local DIY project. A managed router is not automatically better than a stable direct call.

If deterministic provider control matters more than adaptive selection, compare the OpenRouter alternatives for multi-model routing before moving the critical path.

What's Overhyped About Jev Router Being Free

The strongest overclaim is that a $0 model card makes the whole model ecosystem free. OpenRouter has not published enough Jev-specific billing detail to support that statement, and the public machine catalog does not expose a conventional fixed route.

The opposite overclaim is that a hidden router surcharge must exist. No surcharge was documented or observed in this run. Adding one to a forecast would be fabrication.

The benchmark story also needs proportion. OpenRouter's 82% task-lift claim is a vendor comparison against its own Auto Router. Theo's $1,000 DeepSWE report is one practitioner's benchmark against one fixed-model setting. Neither result tells you the cost per accepted task for your agent, and neither replaces a short account-level reconciliation.

Finally, a 1,000,000-token context window does not make a million-token conversation economical. The selected model, cache behavior, reasoning effort, and task changes determine whether a long session is efficient. The context limit is capacity, not a budget.

The Four-Request Cost Check to Run on Monday

Four small synthetic requests can establish more than another week of pricing-page interpretation. Keep tools off, use no private data, ask for short outputs, and stop if cumulative usage.cost approaches $1.

The first request can use this exact shape:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-OpenRouter-Metadata: enabled" \
  -d '{
    "model": "typesafe/jev-router",
    "messages": [
      {"role": "user", "content": "Return only the word READY."}
    ]
  }' | tee jev-router-response.json

Then retrieve the matching generation metadata with the response ID:

GENERATION_ID=$(jq -r '.id' jev-router-response.json)
curl --get https://openrouter.ai/api/v1/generation \
  --data-urlencode "id=$GENERATION_ID" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY"

The decision rule is mechanical:

• If all four responses show usage.cost: 0, all four generation records show zero total cost, and the same key's Activity view adds no spend, you have observed a zero-cost synthetic session on that account and date.
• If any record is nonzero, use its selected model and cost breakdown. The endpoint is not free end to end for that request, whatever the catalog badge says.
• If response, generation, and Activity disagree, do not extrapolate. Save the IDs and ask OpenRouter support which record controls billing.

Do not add tools until the baseline reconciles. When search, fetch, or file processing enters the agent, repeat one controlled request and treat those generation lines as separate costs. Do not infer them from the Jev Router model card.

The Monday move is to run those four requests beside four fixed-model controls, then compare session cost, latency, accepted outputs, and failure rate. Adopt Jev Router only if the routing decision improves that full result, not because one catalog row contains two zeros.

Get the next verified model-routing change and its budget consequence in the newsletter.