jev-model-router

Every coding session starts with the same guess: which model, and how hard should it think? Flagship models on every task burn money and time; small models on hard tasks burn hours of rework. Jev Model Router makes that call for you.

1. Jev reads the task in ~0.4 s for a fraction of a cent: what kind of work it is, how hard, how much reasoning, whether it needs tools, vision, real-time answers or high volume.

2. Live models are ranked against what the task actually needs: benchmark-based quality, live OpenRouter prices, speed, and the reasoning effort that fits.

3. You get a decision you can act on: the best balance, plus the smartest, fastest and cheapest good-enough alternatives, with the exact command to switch (/model opus + /effort medium, codex -m … -c model_reasoning_effort=…, or an OpenRouter request body).

Example

In Claude Code, asking "which model should I use to find the race condition in our Go worker pool?" gives:

Related MCP server: Models PLUS

🧭 Best balance: Claude Fable 5.1 · effort low

Task: debugging · hard (2.9/4) · reasoning substantial · Jev confidence 100% Signals: multi-step tool use

Pick: anthropic/claude-fable-5.1 (fable) · quality 89/100 (task needs ≈72) · ~$0.123 · ~17s

Use it: Use /model fable with /effort low, or delegate to a subagent with model: "fable".

#	Model	Effort	Quality	Cost/call	Time/call	Speed
🥇	Claude Fable 5.1	low	89	$0.123	17s	medium
🥈	Claude Opus 5	medium	84	$0.096	42s	slow
🥉	Claude Sonnet 5	max	77	$0.277	6m 35s	medium

Your call: 💰 Cheapest good-enough: Claude Opus 5 (medium, $0.096, ~42s)

The same question about a product feature, "tag each incoming support email with one of 12 intents, about 40,000 emails a day", routes across every provider instead: DeepSeek V4 Flash at ~$0.0002 per email, with a tip that its :batch variant costs half as much for offline jobs.

What it saves

On 42 real, labeled developer tasks at live list prices (full analysis, reproducible with node scripts/cost-analysis.ts):

priority: cost goes further (Claude Code −40% vs Opus 5, Codex −71% vs Astra low) while still meeting every task's quality bar. Cheap one-model habits save money too, but miss the bar on 12–29% of tasks. A measured spot check with real billed calls cut cost by 99% on easy and moderate prompts. Routing itself costs about $0.08 per 1,000 decisions. Methodology and caveats →

Install

You need Node.js 20+ and your own API key (this repository contains no keys):

• OpenRouter (recommended): https://openrouter.ai/keys. Jev runs through OpenRouter's Decisions API, billed to your account.

• TypeSafe (Jev's official API): https://console.typesafe.ai/keys.

Without a key the router still works, using offline keyword analysis (less accurate).

Claude Code (CLI, or the Code tab of the Claude desktop app)

/plugin marketplace add Mandrilsquad1441/jev-model-router
/plugin install jev-model-router@jev-model-router

Claude Code asks for your OpenRouter or TypeSafe key and stores it in your system keychain. Change it later with /plugin configure jev-model-router@jev-model-router, or set OPENROUTER_API_KEY in your environment instead. Restart the session to load the plugin.

Claude desktop app (chat)

Download jev-model-router-<version>.mcpb from the latest release and open it, or go to Settings → Extensions → Install extension. Enter your key when asked.

Codex (CLI and app)

codex plugin marketplace add Mandrilsquad1441/jev-model-router

codex plugin add jev-model-router@jev-model-router

Codex passes OPENROUTER_API_KEY (or TYPESAFE_API_KEY) from your environment to the plugin, so set it before starting Codex. If your Codex app does not see shell variables, store the key once with the plugin's setup command. The router_status tool prints the exact command, which prompts for the key without echoing it.

Any other MCP client (Cursor, VS Code, Windsurf, …)

Clone the repository and point your client at the bundled server. No install step is needed; the bundle has no dependencies.

{
  "mcpServers": {
    "jev-router": {
      "command": "node",
      "args": ["/path/to/jev-model-router/plugins/jev-model-router/dist/server.mjs"],
      "env": { "OPENROUTER_API_KEY": "your-key" }
    }
  }
}

Use it

Just ask: "Which model should I use for this?", "Cheapest model that can handle this refactor?", "Compare Opus 5 and GPT-6 Astra for a security review." The plugin's skills tell the agent when to route.

In Codex the same route, compare-models and setup skills are available; ask for them by name or just describe what you need.

From a terminal, the bundled CLI does the same:

node plugins/jev-model-router/dist/cli.mjs recommend "write unit tests for the auth module" --host claude-code

node plugins/jev-model-router/dist/cli.mjs compare opus "gpt 6 astra" "gemini 3.8 flash" --task "review this PR for security bugs"

Priorities: you decide the trade-off

Priorities stated in the task are picked up automatically. You can also pass custom weights (for example { "intelligence": 1, "cost": 3 }) or hard constraints (providers, maximum price, minimum context, vision, tool calling).

Tools (MCP)

Every tool is read-only. Results come as Markdown plus structured JSON.

Configuration

The plugins set the host automatically: Claude Code answers with Claude models and /model aliases, Codex with Codex models and -m flags, and the desktop extension with every model on OpenRouter.

How it works

flowchart LR
  T["Your task"] --> J["Jev analysis · one call, ~0.4 s<br/>type · difficulty · reasoning · tools<br/>vision · latency · volume · priority"]
  C["Live OpenRouter catalog<br/>prices · context · capabilities"] --> R
  I["Model intelligence<br/>benchmark-based quality, coding,<br/>agentic and speed scores"] --> R
  J --> R["Ranking · pure, tested math<br/>hard filters → quality vs. need<br/>→ cost and speed → best effort"]
  R --> O["Pick + alternatives<br/>+ exact switch command"]

Jev asks eleven narrow questions about the task in a single parallel call; code, not the model, turns the calibrated answers into a decision. Each model is scored at every reasoning effort it supports, on quality against what the task needs, estimated cost per call (including cached session context inside coding agents), and estimated latency. The full design, including every constant, is in docs/HOW-IT-WORKS.md.

Always current. Prices and models come from OpenRouter's live catalog (cached for 6 hours, with a bundled snapshot for offline use). Model quality scores come from public benchmarks (Artificial Analysis Intelligence Index, Terminal-Bench Hard) and are refreshed daily from this repository, so new rankings reach you without a plugin update. New releases of known families inherit scores automatically, and unknown models get conservative estimates.

Privacy and security

• What leaves your machine: the task text (up to 6,000 characters) and optional context notes go to Jev through OpenRouter or TypeSafe, under their privacy policies. The model catalog and the model-score file are public downloads that send no data.

• Keys: never logged, never included in results, and shown masked (sk-or-…9de2). Claude Code and Claude Desktop keep them in secure storage. The setup command writes a config file readable only by you.

• No telemetry. The bundled server is not minified, so you can audit exactly what runs.

• Found a problem? See SECURITY.md.

Quality: tested in loops

Mutation testing (deliberately breaking the math, the filters or key masking) makes the suite fail, so these tests have teeth.

Development

npm install
npm run check   # typecheck, tests, build, bundle smoke test, secret scan

Live suites need a key: npm run test:live, npm run eval (Jev analysis accuracy), npm run eval:routing (decision sanity), node scripts/cost-analysis.ts [--measure]. See CONTRIBUTING.md for updating model scores.

Credits

TypeSafe built Jev, the System One decision model this plugin runs on. OpenRouter provides the live model catalog and access to Jev. Quality scores are derived from public results by Artificial Analysis and Terminal-Bench. Not affiliated with any of them.

License

MIT