A model that answers, but never writes

System 1, not System 2

The name borrows Daniel Kahneman’s split between System 1 (fast, intuitive, automatic: “is this email spam?”, “is this customer angry?”) and System 2 (slow, deliberate, step-by-step). A large language model is a System 2 machine: it reasons token by token and hands you a paragraph that your code then has to parse and trust.

A System One model gives up text generation entirely. The input is a state (a string, a JSON object or an array, such as a chat transcript) plus a map of typed questions. Every question is evaluated against the state in parallel, in one call, and the output is a typed value per question together with a probability distribution over the answer space you defined. Because the answer space is fixed up front, the model cannot invent an option, and because every answer comes with a probability, your code can branch on “how sure”, not just “what”.

TypeSafe pitches Jev as the first model of this class and describes it as calibrated: higher reported confidence should mean higher accuracy, and similar inputs should get similar answers. That is a vendor claim; the playground shows you the numbers per call so you can judge on your own data.

Three question types

Every question has an instructions string and a type. The type decides what the criteria look like and what comes back. Question ids are yours; answers come back under the same ids.

TypeSafe’s advice is to keep each question atomic: one specific, well-scoped thing that a knowledgeable person could answer in a few seconds. If a judgment needs reasoning, split it into factors, ask each as its own question, and combine the answers in code.

Patterns TypeSafe recommends

The playground’s ticket-triage scenario is a fan-out: five questions in one call, including “if this is a bug, how severe?”. The playground shows every answer; an app would read the severity only when the category came back as bug. The docs go further with composite scoring, intent routing and self-consistency checks; see docs.typesafe.ai.

Pricing and vendor claims

Prices, latency and calibration figures above are TypeSafe’s own statements from its announcement post and docs, as of 2026-09-20. This site is an independent playground and has not benchmarked them; treat them as vendor claims. Providers other than TypeSafe may charge differently.

Three ways to call it

The playground talks to Jev through three providers, and the snippets below are trimmed straight from its adapter code. The same request works everywhere; only model ids, the noul spelling and usage field names differ.

The request

{
  "state": "Support issued a full refund of $42.50 to the customer and closed the ticket.",
  "questions": {
    "refunded": { "type": "noul", "instructions": "Has the refund been completed?" },
    "category": {
      "type": "choice",
      "instructions": "Main category of this ticket",
      "criteria": { "billing": "Charges, payments or refunds", "bug": "Product failure", "other": null }
    },
    "urgency": {
      "type": "score",
      "instructions": "How urgent is this for the customer",
      "criteria": ["low: can wait", "medium: this week", "high: right now"]
    }
  }
}

import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({ apiKey });
const d = await client.alpha.decisions.create({
  decisionsRequest: { model: 'typesafe/jev-1.13', state, questions }
});
// d.answers · d.usage.inputTokens · d.model · d.id · d.provider

import { experimental_evaluate as evaluate } from 'ai';
import { createGateway } from '@ai-sdk/gateway';

const gateway = createGateway({ apiKey });
const r = await evaluate({
  model: gateway.evaluationModel('typesafe-ai/jev'),
  state,
  questions // noul is spelled { type: 'boolean', ... } in the AI SDK
});
// r.answers.refunded → { type: 'boolean', probability: 0.97 }
// r.providerMetadata.typesafe.confidence → { category: 0.91, urgency: 0.62 }
// r.usage.inputTokens · r.response.modelId

const res = await fetch('https://api.typesafe.ai/v1/systemone', {
  method: 'POST',
  headers: { authorization: `Bearer ${apiKey}`, 'content-type': 'application/json' },
  body: JSON.stringify({ model: 'jev-latest', state, questions })
});
const d = await res.json();
// d.answers · d.usage.input_tokens (snake_case here) · d.model

The response, normalized

OpenRouter and TypeSafe return this shape natively (TypeSafe with input_tokens); the playground maps the AI SDK’s boolean / probability and providerMetadata.typesafe.confidence onto it. Values are illustrative.

{
  "answers": {
    "refunded": { "type": "noul", "noul": 0.97 },
    "category": {
      "type": "choice", "choice": "billing",
      "probabilities": { "billing": 0.94, "bug": 0.02, "other": 0.04 },
      "confidence": 0.91
    },
    "urgency": {
      "type": "score", "score": 0.31,
      "probabilities": { "0": 0.72, "1": 0.25, "2": 0.03 },
      "legend": { "0": "low: can wait", "1": "medium: this week", "2": "high: right now" },
      "confidence": 0.62
    }
  },
  "usage": { "inputTokens": 118, "outputTokens": 0 },
  "model": "typesafe/jev-1.13"
}

When to use it, and when not to

Try it in one minute

1. Get a key from OpenRouter, Vercel AI Gateway or TypeSafe.
2. Open the playground, pick the provider in the top bar and paste the key. It stays in your browser’s localStorage and is forwarded per request; this site never stores it.
3. Pick a scenario, swap the state with one of the variants, hit Evaluate, and watch the probabilities move.