The Model Context Protocol (MCP) gave AI agents a standard way to call external tools, and Jev gave those agents a tool worth calling: a decision endpoint that returns typed answers in milliseconds. Put together, an agent that can reach an MCP server wrapping Jev gains something it cannot get from more context or a bigger model — a fast, consistent judgment it can branch on.

Why an agent needs a decision tool

An agent’s hardest moments are not generative. Which of these ten search results matches the request? Is this page the product page or an ad? Has this step succeeded? Should the next action be safe or exploratory? Agents today answer these by prompting themselves and parsing their own prose — the model equivalent of muttering under your breath. It works until it does not, and the failure is invisible: an agent that is 80% sure looks identical to one that is guessing.

A Jev call behind an MCP tool changes the mechanics. The agent passes the situation as state and asks typed questions; the tool returns choices with probabilities and a confidence. The agent’s own loop — or the harness code around it — can branch on that, route low-confidence moments to a slower path, or surface the number to a human.

The shape of a Jev MCP tool

A minimal Jev tool has three parts, and builders in the agents and browsers category converge on the same shape:

1. State assembly. The tool gathers what the judgment is about: the page text, the candidate list, the conversation tail. State is data, not instructions — see designing state and questions for the discipline that keeps this small and cheap.

2. Question templates. Fixed, versioned questions with explicit criteria — a choice over the agent’s action space, a score for “how confident are we this step completed”, a noul for binary safety checks. The agent supplies inputs, not the questions; the tool author owns the schema.

3. Confidence plumbing. The return value includes confidence so the harness can act on it: retry, escalate, or proceed. A judgment without its confidence is half a judgment.

Why the protocol matters here

MCP is doing for tool access what it always promised: a Jev-wrapping server written once is reachable from any MCP-speaking client. The practical consequences show up in the build patterns this directory catalogs:

  • Routing inside coding agents. Instead of the coding model deciding which of its sub-agents handles a subtask, a Jev call picks from the roster with criteria, in milliseconds, for a fraction of a cent.
  • Action selection in browser agents. The DOM becomes state; the action space becomes a choice question; code executes the winner with real guards. Builders report flight searches and checkout flows run this way with per-step costs in the thousandths of a cent.
  • Quality gates in content pipelines. The writer drafts, a Jev tool scores the draft against the brief, and only passing drafts continue — the content and growth category is full of this loop.

What to keep in code

The MCP boundary is also the right place to keep the layer Jev Engineering names as code-acts: allow-lists of reachable actions, spend limits on the Jev budget itself, and logging of every judgment with its inputs. An agent with a decision tool and no ledger is just an agent with better opinions. The Jev Engineering guide covers the full split; confidence and review covers what to do when the number comes back low.

Trying it

The fastest path is to wrap one decision you can verify — for example, relevance ranking: state is a query plus ten snippets, one choice question asks for the best match, and you compare against your own picks for a week. At $0.042 per million input tokens with output free, the experiment costs about as much as the coffee you drink while reading the results, and the API quick start is the call to wrap.

Published 25 September 2026. MCP refers to the open Model Context Protocol; patterns described are those visible in builds catalogued in this directory on this date.