Jev engineering for coding agents

A coding agent spends most of its tokens on small judgment calls between edits — which skill to load, whether a command is safe to run, whether the task is done. Jev engineering is the practice of pulling those bounded calls out of the big model and handing them to Jev: one typed, calibrated decision in about 70–500ms instead of another paragraph to generate and parse.

The model behind Claude Code, Cursor or Codex is excellent at planning and writing code and expensive at everything else. Every loop it also makes dozens of routine choices — pick a tool, judge a diff, decide whether to keep going — and each one is a fresh generation you wait on and parse. Jev engineering moves those choices to a model built only for them: you send the state plus a typed question, and get back a value your code branches on, with a calibrated confidence.

What a coding agent should offload to Jev

Not everything — only the calls with a finite answer space. If the step produces code or prose, it stays with the big model. If it picks from a fixed set, judges a yes/no, or rates something on a scale, it's a Jev call:

Each row is one question. You can send several in the same request and they're all answered in a single parallel pass — so gating a command, classifying its risk and checking whether you're done can be one round trip, not three.

Drop it into your agent — no code

The fastest way to start is to give your agent the decide tool once, then paste a rule that makes it check risky commands before running them. Add the MCP server (set JEV_API_KEY=jv_live_...):

npx github:codaaiteam/jev-mcp   # gives the agent a `decide` tool

Claude Code — save this as .claude/skills/jev-gate/SKILL.md:

---
name: jev-gate
description: Gate risky, irreversible shell/git commands with Jev before running them; stop for the human when unsafe or destructive.
---

# Jev safety gate for coding agents

Before running any irreversible command — rm, git push --force, a deploy,
a DB migration, or anything that writes outside the repo — call the `decide`
tool (from jev-mcp) with:
  state: the exact command + one line of why
  questions:
    safe: { type: "noul", instructions: "Safe and reversible to run without a human?" }
    kind: { type: "choice", criteria: { read, write, destructive } }

If safe < 0.8 or kind == "destructive" -> STOP and ask the human. Else run it.
Read-only commands (ls, cat, git status, grep, tests) skip the check.

Codex / opencode — paste the same rule into your AGENTS.md. The same pattern works for a deterministic PreToolUse hook the agent can't skip.

Or wire it yourself (code)

Two calls a coding agent makes constantly — which tool to reach for, and whether it's done — in a single request:

// One decide call, two typed answers, before the next step
const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
  },
  body: JSON.stringify({
    state: { task, lastOutput, filesTouched },
    questions: {
      tool: { type: "choice", instructions: "Which tool should run next?",
              criteria: { edit: "change a file", run: "run a command/tests",
                          search: "search the codebase", done: "nothing left to do" } },
      done: { type: "noul", instructions: "Is the task fully complete and verified?" },
    },
  }),
});
const { answers } = await res.json();

if (answers.done.noul > 0.85) return finish();        // confident it's done
await dispatch(answers.tool.choice);                  // else run the chosen tool

answers.tool.choice is locked to the keys you listed, so there is no invalid tool to handle; answers.done.noul is a calibrated probability RLCD training makes trustworthy. Tune the 0.85 threshold against your own run logs.

What Jev does not do

Jev is not a replacement for the model behind your coding agent. It doesn't write code, stream text, call tools or edit files — it returns one typed value per question. Keep the frontier model for generation and reasoning, and use Jev for the bounded calls around it. "Can't hallucinate" only means it can't return a value outside your schema; a decision can still be wrong, so keep a human on genuinely destructive or consequential actions regardless of confidence.

Which primitive to use

• choice — pick one tool, skill or route from a fixed set; or classify a command's risk
• noul — a calibrated yes/no such as 'safe to run?', 'did this step succeed?', 'done yet?'
• score — rate relevance or risk on a 0–1 scale when you want a graded threshold (e.g. context compaction)

Want working references? jevgrep uses a score call to rank code chunks, Jev for computer use gates clicks, and Jev for compaction scores what to keep when the context bloats — all the same decide call, different questions.

FAQ

See also: Jev for computer use · jevgrep — ranked code search · Jev for context compaction · Jev MCP server · Jev as a judge · jev-mcp (GitHub)