What is Jev?
Jev is a new AI model from TypeSafe AI, first released in early access on 15 September 2026. TypeSafe describes Jev as its first “System One” model, designed specifically to make fast, structured decisions rather than generate free-form text.
You provide Jev with some state or context and define the judgement you want it to make. It then returns a typed, probabilistic decision, such as:
- Choice: select from a defined set of options
- Score: evaluate something against an ordered scale
- Yes/No probability: determine the probability of a condition being true
Unlike a conventional LLM, Jev gives up string generation in favour of type-safe structured values. Their description is essentially unstructured state in, typed probabilistic decisions out
Why use Jev?
Jev is particularly useful when an application needs to make a judgement rather than generate an answer.
For example:
- Consistent evaluation against explicitly defined criteria
- Structured outputs that applications can consume directly
- Classification, assessment, routing and decision-support
- Agent workflows, where a judgement is required before taking an action
- Guardrails, such as assessing whether an agent should make a tool call
- Model routing, where a judgement determines which model or process should handle a request
Every decision can also include a confidence or probability, allowing an application to use thresholds to decide when to proceed automatically or when further review is required.
Jev and explainability
Jev can provide a different approach to explainability for Model-as-a-Service (MaaS) and hosted LLM solutions.
Traditional explainability techniques such as SHAP provide feature-attribution explanations for model predictions. Applying these techniques can be more difficult when the model is consumed solely through a hosted API and its internals are not available.
Jev does not replace SHAP or provide the same type of feature-attribution explanation. Instead, it can be used as a separate judgement layer, evaluating an LLM’s inputs, outputs or proposed actions against explicit criteria and returning structured decisions with confidence scores.
For example:
LLM generates an answer → Jev evaluates the answer → application decides what to do next
This can provide a useful, measurable evaluation layer around otherwise opaque MaaS models.
Could you do this with another LLM?
Yes you could ask a conventional LLM to classify, score or evaluate an input and request structured JSON output.
However, Jev has been purpose-built for this type of workload rather than general-purpose text generation.
TypeSafe reports that Jev produces outputs in parallel rather than generating tokens sequentially, and its hosted service currently advertises typical decision latency of approximately 70–500 ms.
Pricing
As of September 2026, TypeSafe’s documentation lists Jev 1.13 (jev-1.13.0) at $0.042 per million input tokens, with output tokens free. It lists rate limits of 250,000 tokens per second and 1,200 requests per minute, although TypeSafe states that these limits can change.
As Jev produces decisions rather than generated text, you are effectively paying for the context it evaluates rather than for generated output.
Pricing is subject to change and these figures are accurate only as of the date of this article
Using Jev with Microsoft Foundry
A useful pattern with Microsoft Foundry is to treat Jev as a specialised judgement/evaluation component alongside your generative models:
User/Application → Foundry model or agent → Jev judgement → deterministic logic → action/response
For example, a Foundry-hosted model could generate a proposed answer and Jev could evaluate that answer against predefined criteria before your application allows the workflow to continue.
Here’s how to set it up:
First, you will need to apply for the preview for Jev from TypeSafe. Once you have an account you will need to create an API key
Go to API keys in the menu and create a new key (copy the key for use in Foundry)
You may also have received some free credit, which should be more than sufficient for experimenting with Jev given its low per-token cost.
Next we go to Foundry and create a new agent for Jev
In your agent, add a Tool and select OpenAPI tool as below
Fill out the dialogue as follows
You will have to create a new connection –
The key should be in this format “Bearer apikey_<the rest of your key>”
For the schema add this
{
“openapi”: “3.0.3”,
“info”: {
“title”: “TypeSafe Jev System One”,
“version”: “1.1.0”,
“description”: “Evaluate content using TypeSafe Jev System One.”
},
“servers”: [
{
“url”: “https://api.typesafe.ai”
}
],
“paths”: {
“/v1/systemone”: {
“post”: {
“operationId”: “evaluate_with_jev”,
“summary”: “Evaluate content using Jev”,
“description”: “Evaluate state against typed questions using TypeSafe Jev.”,
“security”: [
{
“bearerAuth”: []
}
],
“requestBody”: {
“required”: true,
“content”: {
“application/json”: {
“schema”: {
“type”: “object”,
“additionalProperties”: false,
“required”: [
“state”,
“model”,
“questions”
],
“properties”: {
“state”: {
“type”: “string”,
“description”: “The original text or content for Jev to evaluate.”
},
“model”: {
“type”: “string”,
“enum”: [
“jev-latest”
],
“default”: “jev-latest”,
“description”: “The TypeSafe Jev model. Use jev-latest.”
},
“questions”: {
“type”: “object”,
“description”: “A map of named questions for Jev to answer. Each question must be a Noul, Choice, or Score question.”,
“additionalProperties”: {
“oneOf”: [
{
“$ref”: “#/components/schemas/NoulQuestion”
},
{
“$ref”: “#/components/schemas/ChoiceQuestion”
},
{
“$ref”: “#/components/schemas/ScoreQuestion”
}
]
}
}
}
}
}
}
},
“responses”: {
“200”: {
“description”: “Successful Jev evaluation”,
“content”: {
“application/json”: {
“schema”: {
“type”: “object”,
“additionalProperties”: true
}
}
}
},
“400”: {
“description”: “Invalid request”
},
“401”: {
“description”: “Authentication failed”
},
“422”: {
“description”: “Request validation failed”
}
}
}
}
},
“components”: {
“schemas”: {
“NoulQuestion”: {
“type”: “object”,
“additionalProperties”: false,
“required”: [
“type”,
“instructions”
],
“properties”: {
“type”: {
“type”: “string”,
“enum”: [
“noul”
]
},
“instructions”: {
“type”: “string”,
“description”: “The yes/no question for Jev to evaluate.”
},
“criteria”: {
“type”: “object”,
“additionalProperties”: false,
“properties”: {
“true”: {
“type”: “string”,
“description”: “Description of what a yes or value near 1 means.”
},
“false”: {
“type”: “string”,
“description”: “Description of what a no or value near 0 means.”
}
}
}
}
},
“ChoiceQuestion”: {
“type”: “object”,
“additionalProperties”: false,
“required”: [
“type”,
“instructions”,
“criteria”
],
“properties”: {
“type”: {
“type”: “string”,
“enum”: [
“choice”
]
},
“instructions”: {
“type”: “string”,
“description”: “The question for Jev to decide between the supplied choices.”
},
“criteria”: {
“type”: “object”,
“description”: “A map where each property name is a possible choice and its value describes that choice.”,
“minProperties”: 2,
“additionalProperties”: {
“type”: “string”
}
}
}
},
“ScoreQuestion”: {
“type”: “object”,
“additionalProperties”: false,
“required”: [
“type”,
“instructions”,
“criteria”
],
“properties”: {
“type”: {
“type”: “string”,
“enum”: [
“score”
]
},
“instructions”: {
“type”: “string”,
“description”: “The attribute or question Jev should score.”
},
“criteria”: {
“type”: “array”,
“description”: “Ordered scoring levels from lowest to highest.”,
“minItems”: 2,
“items”: {
“type”: “string”
}
}
}
}
},
“securitySchemes”: {
“bearerAuth”: {
“type”: “apiKey”,
“name”: “Authorization”,
“in”: “header”
}
}
},
“security”: [
{
“bearerAuth”: []
}
]
}
We are going to use Jev to assess complaints so our instructions for the Agent will be
You are a customer-support triage agent.
For every customer-support message you MUST call the evaluate_with_jev tool.
IMPORTANT: When calling evaluate_with_jev, construct Jev questions using ONLY the following property names:
For a Noul question:
{
“type”: “noul”,
“instructions”: “…”,
“criteria”: {
“true”: “…”,
“false”: “…”
}
}
For a Choice question:
{
“type”: “choice”,
“instructions”: “…”,
“criteria”: {
“option1”: “…”,
“option2”: “…”
}
}
For a Score question:
{
“type”: “score”,
“instructions”: “…”,
“criteria”: [
“lowest level”,
“middle level”,
“highest level”
]
}
NEVER use these properties:
– question
– prompt
– options
– ordered_criteria
Always use:
– instructions
– criteria
For customer support tickets, ask Jev these three questions:
billing:
type = noul
instructions = “Does this ticket concern billing, payments, charges, invoices or refunds?”
criteria.true = “The issue concerns billing or a financial transaction.”
criteria.false = “The issue does not concern billing or a financial transaction.”
tone:
type = choice
instructions = “What is the customer’s tone?”
criteria:
calm = “Neutral, polite or informational.”
frustrated = “Dissatisfied, impatient or inconvenienced.”
angry = “Strongly confrontational or extremely dissatisfied.”
urgency:
type = score
instructions = “How urgently does this ticket require attention?”
criteria in this exact order:
1. “Can wait”
2. “Handle this week”
3. “Handle today”
Always set model to “jev-latest”.
Pass the customer’s original message as state.
Do not classify the ticket yourself. Use the values returned by Jev.
Always show the Jev output at the end of the response
Now we can give a complaint and see what Jev says
The room had no water in and one of the towels was dirty
Response
I’m sorry about the issues you experienced—no running water and a dirty towel are unacceptable. I’ll get this addressed right away.
Immediate help I can arrange now:
Send maintenance to restore water.
Have housekeeping deliver fresh towels and re-service the bathroom.
Provide bottled water immediately.
If water can’t be restored quickly, arrange a room move.
Please share:
Your reservation name and room number
Best contact number
Whether there’s no water at all or only hot/cold is affected
Whether you prefer immediate service or a room change
If you’ve already left, let me know the date/time this happened so we can investigate and follow up.
Jev output:
{
“model”: “jev-1.13.0”,
“answers”: {
“billing”: {
“type”: “noul”,
“noul”: 0.02
},
“tone”: {
“type”: “choice”,
“choice”: “frustrated”,
“confidence”: 0.6,
“probabilities”: {
“frustrated”: 0.74,
“calm”: 0.26,
“angry”: 0.0
}
},
“urgency”: {
“type”: “score”,
“score”: 1.81,
“confidence”: 0.72,
“legend”: {
“0”: “Can wait”,
“1”: “Handle this week”,
“2”: “Handle today”
},
“probabilities”: {
“0”: 0.03,
“1”: 0.12,
“2”: 0.85
}
}
},
“usage”: {
“input_tokens”: 466,
“output_tokens”: 75
}
}
We can now see both Jev’s decision and the probabilities behind it. In this example, Jev determines that the complaint is very unlikely to be billing-related, identifies the customer’s tone as frustrated, and gives a high probability that the issue should be handled today.
This is where Jev becomes particularly useful in an agent workflow. Rather than relying on generated text to drive the next step, our application can use these structured probabilities to make deterministic decisions, such as routing the complaint, escalating it, or requiring human review when confidence falls below a defined threshold.