---
title: "Generation to Claude, Judgment to Jev — The Synergy and Pricing of Using MCP as a Sub-Model"
date: 2026-09-23
time: "18:45"
model: deepseek-v4-flash
category: knowhow
summary: "It lays out a division of labor where a generative LLM writes the code and the non-generative judgment model Jev verifies it with yes-or-no. It covers Jev's business model and pricing, the four MCP integration paths, and three synergies: on-site supervisor, conditional controller, and fact checker."
tags: Jev, TypeSafe, System-One, MCP, Claude-Code, judgment model, router, pricing
---

## Bottom Line First

Claude Code does the coding and Jev does the judging. Until now we dumped everything on a single Claude or GPT — write prose, write code, and even verify whether it is correct. So the AI confidently lied without even knowing it was wrong. When you attach Jev as a sub-model via MCP, judgment steps in at the point where generation ends. The division between generation and judgment is the heart of this piece.

## 1. What Is Jev

Jev is the first System One model unveiled by TypeSafe AI on September 15, 2026. The founder is known to be Diogo Almeida, who worked on RLHF and InstructGPT at OpenAI, and there are reports that it raised about $40M led by DCVC.

| Item | Content |
|------|------|
| Developer | TypeSafe AI |
| Model | Jev (first System One model) |
| Release | September 15, 2026 (managed API) |
| Nature | Non-generative judgment model |
| Output | Choices, scores, and yes/no probabilities rather than sentences |
| Speed | 70-500ms |
| Endpoint | POST /v1/systemone (model selected via the model field) |

Where an ordinary LLM generates tokens one at a time and chats away, Jev matches program state against a set of typed questions and returns structured answers to each in parallel. With no text generation, there is no room for hallucinated narration to creep in.

## 2. Jev's Business Model

Jev's business model is selling a judgment API. It is not selling model weights but charging per managed API call.

| Item | Content |
|------|------|
| Sales model | Closed managed API |
| Billing unit | Based on input tokens, output tokens free |
| Price | $0.042 per 1M input tokens |
| Per decision | Introduced at about $0.0004 |
| Trial | There is a path with a free browser trial and free credits |

The free output tokens are the point. It is consistent with the explanation that Jev generates no long sentences and returns only judgment values, so there is no output billing. Prices may change, so check the official pricing page.

### Felt Cost Scenarios

| Task | Cost feel |
|------|-----------|
| 1,000 judgments | There is a measurement introduced at about $0.02 (based on jev-use) |
| Scoring and classifying 1,000 documents | A demonstrated figure of about $0.04 and under 2 minutes is cited |
| Entrusting 1,000 calls to a Claude-class generative model | Can run from several dollars to tens of dollars per job |

The real saving comes from reducing the main generative model's unnecessary retries and verbose reasoning the moment you attach it as a sub-judge. Jev is not just cheap itself; it cuts the generative model's wasted swings.

## 3. Four MCP Integration Paths

Jev is not an OpenAI- or Anthropic-style endpoint, and it cannot go directly behind Claude Code or Codex as a model. Instead, the following paths work.

| Path | Description |
|------|------|
| Official TypeSafe agent skill | The official path that gives the agent a judgment role |
| Boundary plugin | A way to intervene at the task boundary |
| MCP tool | Register a judgment tool as an MCP server and call it |
| Per-turn routing | Jev picks the optimal model and reasoning effort every turn |

### Community Implementations

| Implementation | Description |
|--------|------|
| jev-model-router | A plugin for Claude Code, the desktop app, and Codex. It picks the optimal model and reasoning effort in about 1 second and reflects OpenRouter's real-time prices |
| jev-use (npm, 0.7.1) | A plugin that hands steps needing no text output to Jev. Introduced at about p50 230ms and about $0.02 per 1,000 judgments |

## 4. Synergy 1: An On-Site Supervisor Watching a Coding AI Trapped in a Loop

The synergy works simply. While Claude Code performs a task, Jev, connected through an MCP channel, observes the real-time log and test results from the side.

Jev does not chat like a generative LLM; it judges exactly one thing: done, in progress, or stuck in a loop.

If the agent edits the same file three or more times and the tests still fail, Jev spits out a stuck verdict. The main agent then changes strategy or escalates to a human. A judgment model cuts off the structure that burns API calls in an infinite loop.

## 5. Synergy 2: A Conditional Controller Without Text Contamination

When Claude Code is unsure whether it may move to the next step during coding, it calls the Jev tool registered via MCP.

Jev returns only a yes/no probability based on clear criteria a human has set. With no long explanation, there is no parsing error.

It is like hardcoding an if statement into the agent loop. If you nail the pass criteria into code, Jev measures against the same yardstick every time. It fits mechanical gates well, such as the conditions in a spec and whether tests pass.

## 6. Synergy 3: A Real-Time Fact Checker That Catches Human Error

Jev compares the original spec against the comments in the code Claude wrote and scores agreement, distortion, and exaggeration. For example, a probability value like 0.98.

A generative model goes easy on itself when verifying its own output. Jev does not generate, so there is no self-justification. It performs a single mission: cross-checking sources against claims.

## 7. Example MCP Registration Code for Mac Terminal

This is an example of registering an MCP server in the Claude Code settings file. The actual server command and API key must be changed to fit your environment.

```json
{
  "mcpServers": {
    "jev": {
      "command": "npx",
      "args": ["-y", "jev-use"],
      "env": {
        "JEV_API_KEY": "sk-xxxx"
      }
    }
  }
}
```

If you use the router-plugin approach, the flow is as follows.

```bash
# After installing the plugin (per the repository README)
# Add jev-model-router to the Claude Code plugin directory
# At the start of each session, Jev automatically selects the model and reasoning effort
```

If you set permissions to auto-allow, the agent handles judgment tools without asking every time. But dangerous operations like payment and deletion must always be left to human approval.

## 8. A Guide to Designing Judgment Criteria Before Attaching It as a Supervisor

You must design the criteria (rules) before attaching Jev. Without criteria, there is no judgment.

| Step | Content | Example |
|------|------|------|
| Gate definition | Pass conditions for moving to the next step | All tests pass, zero lint errors |
| Stuck definition | Loop judgment criteria | Same failure repeats 3 times, same file edited 3 times and still fails |
| Distortion definition | Fact-check criteria | Spec numbers mismatch code constants, comment claims mismatch implementation |
| Escalation | Human-call conditions | Stuck verdict twice in a row, security-related file changed |

Fix the judgment questions as typed. Do not ask them as free-form prose.

```
- Is the task state done, in progress, or stuck (one of the three)?
- Can it proceed to the next step, yes or no?
- On a probability from 0 to 1, how well does the implementation match the spec?
```

Fixing them this way makes Jev's output return in the same schema every time so the agent can parse it.

## 9. One-Line Conclusion

Generation is Claude's job, and judgment is Jev's. Once this division of labor settles, even a solo developer or a small startup will own a cross-check automation system that rivals a big-company dev team. It is the next step in development automation created by open source and the standard protocol MCP.