Jev on Viorant: what it is, why an MCP, and how to call it

We put Jev on Viorant this week. Any MCP client can call it, your Viorant account is the sign-in, and a new account gets up to 25M Jev tokens free, as a launch offer for the first 1,000 users. I want to explain what Jev is, why we shipped it as an MCP server and not as a model in our catalog, and how to call it. I will also compare it with the other ways you can get to Jev today, because there are several and they are not the same thing.

Part 1. What Jev is

Jev is a model from TypeSafe AI, in early access since 15 September 2026. TypeSafe calls it a System One model. The short definition: you send it a state and a set of typed questions, and it returns an answer per question with a calibrated probability. It does not generate text. It cannot.

I spent twenty years building production systems for millions of daily users, from payment to auth. Most of the logic in those systems is decisions: is this transaction risky, does this login look like the account owner, which queue does this dispute go to. We had models for some of it, rules for the rest, and the models gave us a number we could put a threshold on. When LLMs arrived, agents started making the same kind of decisions by prompting a chat model and parsing a sentence. That works, but it is the wrong tool. Jev is the right one.

The request shape

One endpoint, one body. A state (text or JSON, the thing to be judged) and a questions map. Each question is one of three types.

{
  "model": "jev-latest",
  "state": "Customer emailed twice this week about a failed refund. Second email is in capitals.",
  "questions": {
    "department": { "type": "choice", "options": ["billing", "technical", "sales"] },
    "is_urgent":  { "type": "noul",   "instructions": "The message conveys urgency" },
    "frustration": { "type": "score",  "levels": ["calm", "annoyed", "angry"] }
  }
}

• Choice picks one option from a list of up to 255. You get the pick, a probability per option, and a confidence.
• Score places the state on an ordered scale of 2 to 10 levels you describe in words. You get a probability per level and an expected score, which can land between two levels.
• Noul is a yes or no. You get one probability between 0 and 1.

All questions in a call are evaluated against one read of the state, in one pass, in parallel. Adding a tenth question costs you tokens, not another round trip. TypeSafe publishes 70 to 500 ms per call, a 64k token context (32k for the state), and training by what they call RLCD, reinforcement learning for calibrated decisions. Calibrated means a 0.9 should be right about nine times in ten. That is the property that makes the number usable as a threshold.

What that changes

There are no output tokens. You pay for what you send and nothing on the way back. TypeSafe lists Jev at USD 0.042 per million input tokens, output free.

The answer is already typed. A float, an option id, a level. No JSON mode, no retry when the model wraps its answer in a sentence, no regex over a completion. The schema you asked for is the schema you get, because the model cannot produce anything else.

And the limit, said plainly: Jev writes nothing. It will not explain its answer, draft a reply or summarise a page. If you need text, you still need a chat model. Jev sits next to it and handles the decisions around the text.

What people run it for

• Routing. Pick the cheapest model that can handle a turn. Community routers do this today in front of Claude Code, Codex and Pi.
• Verified cascades. A small model answers, Jev checks the answer against the context, only the failures go to the large model.
• Triage. Score a ticket for urgency, frustration or risk against your own rubric. Escalate above the line.
• Runtime gates. Screen a fetched page or a tool result for prompt injection before the agent reads it. Block an action whose probability of being right is under your bar.
• Claim checks. Verify a draft’s claims against evidence and get a verdict per claim before it ships.

On Viorant the server exposes the three primitives as tools (jev_noul, jev_choice, jev_score) and three tools we built on top of them: jev_verify (claims against evidence, a verdict per claim), jev_screen (prompt injection, substance, and relevance if you state the task) and jev_find (rank candidates against a plain-language query, no embeddings).

Part 2. Why an MCP server, and not a model

Viorant has a model layer. Every .vio declares the models it uses, Helix resolves them at deploy time, Sentinel meters them. The obvious move was to add Jev there, next to Claude and GPT, and let agents pick it as a provider. Adi and I looked at it for about a day and said no. Four reasons.

Jev is not a model you prompt. A provider slot in a .vio takes messages and returns text. Jev takes state and typed questions and returns probabilities. Pushing it through a chat-shaped provider would have meant inventing a fake message format on the way in and parsing a fake completion on the way out. The point of Jev is that nothing needs parsing. A tool call already has the right shape: arguments in, a structured result out.

A tool is what an agent calls mid-run. Routing, screening and verification happen between two other steps, often several times per run. That is a tool call, not a model switch. Declared as a connector, the agent calls jev_verify the same way it calls a search tool or a database, and the result lands in the same loop.

A connector reaches every client. A provider reaches ours. If Jev were a Viorant provider, only agents running through Helix could use it. As a remote MCP server with OAuth it works from Claude Code, Cursor, Codex, VS Code, Windsurf, Gemini CLI and anything else that speaks the protocol. Your agent does not have to run on Viorant to use it. You need a Viorant account, nothing more.

The connector path already does what Jev needs. Connectors are declared in the .vio, resolved and checked by Helix, signed with the artifact, metered by Sentinel. Jev drops into that path with no new code on our side for identity, billing or audit. Sign-in is the OAuth flow every other connector uses, tokens draw from the same credit balance, the call shows in the run record. A second billing and identity path for one model would have been a worse product and more code to maintain.

So Jev behaves like a tool, and we shipped it as one.

Compared with the other ways to call Jev

You can reach Jev through at least five doors today. I use the comparison below when people ask me why they would go through us.

Two things stand out when I read that table.

