Jev Routing

A clinical intake router that picks a care pathway from a patient's reported reason for contact and flags whether the message needs a same-day response, without ever assigning a condition or a treatment.

The vLLM Semantic Router project's 29.37B decision model on Qwen3.8-27B: a probability per supplied option with zero generated tokens, 74.0 on JevArena and 56.5 on Jev Decision Index 0.2.1.

Third-party TypeScript check that compares Jev (typesafe-ai/jev) against openai/gpt-4o-mini and anthropic/claude-sonnet-4.5 under identical conditions, routing 60 synthetic booking inquiries in four languages for a photo-shoot service, all through one Vercel AI Gateway key.

Epistemic runtime for autonomous coding agents that uses Jev as a sub-100ms System 1 gate to shadow-evaluate capsule facts, propose evictions before bloat and prefetch memory between turns. Its fixture run reports 31.3% fewer turns and 52.6% fewer blind discovery operations, with a fail-open circuit breaker.

Custom ComfyUI node that routes a prompt to one of three workflow templates using a Jev decision instead of a keyword match. Supports noul, choice (up to 255 options) and score (2-10 levels) questions with parallel evaluation, exponential-backoff retries and full probability distributions as node outputs.

MIT-licensed Python tool router for coding agents that keeps obvious calls on a fast path, asks Jev (default typesafe/jev-1.13 via OpenRouter) for genuinely ambiguous choices, and can run bounded MCTS when multi-step consequences matter. Ships a CLI, MCP server and hook integrations.

High-performance Go event bus with a bounded MPMC ring buffer, fan-out and ordered handlers, plus an optional routing layer that evaluates deterministic rules first, reuses cached decisions, and asks Jev a typed Choice only for ambiguous cache misses.

A Pi coding-agent extension that uses Jev to classify each request and route it to one of three configured models. Supports TypeSafe, Cloudflare AI Gateway, Vercel AI Gateway and OpenRouter backends, with doctor checks, shadow mode and an off-by-default setup.

A Jev-style one-pass skill router for OmO agents: a frozen Qwen2.5-0.5B with a tiny option-attention head scores the whole skill catalog per prompt, and an extension shrinks the system prompt to the top-K skills, failing open.

A CLI, Claude Code plugin and Pi extension that pick a model per task from one Jev call: a Choice over candidates asked in both orders plus a complexity Score that sets a minimum tier, with quota-aware filtering and fallback.

Merged PR in the Kilo Code cloud monorepo that replaces its LLM auto-routing classifier with one OpenRouter /systemone Choice request to typesafe/jev-1.13; the PR reports 0.93-0.94 route accuracy on 72 golden cases at roughly $0.00028 per call, with a 250 ms transport-error retry.

Claude Code plugin and CLI that runs Claude Code on Opus 5.5 and has Jev re-decide the reasoning effort when a prompt arrives and after every tool batch, sending each change as a per-message effort statement inside one unbroken prompt cache.

Halv reports a paired SWE-rebench comparison where its workflow, an Astra coordinator, a Luna investigation stage, and JEV selecting worker models and reasoning effort, recorded $144.67 in model cost versus $337.50 for vanilla Codex across 42 runs, with both arms passing 25 verifier runs.

LangChain maps Kahneman's split onto models: System 1 as the fast automatic decision, System 2 as the slow deliberate one, with Jev in the first role.

A Go-based team workspace with optional Jev AI for agent auto-routing, task auto-fill, auto-assign, and automation condition nodes.

James Cruce replays held-out routing decisions with local Laya against deterministic ordering, not a full Laya-versus-Jev accuracy bake-off.

Discussion of ASTGL's held-out routing replay that chose local Laya over hosted Jev for one Mac Studio deployment.

Claude Code hooks that narrow a roster in YAML, ask Jev which handler owns a prompt, and log the band before anything is blocked.

Vercel's guide for when a typed Jev decision is enough and when a job still needs GPT-6 Astra to write, see images, or call tools.

Riley Brown on a decision model that cannot write: a model router, Choice, Score, and Noul, then speed, cost, and where to get access.

Joe Maddalone on using Jev for routing and filtering before a generative model, with demo code in a transcript-analyzer repo.

Vercel's guide for seven jobs Jev can take: routing forms, prioritizing tickets, reviewing tool calls, picking a model, categorizing documents, moderation, and checking an answer.

TJ Robertson on the jobs that fit a classifier with a confidence score, and the speed and cost he trades against a frontier chat model.

Telusko Alien Coach on why generating text is overhead for a classifier, with Vercel's reported speedup and Armin Ronacher's objection.

OpenRouter times Jev 1.13, GPT Luna, and Claude Opus on 60 support tickets: intent plus an escalation flag, then says the reply still belongs to a generative model.

LangChain contrasts an LLM that writes a paragraph and then a boolean with a Noul probability you can threshold, via langchain-typesafe.

A TypeScript layer beside an LLM: JevSift selects approaches, JevLoop audits progress with typed actions, and JevLong watches sessions for stalls without steering them.

.NET SDK for the System One API with typed question sets, HttpClientFactory and dependency-injection wiring, plus Microsoft.Extensions.AI guardrail, routing, tool, and evaluator adapters.

A community Rust port of the official Python SDK with the same primitives, wire format, retries, and error semantics, plus derive macros for typed questions and answers.

