Jev and OpenRouter

OpenRouter is a gateway that forwards your prompt to whichever LLM you name. Jev is a different layer: a typed decision model that picks one option and returns it with calibrated confidence. They solve different problems — and Jev is a great way to decide which OpenRouter model to call.

If you came here asking whether Jev is 'on OpenRouter', the useful answer is that Jev isn't just another chat model to proxy — it's TypeSafe AI's System One decision model with its own hosted endpoint. It doesn't generate text token by token; it emits a typed answer in a single parallel pass: one of your options, a probability for each, and a confidence value, in roughly 70–500ms.

Jev vs OpenRouter

	OpenRouter	Jev
What it is	LLM gateway / router	Typed decision model
Output	Whatever the chosen LLM returns	One typed option + confidence
Use it for	Sending prompts to many models	Deciding, classifying, judging
Latency	The model's latency	~70–500ms
Hallucination	The model's	0% structured-output error

Use Jev to route across OpenRouter

Jev picks the model in one cheap, calibrated call; OpenRouter forwards the actual prompt to whichever model Jev chose.

The two compose. Put Jev in front of your OpenRouter call as the router's brain: define your candidate models as options, send the request as state, and Jev returns the one to use plus a confidence score. Fast, calibrated model selection — then OpenRouter forwards the actual prompt to the model Jev picked.

Define OpenRouter models as the choice options
Jev returns one model + calibrated confidence in ~70–500ms
Route cheap traffic to small models, escalate only when it matters
Pin a Jev model version so your routing thresholds stay stable

Route in code

// 1) Jev picks the model — one cheap, calibrated call
const jev = await fetch("https://jevtypesafeai.com/api/v1/decide", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
  },
  body: JSON.stringify({
    state: { request: userPrompt },
    questions: {
      model: {
        type: "choice",
        instructions: "Pick the cheapest model that can handle this request.",
        criteria: {
          "openai/gpt-5.6-mini": "cheap, simple tasks",
          "anthropic/claude-haiku-4.5": "fast, mid-difficulty",
          "openai/gpt-5.6": "hard reasoning",
        },
      },
    },
  }),
}).then((r) => r.json());

// 2) OpenRouter runs the prompt on whatever Jev chose
const answer = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.OPENROUTER_KEY}`,
  },
  body: JSON.stringify({
    model: jev.answers.model.choice,            // ← Jev's typed pick
    messages: [{ role: "user", content: userPrompt }],
  }),
}).then((r) => r.json());

jev.answers.model.choice is locked to the model list you sent, so it's always a valid OpenRouter model id — no parsing, no fallback for a name the model made up. Threshold on jev.answers.model.confidence if you want to default to a safe model when Jev isn't sure. The Model Router tool shows this pattern running live.

FAQ

Is Jev available on OpenRouter?

Jev isn't a chat model you proxy through an LLM gateway — it's a typed decision model with its own endpoint, so you call it directly. What you can do is use Jev to decide which OpenRouter model a given request should go to.

Should I pick Jev or OpenRouter?

It's not either/or. OpenRouter forwards prompts to LLMs; Jev makes typed decisions. Many teams use Jev as the fast, cheap router that chooses which OpenRouter model to call.

How does Jev choose a model?

Define your candidate models as the options of a choice question, send the incoming request as state, and Jev returns the best-fit model with a calibrated confidence you can threshold on.

Route smarter with Jev

Grab a jv_live_ key and pick the right model in one typed, calibrated call.

▶ Try Jev free Get an API key →