Jev Model Router

03 / WHO OWNS WHAT

Separate judgment, policy, and execution

A routing decision is input to policy. It is never authorization to execute a tool, access data, spend budget, or make a production change.

05 / HOW THIS DEMO ROUTES

Semantic judgment first, software policy second

The route is not a fourth model answer. Threshold changes re-run local policy over the same result, without another Jev request.

06 / JEV PLAYGROUND'S FOUR LANES

Provider-independent lanes for this example policy

These lanes belong to Jev Playground's demo policy. Real routers may use different candidate sets, tiers, fallback rules, or direct model IDs.

00 / CHOOSE YOUR ROUTER

Which Jev model router should I use?

Choose by where the routing decision needs to live. These setups represent different architectures; they are not a ranking.

npm install -g jev-router
jev-codex   # or jev-claude

02 / RUN A REAL ROUTER

Run Jev in a real model-routing workflow

npm install -g jev-router

echo "JEV_API_KEY=..." > ~/.jev-router.env

jev-codex
# or
jev-claude

git clone https://github.com/its-panzer/jev-model-router
cd jev-model-router
python -m venv .venv
./.venv/bin/pip install -e .
cp .env.example .env

model-router "Describe the task here"

from model_router import Router

with Router(...) as router:
    decision = router.route(prompt)

# Your application now calls its own downstream client
# using the selected model or tier in decision.model_id.

git clone https://github.com/BunsDev/typesafe-router.git
cd typesafe-router
npm ci
npm run dev

04 / ROUTER ARCHITECTURES

Not every Jev router works the same way

07 / POLICY AFTER JEV

Jev characterizes the work; your application owns the route

Policy remains inspectable, testable, and adjustable without spending another model request. It should define explicit behavior for low confidence, unavailable candidates, and router failure.

08 / BUILD IT YOURSELF

Build the decision layer around your own constraints

Our implementation asks for task kind, reasoning depth, and consequence, then runs local policy. A direct router can instead ask Jev Choice over actual candidate IDs. Both patterns keep execution outside Jev.

Use stable allowed IDs, validate the returned ID, and keep provider credentials server-side. The Jev API guide covers the typed request contract and error handling.

import type { Answer } from "./types";

const response = await fetch("/api/evaluate", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    state: ["AI TASK", task, "", "CONTEXT", context].join("\n"),
    questions: {
      task_kind: {
        type: "choice",
        instructions: "Which task category best describes this work?",
        criteria: {
          mechanical: "A tiny deterministic correction.",
          bounded: "Localized work with clear boundaries.",
          cross_cutting: "Work spanning dependent modules or interfaces.",
          security_or_data: "Security, privacy, migration, payment, or production-data work.",
          unclear: "Insufficiently scoped or none of the other categories.",
        },
      },
      reasoning_depth: {
        type: "score",
        instructions: "How much architectural reasoning and verification is needed?",
        criteria: ["Shallow", "Moderate", "Deep"],
      },
      high_consequence: {
        type: "boolean",
        instructions: "Could a materially wrong result create significant or difficult-to-reverse harm?",
      },
    },
  }),
});

const { result } = await response.json();
const route = chooseRoute(result.answers as Record<string, Answer>, 75);

// chooseRoute is deterministic application code.
// It can pause for review; it never asks Jev to execute the task.
return route;

09 / LIMITATIONS & SECURITY

Before putting a router in front of every turn

Some projects publish their own evaluations; inspect their source for the latest methodology and results. This page does not reproduce benchmark, latency, or savings claims.

10 / SOURCES

Primary references for each routing pattern

• TypeSafe API reference: Noul, Choice, and Score ↗
• gargpratyush/jev-router: Codex and Claude Code per-turn routing ↗
• its-panzer/jev-model-router: Python model-tier router ↗
• TypeSafeAI/typesafe-router: generic model and tool routing ↗