CalibratedDecisions.

Jev for orchestration: routing requests, models and skills

Jev works well as the routing step in an orchestration layer: it classifies each request with a typed question and returns a confidence your code uses to pick a handler, model, skill or person. TypeSafe documents this as intent routing and confidence-gated routing; Jev never calls the downstream models itself, your code does (Intent routing).

What Jev does in a router

Not every request needs the same handler. Some can be answered with a database lookup, some need an LLM with special context, and some need a person. TypeSafe's docs say it "can sit in front of all of these as a fast, cheap classifier that determines which handler to invoke" (Intent routing).

The split is simple: Jev answers typed questions, and your code owns the routing table, the fallbacks and the side effects. That follows TypeSafe's general advice to keep control flow in code and route on uncertainty (How to build with TypeSafe). The routing and model choice list collects projects built this way.

The documented pattern: intent routing

In TypeSafe's customer service example, one request asks two questions about each message: a Choice for intent (order status, product question, return or complaint) and a Score for complexity. Code then routes on both (Intent routing):

def route_ticket(ticket_id, response):
    intent = response.answers["intent"]
    complexity = response.answers["complexity"]

    if intent.confidence < 0.5:
        # If we don't have enough confidence to classify, route to a human agent
        return route_to_human_agent(ticket_id)

    if intent.choice == "order_status":
        handle_order_status(ticket_id)

    elif intent.choice == "product_question":
        handle_with_llm(ticket_id, PRODUCT_SPECIALIST)

    elif intent.choice == "return_exchange":
        handle_with_llm(ticket_id, RETURNS_SPECIALIST)

    elif intent.choice == "complaint":
        low_confidence = complexity.confidence < 0.5
        # A higher complexity.score leans toward the "escalation needed" end of the scale.
        if complexity.score > 1 or low_confidence:
            # Too complex for safe automation, or we're not sure about the complexity; route to a human.
            route_to_human_agent(ticket_id)
        else:
            handle_with_llm(ticket_id, COMPLAINT_RESOLUTION)

One intent goes to plain code with no LLM, two go to different specialist LLMs, and complaints go to an LLM or a person depending on complexity. The expensive handlers only run for the requests that need them.

Route on confidence, not just the label

A router needs to know when it is guessing. Choice and Score answers include a confidence from 0 to 1, calculated from how spread out the probabilities are. TypeSafe suggests three bands: act when confidence is high, proceed carefully when it is medium, and hand off when it is low (Confidence).

Thresholds should follow the stakes. In the voice banking example, anything below 0.6 goes to a support agent, a balance check runs at 0.6 or more, and a transfer is approved automatically only above 0.85 (Confidence-gated routing). If you only need the best option and no fallback, TypeSafe notes you can take the top answer without a threshold (Agent skill).

Model routing and cascades

A model router is the same pattern with model tiers as the options. TypeSafe's SDE cascade cookbook shows a related design: a cheap model (gpt-5.4-mini) extracts the data, Jev checks each field with a yes/no question, and the request goes to a reasoning model (gpt-5.5) only when a check fails. The goal is most of the big model's quality at a fraction of the cost (SDE cascade).

Two design tips from the docs apply to any router:

At $0.042 per million input tokens with free output (Models), the routing call usually costs far less than the model it routes to. See Jev pricing and Jev vs an LLM.

Routing skills, tools and agents

The same approach works for choosing what an agent loads. TypeSafe's skill suggestion cookbook ranks a 182-skill roster with one Choice and re-checks the top three with a second request, cutting wrong skill loads by more than half in its test (Skill suggestion). Many community routers below apply this to Claude Code, Codex and other harnesses; see also Jev with Claude Code and coding and code review.

Projects doing this

Routing & model choicejev-router (gargpratyush)A local proxy that asks Jev to route each Claude Code or Codex turn to the cheapest model that can handle it, with a deterministic fallback and inspectable routing logs.GitHub · ★ 377 · gargpratyushRouting & model choicehermes-jev-skillsAgent skills and a jev CLI that use Jev for model routing, memory filtering, compaction and skill selection on Hermes, Claude Code and Codex.GitHub · ★ 726 · kerpopuleRouting & model choiceJev Codex RouterPer-turn routing for Codex where Jev picks the model, thinking depth and speed mode for every turn.GitHub · ★ 272 · 0xNatoshiRouting & model choiceJevRouterA capability router where models, subagents, skills, MCP tools and CLIs share one candidate set, Jev answers a typed Choice, and the router enforces permissions and risk.GitHub · ★ 190 · BillionsBobbyRouting & model choiceskillrankerA Rust CLI that uses Jev to rank agent skills for the next step from live session context, with Claude Code hooks and abstention.GitHub · ★ 116 · DicklesworthstoneRouting & model choicegrok-bot-jevA reference Python router and skill that put Jev in front of Grok Bot's expensive work to reuse cache, stop retries, cap research, allow a subagent or ask a human.GitHub · ★ 78 · Bodila51SDKs & integrationshono-jev-routerAn experimental Hono router that matches HTTP requests to plain-English route descriptions using Jev Noul judgments.GitHub · ★ 46 · yusukebeRouting & model choicepi-jev-router (philippdubach)A minimal OpenRouter model router for the pi coding agent, where Jev classifies each task and local policy picks the model tier.GitHub · ★ 14 · philippdubachRouting & model choicejev-agent-skill-routerTyped, confidence-aware routing of which agent skill runs, using Jev decisions.GitHub · ★ 17 · GodsBoyRouting & model choicejev-routerA small TypeScript library that sends each query to the cheapest LLM tier able to handle it, using Jev for classification instead of an LLM call.GitHub · ★ 8 · rajdhakad9826Routing & model choiceflue-jev-demoAn open-source demo of Jev routing inside a Flue agent through Cloudflare AI Gateway.GitHub · ★ 9 · matthewpSearch & RAGllama-index-jevLlamaIndex integrations that use Jev to rank retrieved passages and to select which query engine should answer a question.GitHub · ★ 4 · WiktorB2004

Questions

Can Jev act as a model router?

Yes, as the classifier inside one. Jev picks a model tier or handler from options you define and returns confidence; your code sends the request to that model and handles fallbacks.

Does Jev call other models for me?

No. Jev only returns typed answers. The orchestration code decides which model, tool or person handles the request and makes that call.

How do I stop a Jev router from sending requests to the wrong place?

Gate on confidence. TypeSafe's examples route low-confidence answers to a person and use higher thresholds for riskier routes.

Can one Jev call decide the route and other details at once?

Yes. You can mix Choice, Score and Noul questions in one request. They run in parallel, so asking for intent, complexity and urgency together usually adds little time.

Is there an official Jev router from TypeSafe?

TypeSafe documents routing patterns and cookbooks rather than a packaged router. The routers listed here are community projects.

More guides: What is Jev?Jev pricing and API costJev vs LLMs: when to use whichHow to use Jev: a quickstartJev and MCP: using Jev as a Model Context Protocol toolHow to use Jev with Claude CodeJev in an agentic harness: where it fits in an agent loopJev as a judge: evaluating LLM and agent outputsJev for SEO and GEOJev for ads and ad reviewJev for marketing and lead scoringIs there an open source Jev?Can you fine-tune Jev?Designing questions for JevWhat is RLCD?Jev statistics