Three routing systems. JEV FastLoop is a fail-open decision edge layer for Jev, TypeSafe's System One model. LAYA Router Gateway is a local provider-aware OpenAI-compatible gateway. LAYA Code Router routes each Claude Code or Codex turn with a local decision model.
All three treat a model decision as infrastructure: narrow the question, keep a deterministic policy in charge, log what happened, and make escalation a deliberate choice. Only two of them are public software.
A fail-open semantic edge layer for Jev, TypeSafe's System One model. It combines keyword retrieval, local embeddings, and Jev reranking over a 1,248-skill roster, then abstains when the first signal is weak. Jev is a decision model, not an LLM: it returns typed choices, scores, and yes/no with confidence.
Read the JEV FastLoop repository ↗
An OpenAI-compatible gateway that turns preset names into healthy, provider-aware routes. Laya scores task difficulty, deterministic policy chooses the route, and the Control Center makes the decision inspectable. Local build on 127.0.0.1:4020 for the API; the captured preview ran on 4021.
See the LAYA gateway evidence below ↓
Per-turn model routing for Claude Code and OpenAI Codex. One local Laya call per fresh user turn scores task complexity, and a deterministic score-to-tier table picks fast, balanced, or strong. The routing decision never leaves the machine. Ported from the MIT-licensed jev-router project, with the hosted Jev call replaced by a local sidecar.
Read the LAYA Code Router repository ↗AI agents need a cheap answer to “which path?” before they pay for a bigger one.
JEV FastLoop answers that question for skills: retrieve candidates, rerank them with Jev, and abstain when retrieval is weak. LAYA Router Gateway answers the neighboring question for model providers: score the task, apply policy, check health, and dispatch through an endpoint-aware transport.
Neither system hides the judgment inside a giant prompt. Both keep deterministic code, a small decision model, and a visible fallback boundary separate.
JEV FastLoop routes a skill roster. LAYA Router Gateway routes model/provider pairs. LAYA Code Router routes each turn of a coding session. The architectural pattern is deliberately similar across all three.
Keyword and local embedding legs surface candidates before an expensive model is asked to judge.
JEV returns choice, score, or noul-style decisions. LAYA scores task complexity, reasoning, and tool complexity.
Confidence, capability, health, and provenance determine what is eligible. The model does not silently become the policy.
Decisions, abstentions, fallbacks, and attempts become evidence that can be inspected and evaluated later.
Jev is TypeSafe’s hosted System One model. Laya is a separate local System 1 decision model. Each project below uses exactly one of them.
Use it when the question is “which existing skill or label fits?”
Use it when the question is “which healthy model/provider should serve this request?”
Use it when the question is “which model should serve this one user turn?”
The JEV images below come from the public project evidence set. The LAYA images are real captures from the isolated Control Center during the recorded build. Counts describe that build; they are not promises of hosted scale or future availability.
Every row below was recorded on 2026-09-19/20 against jev-1.13-free through the OpenCode Zen gateway, at $0 across all runs. That model is a limited-time free tier, so these are dated observations of a specific build, not permanent capability claims.
Jev's own project README argues from early ablation evidence that retrieval does the heavy lifting on routing tasks, and that fusing Jev with a first signal beats either signal alone. The same README reports that one giant free-form verdict scored materially worse than the same model decomposed into narrow typed signals combined with code.
Those comparison numbers are cited in the project as independent early evidence rather than as a measurement this case study reproduced, so treat them as the project's reasoning rather than a verified benchmark on this page.
The architectural conclusion is the durable part: put deterministic facts in code, use Jev as a second semantic signal, let policy own the confidence threshold, and treat escalation as a deliberate choice. Jev is replaceable infrastructure. Swap the backend, keep the service, and never make it the only signal on an expensive decision.
LAYA Router Gateway is a separate local build. It uses a local LAYA decision model to score task complexity, then lets deterministic policy choose a healthy, enabled, non-retired model/provider route. The client keeps one OpenAI-compatible contract while endpoint, protocol, authentication, health, and fallback stay behind the boundary.
Free-first with the lowest intelligence floor (14). Stays on a known-good free model whenever one clears the bar.
Free-first with a higher floor (24). Demands more capability before accepting a free model, so it escalates sooner.
Paid-only, floor 36. Never selects a free model, because free is never assumed to be good enough.
Paid-only, floor 44. Asks for the strongest healthy model available, with the same deterministic policy shape.
Each (model, provider) pair is tracked independently, and the error taxonomy decides whether a pair is skipped, cooled down, retried, or left alone.
Each completion response carries a laya_router block: the preset, the model and provider that actually served it, whether it was free, the capability score, the reason, Laya's latency and confidence, and the full attempted list. If a planned free route ends up served by a paid provider, the response says so rather than hiding the cost.
The gateway pins one model per session using x-router-session, metadata.session_id, or user. Turn two of a conversation reuses that model with no Laya call, so a prompt cache is never thrown away mid-conversation. A new session, including each delegated subagent, gets its own fresh decision. If a pinned provider dies mid-session, the pin is dropped and the gateway re-decides for that one call instead of failing the turn.
The gateway issues its own client key, restricted to an allow-list of model names. Only a SHA-256 hash of each key is stored, and provider credentials stay in macOS Keychain and the server process. The UI and API never return an existing provider secret. Admin endpoints are loopback-only and can require ROUTER_ADMIN_TOKEN.
The same local-difficulty idea as the gateway, applied one turn at a time to a real coding CLI. A launcher starts a loopback proxy and a long-lived Laya sidecar, launches the actual Claude Code or Codex binary, and forwards the CLI's own authorization headers without reading, storing, or modifying them. The routing decision is local; the model call is not.
Auth redesigns and whole-repo migrations land here. Selects the strongest tier, such as Opus or gpt-5.6-sol.
Trivial turns drop to the cheapest tier, such as Haiku or gpt-5.6-luna.
Everything between the thresholds lands on the middle tier, such as Sonnet or gpt-5.6-terra.
A Laya failure, timeout, or sidecar crash keeps the current model instead of blocking the CLI. An explicit request always wins.
Measured 2026-09-23 on an M2 Max with the default checkpoint:
Routing has no key and no hosted call, because the decision model runs locally. The first decision of a session pays a roughly 40-second model load, which the launcher pre-warms while the CLI starts, so interactive use rarely waits. The first routing decision typically lands in about 40 to 50ms once warm.
Only the routing decision stays local. The coding model itself still runs at Anthropic or OpenAI, and the gateway's paid tiers still pay for upstream models by design. Do not read "nothing leaves the machine" as an offline guarantee for the work itself; it is a guarantee about the routing decision.
Claude Code and Codex request formats are not public contracts, so an environment flag dumps request bodies for diagnosis when an upstream format changes.
I build governed decision, routing, and provider-aware systems for products and teams that need the layer to be inspectable.