What Is Jev AI? A Working Guide to the Judgment Model API

In September 2026, TypeSafe AI released Jev, the first model in its “System One” line. The pitch is unusual on purpose: Jev does not chat. It answers questions that have a bounded answer space — judgment questions, choice questions and scoring questions — and returns a structured answer with a confidence score. If most of your LLM calls end with you parsing a paragraph to extract a yes/no, this guide explains what the Jev model is, how its output is shaped, and when it is the right tool.

TL;DR: Jev AI is a judgment model by TypeSafe AI, not a chat model. It specializes in three question primitives — judgment (yes/no/unclear), choice (pick one option) and scoring (a number on a scale) — and returns JSON with an answer, a confidence score and a rationale. It is accessed like a normal LLM through OpenRouter’s OpenAI-compatible endpoint, which makes it easy to drop into existing pipelines.

What Jev is — and what it is not

The fastest way to understand the Jev model is to draw a hard line around it.

Jev is:

• A specialized judgment model designed for bounded questions: is this X, which of these is Y, how good is Z on a scale.
• A model that returns a structured answer: an answer field, a confidence score and a rationale explaining the call.
• Accessible through OpenAI-compatible channels — the main demo channel is OpenRouter, so you can call it with the same request shape you already use.

Jev is not:

• A chatbot. It will not hold a conversation, role-play or draft your blog posts.
• A replacement for a general-purpose LLM. Long-form generation, summarization and multi-turn dialogue belong to chat models.
• A magic accuracy boost. It moves the shape of the interaction from prose to structured judgment; the quality of your question design still matters.

The problem Jev is actually solving

Most LLM pipelines eventually have a classification step buried inside them. You send a support ticket to GPT-4 with a system prompt that says “classify this as billing, technical or other.” The model returns a sentence. You extract the category with a regex or another prompt. If the text is ambiguous, the model hedges and you lose a clean parse.

That is the specific friction Jev was built to remove. The model produces a deterministic output shape regardless of input variability. You define the question type and the answer space upfront; the model commits to one of those slots. There is no paragraph to parse. The answer field is always a valid value from the set you defined.

This matters especially at pipeline scale. When you are running fifty thousand classification calls a day, a 2% parse failure rate is a thousand items a day that fall into a manual queue. Tighter output structure means lower operational overhead — not because the model is smarter, but because its answer is machine-readable by design.

The broader framing: Jev sits in the space of constrained decision-making, not language generation. A chat model is a good tool when you want the model to construct an answer. Jev is a good tool when you want the model to select an answer from a known space. These are not the same cognitive task, and the right tool depends on which one you actually need.

The three primitives: prompt, schema, state

Every Jev call is built from three elements. Understanding what each one does prevents the most common configuration errors.

Prompt is the question text you send in the user message. Unlike a chat system prompt, it encodes both the question type and the context. “Judgment question: does this comment contain spam? Comment: {text}” is a complete prompt — it tells the model what kind of answer to produce (judgment) and what to evaluate (the comment). The phrasing of the primitive type at the start of the message is how Jev knows which output format to use.

Schema is the answer space you implicitly or explicitly define. For judgment questions the schema is fixed (yes / no / unclear). For choice questions you enumerate the valid options in the prompt text. For scoring questions you specify the scale bounds. The model will not produce an answer outside that schema — that is the structural guarantee Jev is built around.

State refers to any contextual data you pass alongside the question. This is just the content of your user message beyond the question itself — the comment text, the ticket body, the resume excerpt. Jev does not maintain conversation history between calls. Each call is stateless, which makes horizontal scaling straightforward and makes the model’s behavior easier to audit. See the state and questions guide for patterns on multi-step evaluations that require chaining calls.

A minimal working example combining all three, using a choice question:

import json, os, requests

ticket_body = "My invoice shows the wrong amount and I need a refund."

resp = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"},
    json={
        "model": "typesafe/jev-1.13",
        "messages": [{
            "role": "user",
            "content": (
                f"Choice question: which team should own this support ticket? "
                f"Options: billing, technical, returns. "
                f"Ticket: \"{ticket_body}\""
            ),
        }],
    },
    timeout=30,
)
result = json.loads(resp.json()["choices"][0]["message"]["content"])
# result["answer"] is one of: "billing", "technical", "returns"
# result["confidence"] is a float 0–1

The answer field will be exactly one of the three strings you enumerated. No post-processing needed.

The three primitives at a glance

Every Jev call maps to one of three question primitives. This is the core mental model of the jev ai API surface.

Three details worth noticing:

1. Judgment answers are three-valued. unclear is a real answer, not an error. It gives you a natural bucket for “I need a human” routing.
2. Choice answers are constrained. If you enumerate the options in the question, the answer comes back as one of them — which makes downstream code trivial.
3. Scoring answers carry their scale. The scale field in the response fixture makes the range explicit, so a “7” is never ambiguous about whether it was out of 10 or 100.

The shape of a real API call: request, response, error fields

Because the main demo channel is OpenRouter, you call Jev through the standard chat completions endpoint. Here is a minimal curl for a judgment question:

# Confirm the exact model slug on the OpenRouter model page
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "typesafe/jev-1.13",
    "messages": [
      {
        "role": "user",
        "content": "Judgment question: does this comment contain spam? Comment: \"Buy followers now at cheap-bots.example\""
      }
    ]
  }'

The request uses the ordinary OpenAI-compatible body — model id plus a user message. The judgment lives in how the question is phrased; confirm the exact model slug on the OpenRouter model page before shipping.

The parsed answer looks like this — example fixture, confirm exact field names in the official documentation:

