Last updated: November 16, 2026

Jev Router on OpenRouter, explained

typesafe/jev-router is a model you call like any other on OpenRouter, except it is not a model. It hands each request to TypeSafe's Jev, which picks the model and reasoning effort that should answer, and you pay that model's price. Steer it with one plugin: a cost_tier, a preferred list and a block list.

Searches for "jev openrouter" jumped over the last three months on Google Trends, and most answers mix up the router with Jev itself. This page sticks to what OpenRouter documents, read on November 16, 2026, with a link at each claim. We have not benchmarked the router, and nothing here measures it.

The facts

Model IDtypesafe/jev-router
AnnouncedSeptember 25, 2026, by OpenRouter on X
PriceThe routed model's price. Listed as -1 (dynamic) in GET /api/v1/models
Endpoints/api/v1/chat/completions, /responses, /messages; streaming and non-streaming
Listed limits1,000,000 context, 64,000 max completion tokens (per the models API listing)
InputsText, image, file, audio and video, depending on the model it routes to
Where it runsGlobal data region only; not with EU in-region routing

Sources: the model page, the Jev Router docs, OpenRouter's live GET /api/v1/models listing, and the announcement.

How it picks a model

Per the router docs, Jev looks at the request, judges how hard it is and how much a stronger model would help, and weighs that against the estimated cost and your restrictions. It then picks a model and an effort. In agent sessions it adapts across turns, and an "expert advisor" model can step in when the policy allows.

That is why it sits on Jev. Jev is a decision model: it answers typed questions (pick one of these, score this) instead of writing text. "Which of these models should answer this message?" is exactly that kind of question. More on that split in is Jev an LLM.

Reasoning effort is the router's call too. You can hint with "reasoning": {"effort": "high"} (or the older reasoning_effort on Chat Completions), but a hint is not a guarantee. reasoning.max_tokens and reasoning.mode: "pro" return 400.

The candidate pool is not published and, per OpenRouter, can change over time. If you need a fixed set, use excluded_models to rule out what you must never hit.

A request with the jev-router plugin

Without a plugin, "model": "typesafe/jev-router" uses Jev's default policy. With one, you set the spend tier and the lists. The metadata header asks OpenRouter to explain the choice.

Terminal
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": "Summarize this changelog in one sentence: ..."}],
    "plugins": [{
      "id": "jev-router",
      "cost_tier": "low",
      "models": ["anthropic/*", "~deepseek/deepseek-flash-latest"],
      "excluded_models": ["openai/gpt-6-astra"]
    }]
  }'
FieldTypeWhat it does
id"jev-router"Required. Any other value is a different plugin.
cost_tier"low" | "medium" | "high"How much Jev may spend for quality. Omit it for Jev's default policy. Unknown values return 400.
modelsstring[]Preferred models, with fallback if none can serve. Not a hard allowlist.
allowed_modelsstring[]Alias of models. Entries from both lists are combined.
excluded_modelsstring[]Hard exclusions, enforced even during fallback.

