A router decides which model, tool, skill or sub-agent should handle a request before any work starts. Most routers are an LLM call that reads the request and replies with a name. A decision model does the same job and returns a typed choice with a confidence value, so the caller can send a clear case straight through and flag a weak one. The examples in this hub run on Jev and other decision models, and Laya appears in some. Some route between models, such as 0xNatoshi/jev-codex-router, which picks a model tier and thinking depth per call in Codex. Others route to tools or skills, such as abhishekashokvkumar/jev-mcp-dispatcher and Dicklesworthstone/skillranker. Cookbook entries from TypeSafe AI cover function calling and skill suggestion. Before you copy one, check what the router is shown, how many options it can pick from, what it does on low confidence, and whether the author measured the result or only demonstrated it. Treat any savings claim as the author's own until you have run it on your traffic.
45 entries
Showing 45 of 45
Agent skills for Hermes, Claude Code and Codex that hand Jev the routing decisions: which model tier to use, which search results to open, which memory passages to read and which hide injected instructions. Ships a dashboard with an on, shadow and off switch and publishes measured latencies per skill.
Automatic per-turn model routing for Claude Code and OpenAI Codex. Jev sends simple work to the fast model tier and difficult work to the strong tier while preserving each CLI's native tools, sessions, permissions and authentication.
Per-call model routing for Codex: Jev answers four choice questions to pick the model tier and thinking depth, so the cheapest sufficient model serves each call. A 7-day replay of 237 real turns measured about 60% savings against always using Astra, under an older policy.
262 starsHistorical replay ~-60% cost
Self-hosted, versioned skills library for AI agents. Serves skills over MCP with scoped clients, and adds optional Jev recommendations for which skill to reach for.
Rust CLI that hands an agent's live session context to Jev, which compares the available skills and estimates which fit the next step. Ships Claude Code hooks, structured JSON, abstention, a terminal display and local feedback.
Personal-assistant agent built with Vercel's eve framework and 100 mocked tools, served through OpenRouter. Measures how many steps the agent needs when the LLM picks the tool itself versus when Jev picks it via a 101-option Choice.
Adds semantic tool routing, skill discovery and typed Choice, Noul and Score judgments to the Pi coding agent. Opt-in modes pick the model per prompt and use Jev to decide which tool history survives compaction.
Local-first macOS coding workspace built in Rust with a local Laya selector and optional hosted Jev, routing fresh coding tasks and validating each chosen route on the host.
Avid (@Av1dlive)Opencodejunkie99/keel on github.com41 starsCost/time cut ~80%
Ranks Pi agent skills for the task in front of it, using Jev to pick which skill to load.
Gives an agent one tool to find the documented commands it needs, using Jev to search a nested capability tree and return only the context attached to the selected operations.
Routes agent skill selection through typed, confidence-aware Jev questions so a weak match is sent for review instead of guessed. On 72 synthetic requests it routed 68 correctly (94.4%) against 51 (70.8%) for a lexical baseline, at a median 1,287 ms; the author labels the results exploratory.
A minimal Pareto-optimal router for OpenRouter models in the Pi coding agent, using Jev to pick a model on the cost-quality frontier for each turn.
Pi extension that lets Jev choose a model and reasoning effort through Vercel AI Gateway, then keeps both pinned for the session. Generation still runs on your existing Pi providers and credentials.
Open-source LLM router that uses Jev to pick a model, built on LiteLLM. Clients send a single model ID and Jev routes each request; it falls through without a TypeSafe API key.
A task-boundary model router for the Pi coding agent: Jev judges task tier, context sufficiency and consequences, and deterministic code decides whether to switch models based on your configured capabilities and costs.
Routes MCP tool discovery for Codex through Jev instead of exposing hundreds of tool schemas directly to the agent: Jev sees the request and the tool names, and above a 0.90 threshold the agent gets one tool and its schema instead of the full list.
A FastAPI request router that uses Laya as a System 1 decision layer to pick between small, medium and powerful downstream models, matching GPT-5 nano's routing accuracy at far lower latency in the author's evaluation.
Local proxy between Claude Code and the Anthropic API that picks the model and effort level per message with a Jev decision. The author measured that routing subagents saves money while routing an established main chat loses it: 309 logged requests cost $106.73 against an $87.19 baseline, and $17.12 of the $19.53 loss came from the main chat alone.
A zero-dependency library that prunes large tool schema catalogs down to top candidates in 0.4 milliseconds, entirely pre-flight and offline, cutting the tokens spent listing tools by up to 92 percent. The author reports 100 percent on Berkeley's FCL v3 benchmark with Jev.
Dispatches natural-language requests to MCP tools using only Jev, with no general-purpose LLM in the loop. It reads a server's tool signatures at runtime and uses Jev's Choice and Noul primitives to pick the right tool and pull its arguments out of the sentence.
Claude Code mod that routes decisions to Jev: it ranks installed skills against each prompt and answers the agent's own this-or-that questions when confidence is high enough, otherwise falling back to asking the user.
A personal skill router for Claude Code that uses Jev to decide which of your installed skills a session needs, built after the author found they only reached for five of about 90 installed skills.
Two ComfyUI nodes that free VRAM between models on a single GPU: one unloads cached image models, and a Laya-based router classifies the enhanced prompt's style before an image model loads. Measured on a 12 GB RTX 3080 Ti.
A Codex CLI plugin that uses Jev to score which of a project's skills are relevant to a prompt, passes the matches to Codex, and shows selection history on a local dashboard.
A cross-platform Agent Skill and MCP tool that gives Codex, Claude Code, OpenCode and Pi local Laya decision routing, with explicit invocation verified end to end on Apple Silicon and cross-platform CI.
Measures on your own labelled data where a small model's confidence stops paying off, then routes each decision to Jev or a larger model at the threshold it found rather than a default. On 500 Banking77 examples Jev was 77.8% accurate but 90.7% confident, and threshold 0.67 reached 80.2% accuracy for $0.1033.
A Home Assistant conversation agent where Jev classifies an utterance and either takes a fast-path light action or hands off to the Grok conversation agent, gated by confidence and yes/no thresholds.
A Hermes plugin that pre-routes each task to a skill before the main model sees it, classifying against a roughly 300-skill index with SemIf by default or a legacy local Laya model. Measured 67 percent top-1 for SemIf against 56 percent for Laya on the same pools.
A Jev-based model-routing experiment for Codex tasks that the author now recommends against adopting: in a Pokedex benchmark, the Jev-routed team cost almost as much as running the top model alone and missed the time limit, while the single-model run finished and passed all checks. Code and results are public as a negative benchmark.
Answers four routing questions about an agent turn, model tier, effort, tools and skill, in a single Jev call under 350ms with a hard deadline, and ships a Claude Agent SDK adapter.
A local MCP gateway that uses Jev for tool discovery across connected MCP servers, with credential storage, a CLI and a dashboard.
prasanth263Openprasanth263/maza on github.com
Demo in which Jev decides which model should serve a request before the request is forwarded.
Vercel's eve agent framework announcing criteria-based model routing built on Jev: its experimental autoModel uses typesafe-ai/jev to pick between models described in plain language.
A chat bot that uses Jev to pick which tool to call, such as web search, Wikipedia, weather, Todoist or Home Assistant, and what arguments to pass, with no general-purpose LLM in the loop.
CJ (Coding Garden) (@CodingGarden)114k viewsOpenA chat bot that picks tools with Jev, no LLM (X) on x.com
A video demo replaces an LLM's tool-calling decision step with Jev, exploring how voice agents could act on partial speech before the user finishes speaking, aiming for lower latency and cost than running an LLM at each step.
An API that routes a request across more than 1,000 AI models from 50 or more providers. Corent's routing layer now uses Jev to decide what a request needs and how confident it is in that route before generation happens, falling back to a safer model below a set confidence level.
corent (@corentAI)OpenCorent on corent.tech110k viewsModel pool 1,000+ models
OpenRouter and TypeSafe's hosted router, typesafe/jev-router, uses Jev to pick the model and reasoning effort for each turn and avoids switches that would lose the cached conversation. OpenRouter reports it solved 237 of 423 agent tasks against 130 for its own Auto Router.
A short video demo of an agent whose model router is powered by Jev; the post text gives no further detail on how the routing itself works.
On OpenMausBot, Jev reads an incoming task and decides which bot to wake and which underlying LLM to assign it, working across the user's existing LLM subscriptions.
Benchmarks Laya-MLX against Jev/Qwen3-4B inside an OpenClaw agent cascade on an M4 Pro: Laya scores 85% at 27.8ms, Jev scores 90% at 1,168ms, and 14 of 20 decisions resolve before reaching Jev.
meraGPT's own post, following Elvis Saravia's "Building a Custom Harness with Pi and Jev". A Pi agent harness of about 130 lines of JavaScript calls Decider 1 through TypeSafe's JS SDK to pick the model, block shell commands that delete data or use the network, and send unfinished answers back.
Picks which agent skill to load for a given task by scoring candidate skills against the current state.
Maps a natural-language request onto a function and its arguments using Choice questions, as a cheaper substitute for LLM tool calling.
Chains cheap Jev decisions in front of expensive steps so only the uncertain cases escalate.
LangChain integration package (0.0.1a2 pre-release, MIT) providing TypeSafeClassifier as a Runnable plus experimental agent middleware: ModelRouterMiddleware, SkillsMiddleware and AutoModeMiddleware for tool-risk gating.
Nothing matches those filters
Clear a filter to widen the search, or send us the thing you were looking for.
The loop is short. The router gets the request and a list of candidates, asks a choice question, and hands the request to the winner. In ComfyUI Sequential GPU Router by highdeftant, a Laya-based router classifies the prompt's style before choosing which image model to load. Corent, an API that routes requests across many models, uses Jev in its routing layer to decide what a request needs.
Choice fits picking one route. Score fits ranking many skills or tools against a prompt, as Dicklesworthstone/skillranker does with an agent's live session context. Long tool lists are a problem, so jackbarunz/jev-tool-router shows Jev the request and the tool names instead of exposing hundreds of tool schemas to the agent. Entries differ on whether they route once per message or again at each step of a task.
Routing only pays off if it beats sending everything to one model. instructa/switchloom is a useful honest case: the author now recommends against adopting the Jev-routed setup after running a benchmark on it. Measure on your own traffic first, and keep a fallback for low-confidence calls. A router that cannot be measured is hard to trust, so look for entries that report a baseline next to their result.
For picking one route from a known list, a decision model returns a typed choice with a confidence value, which is easy to act on. An LLM is better when the request needs open-ended reasoning. Some entries here use both and escalate only when confidence is low.
Yes. Entries such as abhishekashokvkumar/jev-mcp-dispatcher and Dicklesworthstone/skillranker give Jev a request and a list of tools or skills and act on its choice or scores.
Yes. 0xNatoshi/jev-codex-router and adarshmishra07/jcm-router pick a model and effort level per message. Check each project's own measurements before relying on the savings.