A Home Assistant integration that turns Jev questions about entity state into sensors and automation actions, with an Assist conversation agent and a daily token budget.

Wrappers for Claude Code and OpenAI Codex that ask Jev to choose a model tier for each fresh user turn while preserving each CLI's native interface, tools, sessions, permissions, and authentication. Ships as the jev-claude and jev-codex commands.

Local Codex Router extension that asks Jev for a model tier and thinking depth on each model call, including continuations after tools, then relays the native Responses request verbatim. Fails open on Jev errors and logs decisions locally.

Experimental Hono router that matches an incoming HTTP request to a plain-language route description: one yes/no Jev question per description is evaluated in a single call, and the first registered route above the threshold wins.

Unofficial LlamaIndex reranker and router built on the official Python SDK: JevRerank scores retrieved passages and JevSingleSelector chooses which tool handles a query.

An OpenTelemetry exporter wrapper that scores each log record with Jev for diagnostic value, priority, and routing, letting low-value events skip an LLM-analysis branch while every record stays in your archive.

A CLI that turns Jev into Unix pipeline primitives: is, choose, score, filter, and guard commands return typed verdicts, stable exit codes, and versioned JSON without prompt or parsing glue.

A Pi plugin that has Jev pick one model and one reasoning-effort level from a configured list at the start of a session, then keeps both pinned for the rest of it.

An OpenAI-compatible LiteLLM proxy where clients send one model id and Jev picks which configured model serves each request, with capability filtering and a cheapest-eligible fallback.

An experimental local proxy for coding agents that sends jevonian/auto turns to Jev to pick a model and thinking level after deterministic compatibility and quota filters, while explicit routes skip Jev.

A router that turns models, subagents, skills, MCP tools, CLIs, and plugins into one candidate set Jev answers with a single typed Choice, while the router code owns availability, permissions, and confirmation.

A reference router and skill that put Jev in front of Grok Bot so each request is classified before expensive research, browser, retry, or subagent work, returning actions such as reuse_cache or ask_human.

An optional routing layer for Hermes Agent, shipped as a Python CLI and library, that sends a request and a public skill catalogue to Jev and returns route, no_skill, or review plus confidence and candidate distributions.

A local proxy between Claude Code and the Anthropic API that picks the model and effort level per message with Jev, routing subagents whenever cheap but gating main-chat switches on prompt-cache arithmetic.

An independent calibration study of Jev against a frontier fallback on Banking77 and Web of Science, packaged as the janus-decide tool that measures a routing threshold on your own data instead of shipping a default one.

A Python toolkit that installs nine plain SKILL.md files for Hermes, Claude Code, and Codex, letting Jev route models, filter retrieved passages, select skills, and choose bounded computer or browser actions.

A Rust coding-agent harness and TUI that uses Jev to pick a model and effort, route bounded utility work, and decide what context to keep, with code constraining every choice and validating results.

Open multilingual System 1 decision models with published checkpoints for choice, score and noul questions, plus a router that dispatches each request to the right checkpoint in one forward pass.

A Juspay TypeScript SDK that treats Jev as a third inference type beside generate and stream: providers declare which kinds they serve, and tryDecide returns typed boolean, choice, or score answers, null when no decision provider is set.

A local-first Herdr CLI that filters your agent subscriptions with fixed eligibility rules, then asks TypeSafe Jev to rank the remaining Cursor, Claude Code, Codex, or OpenCode options and pick a reasoning effort.

A Pi coding-agent extension that routes tools and skills with Jev: one pass activates only what a prompt needs, with opt-in model selection, tool-call guards, and compaction.

An experimental Codex CLI router where a local Responses proxy asks Jev one Choice per model call to select a host-available model and reasoning effort, while application-owned acceptance decides whether the task passed.

Use the answer to decide what to do and confidence to decide whether to act: the voice-banking example routes below 0.6 to a human and needs 0.85 or more to auto-approve a transfer.

Ask everything the system might need in one request, then let code throw away what it does not use. The ticket-triage example sends a category plus four speculative questions in parallel.

Classify intent with a Choice and complexity with a Score, then send each branch to deterministic code, a specialist model, or a person, with a 0.5 intent-confidence floor.

A Python walkthrough of typesafe-sdk: sync and async clients, grouping answers into choices, scores, and nouls, and routing uncertain cases to review, with arithmetic kept in Python.

A practical guide through SDK setup, the three primitives, and five patterns including speculative fan-out, confidence-gated routing, composite scoring, and a retrieval-then-judge cascade.

A map of documented Jev use cases, routing, guardrail verification, citation checking, reranking, rubric scoring, bulk classification, and semantic linting in CI, each with a confidence policy.

An engineering note that places Jev as a typed micro-decision layer inside an agent harness rather than a planner, with preconditions for confidence gates and fan-out and a runtime split into five parts.

LangChain's langchain-typesafe integration exposes Jev as a TypeSafeClassifier plus experimental model-routing and auto-mode middleware that screens risky tool calls before execution.

A short demo of a model router built with Jev: each request is classified by Jev and forwarded to the model judged most suitable, shown as a screen recording.

End-to-end guide to a ticket-routing workflow with confidence thresholds, zero-data-retention options, and mock-based tests that need no network call.

How TypeSafe reports certainty, how it differs from probability, and how to use it architecturally to gate and route decisions.