Patterns can be an exact slug, a dated revision, a wildcard such as anthropic/*, or a ~author/family-latest alias. OpenRouter caps each list at 1,024 patterns. A typo in a field name (allowed_model) is a 400, not a silent no-op, which is the behavior you want.

models is a preference, not an allowlist

If none of your models can serve the request, Jev Router falls back to others. Only excluded_models is hard. Auto Router behaves the other way round: its allowed_models is a hard restriction. Code copied between the two can route somewhere you did not expect.

Which model answered, and what it cost

The model field of the response names the model that served it. With X-OpenRouter-Metadata: enabled, the response also carries the router's reasoning:

response shape (from OpenRouter's docs, values elided)
{
  "model": "<the model that served the request>",
  "openrouter_metadata": {
    "pipeline": [{
      "name": "jev-router",
      "resolved_models": [...],
      "candidates": [{ "model": "...", "effort": "...", "tier": "...", "estimated_cost": ... }],
      "reason": "...",
      "advisor_model": null
    }]
  }
}

Bill on the generation, not on estimated_cost: OpenRouter says those figures are not final. If you track spend per feature, log the served model with each call. The router can send two similar prompts to different models with different prices.

Errors to handle: 400 for an unknown cost tier or plugin field, unsupported reasoning settings, regional routing, or combining two router models in one request; 404 when no eligible model is left (often an excluded_models list that is too strict) or you lack access; 503 when the router itself is down.

Jev vs Jev Router vs Auto Router

Three things with similar names on the same site. From OpenRouter's Jev docs, Jev Router docs and Auto Router docs.

JevJev RouterAuto Router
What it returnsA typed decision with a probability. No textA normal model responseA normal model response
Model IDtypesafe/jev-1.14, ~typesafe/jev-latesttypesafe/jev-routeropenrouter/auto
Endpoint/api/alpha/decisions, /api/v1/systemone/chat/completions, /responses, /messages/chat/completions, /responses, /messages
Price$0.042 per 1M input tokens, output free (TypeSafe list price)The routed model's priceThe routed model's price, no extra fee
Include listn/amodels: preferences with fallbackallowed_models: hard restriction
Exclude listn/aexcluded_models: hardexcluded_models: hard
Cost controln/acost_tier low / medium / highcost_tier low / medium / high

Pick Auto Router when you need a hard allowlist or saved account defaults. Pick Jev Router when you want preferences with fallback and turn-by-turn adaptation in agent loops. Call Jev directly when you need a decision, not text: a label, a score, a yes or no.

Using Jev Router in an agent that posts to X

A social posting agent is a good fit for a router. Most of its calls are cheap: rewrite a headline, shorten a post, pick a time. A few are not: a long thread, a reply to an angry customer. With cost_tier: "low", routine calls should land on small models without you choosing per call.

The router accepts tools, so the agent can call the OpenTweet MCP server to publish and schedule on X. Point OpenRouter's @openrouter/mcp client at https://mcp.opentweet.io/mcp with an ot_ key, pass typesafe/jev-router as the model, and the full setup is on post to X from OpenRouter. OpenTweet holds the X login and the schedule, so you need no X developer account.

Keep a human on publish, or use drafts

A router can hand a post to a model you did not test with your voice. Have the agent create drafts and approve them in OpenTweet, or exclude models you have not tried with excluded_models.

7-day free trial with a few limits, or pay now for full limits.

Frequently asked questions

What is Jev Router?

Jev Router (model ID typesafe/jev-router) is a model router on OpenRouter. You send it a normal chat, Responses or Messages request, TypeSafe's Jev decision model picks which model and reasoning effort should answer, and that model writes the reply. OpenRouter announced it on September 25, 2026.

How much does Jev Router cost?

OpenRouter says each request is billed at the price of the model it is routed to, so the router has no price of its own. That is why the models API lists its prompt and completion price as -1. The estimated_cost values in the routing metadata are estimates, not the final bill.

Is Jev Router the same as Jev?

No. Jev (typesafe/jev-1.14, ~typesafe/jev-latest) is a decision model: it answers typed questions with a probability and never writes text, through OpenRouter's Decisions or System One endpoints. Jev Router is a text router that uses Jev internally and returns an ordinary model response from chat/completions.

How do I restrict which models Jev Router can use?

Add a plugin with id "jev-router" to the request. "models" (or its alias "allowed_models") lists preferred models with fallback, so it is not a hard allowlist. "excluded_models" is a hard block that holds even during fallback. Both take exact slugs, dated revisions, wildcards such as anthropic/* and ~author/family-latest aliases. Unknown field names return 400.

How do I see which model Jev Router picked?

The response "model" field names the model that served the request. For the reasoning, send the header X-OpenRouter-Metadata: enabled and read openrouter_metadata.pipeline; the jev-router entry lists the candidates with their effort, tier and estimated_cost, the reason, and any advisor model.

What is the difference between Jev Router and openrouter/auto?

Both pick a model per request and both bill at the chosen model's price. Per OpenRouter's docs, Auto Router rates eleven aspects of the request with a fast decision model and weighs live prices, cache status and benchmarks; its allowed_models list is a hard restriction and it supports account-level defaults. Jev Router uses Jev, treats its models list as preferences with fallback, and adapts across turns in agent sessions.

Does Jev Router support tools and streaming?

OpenRouter says the router works with Chat Completions, Responses and Messages, streaming and non-streaming, and its model page lists tools, tool_choice and parallel_tool_calls among the accepted parameters. That means an agent with tools, such as an MCP server that posts to X, can run on it.

OpenTweet is not affiliated with TypeSafe or OpenRouter. Product details change quickly during beta; check the router docs before you build on any of them.