Four of the five doors give you the raw primitives and leave the harness to you. You write the Worker or the route handler, you build the verify prompt, you define the screening questions, you parse the response envelope (each gateway nests it differently, and one of them renames Noul). That is fine if Jev is going into a backend you control. It is a lot of glue if what you want is for an agent in Claude Code to check a claim before it merges.

The other four are also a second account and a second bill next to your agent. On Viorant it is the same account, the same credits and the same statement as the rest of your deployment, and for a .vio agent the dependency is written in the file and signed with it. An auditor reading the run record sees that Jev was called, with what, and what came back.

Where we lose: if you already run on Cloudflare or Vercel and you want the raw model in your own code with no MCP in between, their gateway is one line and you should use it. We host Jev for agents, not for backends.

Part 3. How to use it

The server is at https://jev.viorant.io/mcp. It is a standard remote MCP server with OAuth. Whatever client you use, the flow is the same: point it at that URL, sign in with your Viorant account when the browser opens, done. No separate Jev account, no API key to paste anywhere.

If you do not have a Viorant account yet, sign up here. It takes a minute and comes with 2,500 credits, enough for up to 25M Jev tokens (a launch offer for the first 1,000 users).

1. Viorant Hub

Hub is our desktop app (Mac and Windows). Download it here. In Hub, open Connectors, choose Add connector, paste https://jev.viorant.io/mcp on the MCP URL tab, name it Jev and sign in. Every agent you build in Hub can now call the six Jev tools, and the Assistant knows they exist when it helps you write the agent.

2. Viorant CLI

Install the CLI first:

curl -fsSL https://dl.viorant.ai/cli/install.sh | sh

(Installation options for other platforms are on the CLI page.)

Then declare Jev in the requires block of your agent.vio:

requires:
  - connector: https://jev.viorant.io/mcp
    scopes: []
    auth: oauth
    kind: connector
    tools:
      - jev_verify
      - jev_screen
      - jev_find
      - jev_noul
      - jev_choice
      - jev_score

Deploy and sign in once:

vio deploy .
vio connect <deployment-id>

vio docs agents prints this recipe if you would rather paste it. After vio connect, the agent calls Jev mid-run like any other connector, and every call shows in the run record. This is the path I use. The Jev dependency is in the file, the file is signed, and the deployment carries it to whatever target you deploy to.

3. Claude Code

claude mcp add --transport http jev https://jev.viorant.io/mcp

Then /mcp, Authenticate for jev, sign in. The six tools appear in the tool list.

4. Everything else

Cursor, VS Code, Windsurf and Gemini CLI take a one-line entry in their MCP settings with the same URL. Codex is codex mcp add jev --url https://jev.viorant.io/mcp then codex mcp login jev. The exact snippets per client are on the Jev page and in the docs. Any client that supports a remote HTTP MCP server with OAuth connects the same way.

A worked example: check a release note before it merges

The setup. A coding agent drafts release notes from a PR. Notes are cheap to draft and expensive to get wrong, because a customer reads “ships in 1.0” and plans around it. Before the note merges, the agent calls jev_verify with the note’s claims and the changelog as evidence.

The call:

{
  "tool": "jev_verify",
  "arguments": {
    "claims": [
      "Bulk export ships in 1.0",
      "The export runs as a background job",
      "Exports are limited to 50,000 rows"
    ],
    "evidence": "CHANGELOG 1.0\n- Bulk export (CSV, JSON). Runs as a background job; the user is emailed a link when the file is ready.\n- Export cap raised from 10,000 to 100,000 rows.\n- Fixed: timezone drift in scheduled reports."
  }
}

Under the hood the tool turns each claim into a Choice question over verified, contradicted, unsupported against the evidence as state, and sends them in one call. The result:

{
  "results": [
    { "claim": "Bulk export ships in 1.0", "verdict": "verified", "confidence": 0.97 },
    { "claim": "The export runs as a background job", "verdict": "verified", "confidence": 0.95 },
    { "claim": "Exports are limited to 50,000 rows", "verdict": "contradicted", "confidence": 0.93 }
  ],
  "usage": { "input_tokens": 148, "credits_remaining": 2497 }
}

The agent’s rule is one line: any claim contradicted above 0.8, or unsupported above 0.6, blocks the merge and sends the draft back with the failing claim quoted. Here the third claim fails. The agent rewrites it to “100,000 rows”, calls jev_verify again, gets three verified, merges.

Cost: 148 input tokens, about 0.015 credits, and nothing on the way out because Jev returned no text. The same check through a chat model is a prompt, a completion, and a parser for the completion, and the “confidence” is whatever the model felt like writing.

The same pattern runs the other jobs. Swap jev_verify for jev_screen and the evidence for a fetched page, and the rule becomes “skip any page flagged for injection”. Swap it for jev_choice with your model list as options, and the rule becomes “run this turn on the chosen model”. The threshold always lives in your code, which is where I want it.

Cost, and where to start

100 credits per 1M Jev input tokens, from the same Viorant balance as Helix, Sentinel and everything else. A new account starts with 2,500 free credits, enough for up to 25M Jev tokens, as a launch offer for the first 1,000 users. Jev tokens are always charged; the free credits cover them until they run out, then you top up like any other usage.

The fastest way to try it: sign up, install the Hub or the CLI, add https://jev.viorant.io/mcp, sign in, and call jev_verify on something you were about to ship. If a claim comes back contradicted, you have found the use case.

Connection steps and limits are in the documentation. If something does not work, tell me on Discord; I read it.

Browse more reporting in AI Infrastructure Field Notes.

Vivien