Coding agents are the natural habitat for a decision model. The agent already plans, writes, and reasons in an expensive loop, and what it needs between steps is not more generation, it is a fast typed answer to a narrow question. That is the gap Jev fills, and the ecosystem has filled it from several directions.
Gate tool calls before they run
The most direct integration is a gate: intercept a tool call, ask Jev whether it is safe or on-task, and act on the answer before anything executes.
pi-jev is a Pi extension that judges bash, write, and edit calls in one request of roughly 300 ms, mixing four judgments: destructive (0.90), exfiltration (0.70), beyond_scope (0.85), and an impact score (2.50). It also runs an output judge that flags leaked secrets and classifies failures. Two defaults to read before enabling it: the gate starts in shadow mode, and every error path fails open.
pi-jev-auto-mode takes the opposite safety stance: it approves bash, write, and edit calls semantically and fails closed whenever a decision cannot be made. If you are choosing between the two, the difference that matters is what happens when the API call fails.
Give the agent judgment tools
The second pattern is an MCP server, which puts Jev's primitives behind the same interface as the agent's other tools.
jev-mcp exposes ten tools, including verify, screen, find, rerank, classify, review, and gate, each returning typed probabilities in roughly 150 to 500 ms. Typesafe MCP goes the other way and exposes a single evaluate tool for noul, choice, and score questions, shipping as one static Go binary with one-command registration for Claude Code, Claude Desktop, and Codex. Both support provider fallbacks, TypeSafe direct or a gateway, which is useful when you want to compare routes without changing your prompt design.
Trim context instead of paying for it
Reading and writing context is where coding agents spend most of their money, so the third pattern prunes what reaches the model.
jev-pruner is a Claude Code hook that reads Bash output after the command runs and before the model sees it. Outputs at or below an estimated 10,000 tokens pass through untouched; larger outputs are scored in chunks, irrelevant ones are dropped with [N lines omitted] markers, and everything is archived first. Errors, diffs, JSON, XML, YAML, binary, docs, and source code are all preserved.
Rank skills and supervise the loop
Two more patterns round out the loop. Building with Jev is an agent skill for writing and improving Jev programs themselves, covering question design, state structure, and diagnosing questions that keep coming back wrong. SkillRanker is a Rust CLI that ranks which skill the agent should load next using a two-stage Jev pass, with a lexical prefilter for rosters above 254 skills, plus abstention and --why-not explanations.
At the top of the stack, Foreman runs Jev as a supervision loop above Codex or OpenCode workers. Two asyncio loops run concurrently, one driving the worker and one judging, and each judgment covers ten factory questions including implementation_complete, tests_sufficient, and worker_stuck. Codex App Server sessions can be steered mid-turn; OpenCode sessions degrade to stop and retry.
Small open models for the gate
Every tool above calls the hosted API, and the gate is exactly the place where a local model fits: a bounded question with a known answer space, asked hundreds of times a session. Strands Decider was built for this — model routing, tool selection, and triage from a 2B LoRA checkpoint that serves /v1/systemone locally, at 0.641 on its held-out short tasks. Interfaze Lev serves the same route from a 4B adapter, and JEV-9B answers through POST /v1/decide while leaving HumanEval pass@1 at 70.7%, because the System 2 backbone stays untouched.
What a local gate buys is availability: a fail-closed policy is only as good as the endpoint behind it, and a resident model cannot rate-limit you. What it costs is calibration and maintenance. The gate's thresholds have to be fitted on the local checkpoint's probabilities rather than copied from a hosted configuration, and the model card's speed numbers are warm-call numbers, so keep the checkpoint resident the way the local servers do. The fine-tuning and calibration walkthrough covers the fitting step, and serving System One locally covers the servers themselves.
What to copy from all of this
Across very different projects, the same design shows up:
- Put Jev between the agent and the action, not in the planner.
- Batch the gate questions into one request; four judgments in 300 ms is the bar.
- Decide deliberately what happens on API failure. Shadow mode and fail-open are reasonable defaults for a first rollout; fail-closed is the right choice once the gate is load-bearing.
- Cache identical inputs, as pi-jev does for 120 seconds, so repeated checks are free.
- Keep policy in code. The gate classifies; your thresholds and permissions decide.
Browsers, shell history, and Postgres are getting the same treatment; the tools category collects those experiments. The coding loop is simply where the pattern is most mature, and the fastest place to see what a decision layer feels like in practice.
