JEV FOR MODEL ROUTING

Jev Model Router

Not every AI task needs the same model. Give Jev the task, let it judge the work involved, then let application policy choose an execution tier.

Route a task How to use Jev

REAL JEV DECISIONSSimulated model router

AI task
Jev signals
Application policy
Execution lane

01 / LIVE ROUTER

Route one task from three real signals

One request asks Jev for Task Kind, Reasoning Depth, and High Consequence. The selected execution lane comes from deterministic demo policy in this application, after Jev responds.

Real Jev decisions · Simulated model router · No execution model is called

Task presetsLoading or switching a preset never calls Jev.

ROUTEApplication-owned policy

Waiting for evaluation

Run the selected preset as-is or edit the Task and Context first.

02 / HOW ROUTING WORKS

Semantic judgment first, software policy second

01Task

Plain-language work and optional context.

02Jev signals

Choice, Score, and Boolean in one request.

03Policy

Thresholds and routing rules owned by the app.

04Route

A tier for another system to consume.

03 / THE FOUR ROUTES

Stable lanes, independent of model vendors

Fast

For mechanical, low-risk tasks.

Balanced

For bounded work requiring normal reasoning and verification.

Strong Reasoning

For cross-cutting or deep tasks requiring broader reasoning.

Human Review

For high-consequence or insufficiently safe automatic routing.

YOUR APPLICATION MIGHT MAP

Fast: small / low-latency model
Balanced: general model
Strong Reasoning: high-reasoning model
Human Review: pause and ask a person

04 / WHY POLICY COMES AFTER JEV

Jev characterizes the work; your application owns the route

JEV

Typed semantic signals

Classifies the task, scores reasoning depth, and estimates high-consequence probability.

APPLICATION

Deterministic routing policy

Applies thresholds, handles missing distributions, selects a lane, and can stop for review.

The route is not a fourth model answer. That separation makes policy inspectable, testable, and adjustable without spending another model request.

In a larger AI system, a cheap typed judgment can keep every task from defaulting to the same expensive execution path. The application still decides which tradeoffs, permissions, and safeguards each lane requires.

05 / REAL-WORLD PATTERN

Model cascades use decisions before execution

Public Jev coding-agent guidance describes a model cascade: Jev judges task difficulty and risk, then harness code chooses a small model, a stronger reasoning path, or a person. The independent community project gargpratyush/jev-router also routes fresh coding turns through abstract execution tiers.

These projects demonstrate an architecture, not results for this site. Jev Playground does not reproduce their code, publish their performance figures, or imply TypeSafe endorsement.

06 / IMPLEMENTATION

One state, three questions, one local policy

This compact example uses the same validated public endpoint as the live console. Provider setup and failure handling remain server-side; see the Jev API guide for integration details.

Task routerTypeScript

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;

07 / LIMITATIONS

A route is a decision input, not task execution

Jev does not

Execute the task
Call GPT, Claude, Codex, or another execution model
Write code or deploy production
Decide permissions
Guarantee the route is correct

This demo does not

Connect to a repository
Send tasks to external coding agents
Trigger execution-model charges
Compare model speed, quality, or price
Turn a route into authorization

08 / SOURCES & NEXT STEPS