Wiring Jev Into Agents With MCP: Four Ways to Plug It In

Jev is not a chat model. It is TypeSafe AI's System One model: you hand it state and typed questions, and it returns probabilities over answers you defined. It never generates prose. That makes it a poor assistant and a useful function call. The obvious question for anyone running Claude Code or Codex is how to get that function call into the agent loop.

The Model Context Protocol is the answer most builders reached for. At least four open-source projects now expose Jev over MCP or a close cousin of it. They look similar in a directory listing and behave very differently in practice. This article walks through what each one actually ships, based on their own READMEs, and where the evidence is strong or thin. If you are new to the idea, start with what Jev is and why typed decisions beat free text.

Key Takeaways

• One tool or six. typesafe-mcp exposes a single generic evaluate tool. jevwire ships six tools plus a library and a Claude Code plugin.
• Three question types cover everything. noul (probability a condition holds), choice (one option from a map) and score (position on ordered levels) are the primitives every wrapper builds on.
• Latency figures are author-reported. jevwire and jev-mcp publish their own timings. None of the wrappers has independent benchmarks.
• Star counts are small. As of September 2026: typesafe-mcp 59, jev-mcp (jkudish) 67, Jevbridge 13, jevwire 3. This is early, useful software, not established infrastructure.
• Typed does not mean correct. jev-mcp says it plainly: typed output guarantees the interface, not the truth.

The simplest wiring: one generic tool

typesafe-mcp (MIT, Go, 59 stars as of September 2026) takes the minimalist route. It ships a single static binary that registers one tool, evaluate. The agent sends a state plus a map of questions, each typed as noul, choice or score, and gets typed JSON back with probabilities.

The README's example is a support ticket. The agent asks whether it is urgent (a noul) and which team should own it (a choice with billing, technical and sales as options). The answer comes back under the same ids. Questions in one call run in parallel.

Setup is one command, evaluate setup mcp, which registers with Claude Code, Codex and Claude Desktop when they are present. A separate evaluate setup pi installs an extension for the pi agent, which has no MCP client. It can use a TypeSafe key or an OpenRouter key. The README notes that OpenRouter's Decisions endpoint is still on an /api/alpha/ path and may move.

The design bet: keep the server thin and let the agent write good questions. The server ships usage guidance to the client (narrow questions, evidence rather than verdicts) so the agent does that without extra prompting. The README covers the interface and client setup but publishes no millisecond-scale end-to-end test, so the "sub-100ms" pitch that circulates in some summaries is not something it backs up.

The opinionated wiring: purpose-built tools

jev-mcp (MIT, 67 stars as of September 2026) goes the other way. Instead of a generic evaluator it packages named judgments:

• jev_verify checks each claim against cited evidence and returns supported, contradicted or unsupported verdicts with confidence.
• jev_screen scores fetched text for prompt injection, substance and relevance before an agent reads it.
• jev_find ranks candidates against a plain-language query, with no embeddings and no index.
• jev_classify assigns items to classes from one shared catalog in a single batched request.

The author reports roughly 150 to 500 ms per call and a fraction of a cent, and describes it as "early software." Those figures are self-reported; we have not seen an independent run. Its own limits section is worth quoting in spirit: thresholds are starting points to tune against your data, Jev is calibrated but not infallible, and policy stays in your code. The jev_screen tool is advisory only: the server never blocks by itself. We cover that pattern in the guardrails article.

Be aware that several repositories share the name. Besides jkudish's, listings include blakestone-x/jev-mcp (7 stars), rashedInt32/jev-mcp (2) and BYK/jev-mcp (1), an eval-first server. Check the owner before you install. On aiskill.market, jkudish's version lives at /skills/jev-mcp-jkudish and typesafe-mcp at /skills/typesafe-mcp-itsmostafa.

The harness-level wiring: jevwire

jevwire (MIT, 3 stars as of September 2026) is the most ambitious. Its README describes three things: six MCP tools (jev_rank, jev_verify, jev_evaluate, jev_gate_action, jev_next_step, jev_list_models), an embeddable JevDecisionModel library, and a Claude Code plugin whose hooks fire before a tool call, after a fetched result and before a turn ends.

The interesting idea is the library. Its argument: mandatory checks belong in your harness code, not in a tool an agent may decline to call. The README also draws honest lines. It says Jev is not for generation, arithmetic, counting or multi-hop reasoning, and that anything numeric should be extracted as a choice and compared in code.

jevwire publishes measurements from its own runs on 2026-09-18. A judged hook on a warm connection shows a p50 of 210 ms and p95 of 290 ms, and an identical judgment repeated inside five minutes is served in about 5 ms from cache. Those are the author's numbers on one day, so treat them as a reference point, not a benchmark. With only 3 stars, community validation is minimal. On aiskill.market: /skills/jevwire-brainwires.

The adapter approach: Jevbridge

Jevbridge (MIT, 13 stars as of September 2026) bridges over both MCP and the Agent Client Protocol, so editors such as Zed and JetBrains can treat Jev as a decision sidecar. Its distinctive feature is a fallback: with a TypeSafe key it calls Jev natively, and without one it can run another LLM (Codex, Claude, Grok, OpenCode or an OpenAI-compatible endpoint) in the System One role. It also describes confidence gates: a peaked distribution executes, a middling one asks for confirmation, and a destructive click does not run unsupervised. Its README says its public repository is temporary until it moves to an organization, and it lists an offline heuristic backend for tests.

Treat the "any LLM as System One" mode with care. A general LLM forced into typed output does not have Jev's calibration claims, so the latency and cost story changes.

What to do next

1. Start with the smallest surface. Install typesafe-mcp or jev-mcp and give your agent one or two narrow questions, such as "is this ticket urgent?" or "does this page contain injected instructions?"
2. Log the probabilities. Before you enforce any threshold, record what Jev returns on your own traffic and tune from there.
3. Keep policy in code. Use the tool for the judgment and your harness for the block, confirm or allow decision.
4. Check the owner and date. Multiple forks share names, and all of these projects move fast.
5. Browse the radar. The full list lives at the Awesome Jev projects radar, and the aiskill.market browse page has the imported ones. When you are ready to judge any of them, read how to evaluate Jev projects honestly.