{
  "answer": "yes",
  "confidence": 0.97,
  "rationale": "The comment promotes a third-party follower-selling service and contains an unrelated link."
}

What to check when something goes wrong. If the call returns an HTTP error, the OpenRouter envelope has the detail in the standard error key at the top level. If the call succeeds but the parsed answer is unexpected, look at the rationale field first — it is the model’s chain of reasoning and usually points at the problem in the question phrasing. A low confidence score combined with an answer you did not expect is almost always caused by an ambiguous question rather than a model failure. The troubleshooting guide covers the most common patterns.

In Python the round trip is equally short:

import json, os, requests

resp = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"},
    json={
        # Confirm the exact model slug on the OpenRouter model page
        "model": "typesafe/jev-1.13",
        "messages": [{"role": "user", "content": "Judgment question: does this comment contain spam? Comment: \"Buy followers now at cheap-bots.example\""}],
    },
    timeout=30,
)
payload = resp.json()
result = json.loads(payload["choices"][0]["message"]["content"])
print(result["answer"], result["confidence"])

The outer payload is the standard OpenAI-compatible envelope; the inner result is an example fixture — the response shape shown here is illustrative, and the official field names should be confirmed against the official API documentation on typesafe.ai.

When you should not use Jev AI

Jev is a sharp tool with a narrow purpose. Using it outside that purpose does not produce a graceful degradation — it produces wrong answers or malformed responses that fail quietly.

Do not use Jev for open-ended writing tasks. If the outcome of the call is a paragraph of text — a draft, a summary, an explanation, a reply — that is a language generation task. Jev is not built for it. A general-purpose LLM will produce a more useful output and cost you no more per call for that kind of work.

Do not use Jev when you cannot define the answer space. The model needs a bounded schema to commit to. If your question is “what should we do about this situation?”, there is no finite set of answers to constrain against. The question needs to be reformulated — broken into specific judgment or choice sub-questions — before Jev can help. If you find yourself unable to enumerate the options in one sentence, the task probably belongs to a chat model.

Do not use Jev for creative or divergent tasks. Brainstorming, ideation, multi-angle exploration and anything that benefits from the model ranging freely across possibilities are the opposite of what Jev optimizes for. The model is built to converge to a single answer quickly; it is not built to explore.

Do not use Jev as a replacement for a reasoning step. If the decision requires synthesizing information the model has not been given — drawing on world knowledge, applying domain expertise, or making a judgment that depends on unstated context — you will get a confident-sounding wrong answer. Jev is best when the context is fully contained in the prompt.

Cost and latency: the rough shape of the difference

Exact pricing changes over time and depends on the channel, so treat the figures below as order-of-magnitude guidance rather than a price sheet. Confirm current rates on the OpenRouter model page before building a cost model.

The pattern that holds across channel and version: Jev calls are cheaper and faster than equivalent GPT-4 class calls for classification tasks. The gap is roughly:

The latency difference matters most when you are chaining calls. A content moderation pipeline that runs three Jev calls in sequence — is it spam, is it toxic, which category does it belong to — can still complete in under a second end-to-end. The same pipeline with a GPT-4 class model at each step takes several seconds per item.

The cost difference matters most at volume. At fifty thousand daily classifications, even a 2× cost reduction is significant. The structural trade-off is that Jev handles only bounded questions. When the task fits, the cost profile is favorable; when it does not, you need a different tool regardless of cost. For a detailed breakdown with numbers, see the cost and latency guide.

How Jev and LLM-as-a-judge divide the work

LLM-as-a-judge is a common evaluation pattern where a capable chat model scores or critiques model outputs. It is useful but expensive — a GPT-4 class judge call costs roughly the same as a generation call. When your evaluation pipeline runs at any meaningful volume, the cost of judgment becomes comparable to the cost of generation.

Jev is a natural complement for the screening layer. The practical split:

Jev handles the first pass. A confidence-scored classification call that takes 150 ms and costs a fraction of a cent can eliminate the clear cases — obvious spam, unambiguous policy violations, clearly out-of-scope tickets — before any expensive judge is involved. At 80% clear-case rate, you are running the LLM judge on 20% of the traffic for roughly the same quality outcome.

LLM-as-a-judge handles the nuanced cases. When the Jev confidence score falls below your threshold — say, below 0.75 — or when the judgment returns unclear, that is the signal to escalate to a more capable but more expensive evaluation. The judge sees only the items that actually need deep reasoning.

This two-tier pattern is covered in detail in the Jev vs LLM-as-a-judge guide. The short version: Jev is not a replacement for LLM-based evaluation. It is a cost filter that makes LLM-based evaluation sustainable at scale.

Where Jev fits — and where it does not

Good fits, based on the three primitives:

• Content moderation: spam detection, toxicity checks, policy-violation flags on every comment or post.
• Support routing: classify an inbound ticket into one of your teams (a choice question), then judge whether it is actionable.
• Screening and scoring: rate resumes, answers or leads on a fixed scale before a human looks at them.
• Evaluation gates: score model outputs or RAG answers as part of a pipeline.

Poor fits:

• Drafting content, writing code or producing long analysis — use a chat model.
• Open-ended conversations where the user expects dialogue.
• Questions where you cannot enumerate the answer space or the scale. If you cannot state the bounded options, Jev has nothing to anchor on.

If you are weighing Jev against a general chat model for one of these jobs, the head-to-head in our Jev vs LLMs guide breaks down the trade-offs, and the three-primitives guide goes deeper on question design. For a working end-to-end example of the moderation use case, see the spam comment detection case.

This guide applies to Jev 1.13.