The most common mistake when wiring Jev into a coding agent is asking it, "Which model is best?" That isn't a stable engineering question: task scope, whether writes are allowed, verification cost, and the cost of a mistake all change the answer.
A better approach is to turn it into a small, well-defined decision maker. It outputs only which path the task should take, whether approval is needed, and how certain the call is. Claude Code, Codex, Gemini, or another execution model then handles planning, editing code, calling tools, and verifying results.
TypeSafe's official documentation draws the same line: Jev does not generate text or code and is not a replacement for a coding agent. It is suited to structured judgments such as routing, classification, scoring, and guardrails.See how responsibilities are divided between Jev and the coding agent
The output of routing should be an "operating contract"
A reviewable router does more than pick a model. It declares the conditions for the next step. A minimal output can contain three fields:
route: quick_answer | coding_task | deep_review
approval: required | not_required
confidence: 0.00–1.00
Your application then maps that result to deterministic actions. For example:
| Routing result | Allowed next actions |
| `quick_answer` | Explanations, locating information, formatting; no file writes by default |
| `coding_task` | Handle well-scoped changes and run predefined verification |
| `deep_review` | Present a plan and the scope of impact first, then execute and keep a verification record |
| `approval: required` | Stop automatic execution and wait for human confirmation |
The point isn't to label a model as "fast" or "strong." It's to let the team answer one question: why was this task allowed to reach writes, commits, or external calls? When the rules need to change, you edit this contract instead of intuition scattered across prompts. For how to break tasks down so they can be routed and accepted independently, see the task-splitting approach for Codex Subagents.
Judge complexity and risk separately
Complexity describes how much reasoning and tool work it takes to finish the task. Risk describes what happens if you get it wrong. The two often move out of sync.
• Adding a comment to a function: low complexity, low risk.
• A production database migration: the description may be short, but the risk is high.
• Analyzing a long log: complexity may be high, but it usually doesn't need write access.
So don't pick a model from a single score. At minimum, have the router judge separately how much execution capability is needed and whether this step can run automatically. The application layer then applies a clear priority: risk vetoes automation, and complexity decides which execution path to use once automation is allowed.
if approval == "required":
request_human_approval()
elif route == "quick_answer":
run_read_only_path()
elif route == "coding_task":
run_standard_coding_path_with_tests()
else:
run_deep_review_path_with_plan_and_verification()
This pseudocode deliberately checks approval first. Otherwise, a task judged to be simple could bypass a safety gate that should have applied.
Low confidence isn't a failure. It's a controlled exit
The most dangerous moment in routing isn't "I don't know." It's dressing up "I don't know" as certainty. Define how to handle low confidence before the call, for example:
• Add the missing state and re-evaluate, such as the scope of changed files, the target environment, and whether secrets are involved;
• Continue on a read-only path, but block writes and external tool calls;
• Escalate to an execution path with plan and verification requirements;
• Ask for human confirmation directly.
Don't set thresholds by feel. First collect a batch of historical tasks and have people label the expected path and whether approval should be required. Then compare Jev's judgments with the actual outcomes. For high-risk tasks, prioritize reducing the rate of incorrect auto-approvals over minimizing human involvement.
Use four metrics to verify that routing adds value
Whether routing is worth keeping depends on whether it improves your workflow, not on whether it looks smarter. When testing, watch these together:
| Metric | The question it answers |
| First-pass verification rate | Was the task sent down the right execution path? |
| Human override rate | On which tasks are the routing rules unreliable? |
| Unsafe auto-approval rate | Did high-risk operations bypass the approval flow? |
| Cost and latency per completed task | Does the split actually buy a reasonable level of resource use? |
Break these metrics down by task type. If you average across all tasks, a router that works well on simple Q&A but often misjudges write tasks can easily look better than it really is.
Start with read-only tasks, then expand permissions
Your first rollout doesn't need to cover the entire coding workflow. Pick an entry point that can be replayed and where mistakes won't change external state, such as distinguishing "explain a problem" from "needs a code change." Record the task summary, routing output, actual path, verification result, and any human override. Once that sample set is stable, connect the router to file writes, commits, or external systems.
If your execution models come from different providers, the integration layer can use a multi-model API relay service, AI Code With, to put Jev and the execution models behind the same call entry point. The routing policy itself should still be vendor-independent and driven by the replayable data above.
Further reading
• Codex automation permission configuration: keeping least privilege in the execution chain
• How to use different models together: unified keys, accounts, and call records
