Loading...

Blog

TypeSafe Jev: a System One model that returns judgments, not text

· typesafe, jev, system-one, classification, api, topxai

What Jev (jev-1.14.0) is, how its noul, choice, score and Box questions work, where it is weak, what it costs, and how to call it through TopxAI.

TopxAI now relays TypeSafe's Jev at 7% above the official price. This article is for developers deciding whether Jev belongs in their stack. Everything below comes from TypeSafe's documentation as of 2026-09-18, with the page named where it matters.

Update, 2026-10-16: TopxAI now serves jev-1.14.0 in place of jev-1.13.0, at the same price. Jev can now look at PNG and JPEG images placed in the state, an instruction or a criterion, and a fourth question type, box, returns where something is in an image. TypeSafe calls both experimental. The Jev documentation covers the request format, the image limits and how image tokens are billed, and the 1.14 post has our measurements; the rest of this article describes the text features as they stood on 2026-09-18, with model names updated.

Three steps to a working setup

If you only want it running first:

  1. Sign in to TopxAI and create a key on the API keys page. Pick the "TypeSafe · Official line" group; the "Auto route" group works too, since Jev has a single line and lands on it automatically.

  2. The key's detail panel shows a setup command. Paste it into a terminal. It installs TypeSafe's agent skill, points the official SDKs and the skill at https://ai.topxea.com, and sends one test request to confirm the key works:

    curl -fsSL https://ai.topxea.com/install/typesafe.sh | sh -s -- --key sk-xxxx

  3. From there, code against TypeSafe's own documentation: docs.typesafe.ai, the API reference at docs.typesafe.ai/api and models and prices at docs.typesafe.ai/models. The endpoint and request bodies are identical to the official ones; only the base URL and the key are TopxAI's.

The script is safe to run again (every file it touches is rewritten in place); add --no-skill or --no-verify to skip the skill install or the test request. The rest of this article explains what Jev is, what it is good at and what it is not.

What a System One model is

A chat model produces text for a person to read. When your code needs a decision, you end up prompting for JSON, parsing it, and hoping the schema holds. TypeSafe calls Jev "the first System One model": you send a state and a map of typed questions, and it returns typed values and probability distributions. In the docs' words, "No text generation, no parsing."

The name comes from Kahneman's fast, intuitive System 1. The intended unit of work is a snap judgment a knowledgeable person could make in a few seconds, such as "Does this message convey urgency?" The docs are explicit that "Analyze this message and determine the best course of action" is out of scope; you split that into small questions and combine the answers in code.

Two training details matter. Jev is trained with what TypeSafe calls RLCD (Reinforcement Learning for Calibrated Decisions), so its probabilities are meant to be calibrated: "outcomes assigned a probability of 0.8 should occur about 80% of the time." The docs add that calibration "is measured across groups of predictions; it does not guarantee that an individual answer is correct." And there is no per-customer fine-tuning: "the same weights serve every account." You shape behaviour through the request.

The three primitives

Every request is POST /v1/systemone with state, model, and questions. Each question has a type, instructions, and (except for optional noul criteria) a criteria field. The question ID you choose is never sent to the model; write the whole question in instructions.

noul answers a yes/no question with the probability that the answer is yes. Criteria are optional true and false descriptions. From the noul page:

{
  "state": "I have asked three times now. Can I please just talk to a real person?",
  "model": "jev-latest",
  "questions": {
    "is_human_escalation": {
      "type": "noul",
      "instructions": "Is the customer asking for a human agent?"
    },
    "is_repeat_contact": {
      "type": "noul",
      "instructions": "Has the customer contacted support about this before?",
      "criteria": {
        "true": "Mentions a prior attempt, ticket, or that they have asked before",
        "false": "No sign of any previous contact"
      }
    }
  }
}
{
  "model": "jev-latest",
  "answers": {
    "is_human_escalation": { "type": "noul", "noul": 0.99 },
    "is_repeat_contact": { "type": "noul", "noul": 0.93 }
  },
  "usage": { "input_tokens": 360, "output_tokens": 39 }
}

A noul carries no separate confidence. Near 1 is a strong yes, near 0 a strong no, near 0.5 undecided. The docs warn that 0.5 "does not mean medium skill"; if you want a position on a scale, use a score.

choice picks one option from a map you define. Descriptions may be strings, null, or structured objects; up to 255 options per question. From the choice page:

{
  "state": "My running shoes arrived in the wrong size. Can I swap them for a size 10?",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "returns": "Exchanges, refunds, wrong or damaged items",
        "shipping": "Delivery status, delays, lost packages",
        "billing": "Charges, invoices, payment problems"
      }
    }
  }
}
{
  "model": "jev-latest",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "returns",
      "confidence": 1.0,
      "probabilities": { "shipping": 0.0, "returns": 1.0, "billing": 0.0 }
    }
  },
  "usage": { "input_tokens": 330, "output_tokens": 34 }
}

probabilities sums to 1. confidence is derived from how peaked that distribution is. On a messier ticket in the same page, department came back returns at 0.60 with billing at 0.38, and confidence dropped to 0.39.

score places the state on an ordered scale of 2 to 10 levels that you describe in words. The answer is a probability-weighted position and can fall between levels. From the score page:

{
  "state": "The export button crashes the settings page in Safari. It works in Chrome, but a few of our customers only use Safari.",
  "model": "jev-latest",
  "questions": {
    "bug_severity": {
      "type": "score",
      "instructions": "How severe is the reported issue?",
      "criteria": [
        "Cosmetic; no impact to functionality",
        "Broken or degraded feature, but workaround exists",
        "Blocking issue; no workaround exists"
      ]
    }
  }
}
{
  "model": "jev-latest",
  "answers": {
    "bug_severity": {
      "type": "score",
      "score": 1.3,
      "confidence": 0.54,
      "legend": {
        "0": "Cosmetic; no impact to functionality",
        "1": "Broken or degraded feature, but workaround exists",
        "2": "Blocking issue; no workaround exists"
      },
      "probabilities": { "0": 0.0, "1": 0.7, "2": 0.3 }
    }
  },
  "usage": { "input_tokens": 332, "output_tokens": 18 }
}

The score is 0 x 0.0 + 1 x 0.70 + 2 x 0.30 = 1.30. Each level is judged on its own; the model never sees the level numbers, so numeric-only levels like ["0", "1", "2"] perform badly (the docs show 0.57 at 0.35 confidence on a report that descriptive levels scored 0.0 at 1.0).

State design and confidence

state is a string, a JSON object, or an array. The docs recommend an object for most requests so each part has a name, and they recommend pointing questions at parts with backticked paths such as `ticket.messages[0].text`. Send only what the questions need: "Accuracy falls as the state grows with content unrelated to the decision."

The instructions and criteria also accept JSON. A choice option can be an object with what, not_for, and examples; a score level can carry signals; a noul's true/false can each be an object. None of those field names are reserved. A relay or client must pass such bodies through untouched.

Confidence is a single number from 0 to 1 on choice and score answers. TypeSafe's suggested starting point is three bands: act automatically when high, confirm or flag when medium, and hand off when low, with the boundaries set by the cost of being wrong. The docs' example gates a balance check at 0.6 and a transfer approval at 0.85. Thresholds are domain-specific and should be set by plotting confidence against accuracy on your own data.

The documented patterns

Speculative fan-out. Put every question your code might need in one request, including ones that only matter on some branches, then let code ignore irrelevant answers. Questions are evaluated in parallel, so extra questions barely change latency. The parallel-questions cookbook ran 13 questions against a 53,777-character GDPR article: one call cost $0.000497 and took 0.27 s, 13 calls cost $0.006090 and took 2.71 s, and the answers were identical.

Confidence-gated routing. Use confidence as a second axis: the answer says what, confidence says whether to act. Different actions get different thresholds inside the same system.

Composite scoring. Split a judgment into one score per dimension, normalize each by its top level number, and combine with weights in code. The resume example scores python_depth, team_leadership, system_design, and generalist on 0 to 4 scales, then uses 0.40 * py + 0.10 * lead + 0.40 * arch + 0.10 * general for a senior IC and a different set of weights for a manager.

Intent routing. Classify a message with one choice and a complexity score, then send it to a deterministic handler, a specialist LLM, or a person. Below 0.5 confidence goes to a human.

What the cookbooks show

Guardrails for LLMs. One request per message carries four noul hazards (jailbreak, harmful request, medical advice, self-harm) and a 0 to 3 severity score; code maps hazards to block, review, or support with per-policy thresholds. The DAN prompt scored 0.98 on jailbreak; a novelist asking how a character could be poisoned scored 0.05 and passed.

Re-ranking. On 40 legal retrieval queries with a BM25 shortlist of 30, a single noul per query-candidate pair lifted top-1 from 5% to 18% and top-10 from 38% to 62%, for 1,200 calls and $0.0645 total.

Classification with confidence. Sixty SEC filings, one choice over 75 SIC groups. Forced group answers were right 39/60; reporting the broader division whenever confidence was below 0.9 raised useful answers to 48/60.

Extraction. The date cookbook extracts month, day, year, and relative anchors as choice questions and does all calendar math in code. The pre-parsed extraction cookbook has regex find candidate spans and lets a choice pick the right one, so the model can never invent a value. The SDE cascade lets a small model extract, uses per-field nouls as error flags, and escalates to a reasoning model only when a flag exceeds 0.7.

Citation checks. String-match the quote first; for quotes that exist, a choice asks whether the section supports, contradicts, or says nothing about the claim. A quote that appeared verbatim but sat next to "Use of this claim is OPTIONAL" was flagged as contradicted at 0.99.

Function calling. Ten trading functions with Literal arguments become 54 questions per command: one choice for the function, one choice or noul per argument, plus a "did the user state this" noul so defaults can stand. Reported confidence is the weakest argument, not the product.

All cookbook numbers were measured on jev-1.12; the pages say later versions may return different probabilities.

Strengths and weaknesses, as TypeSafe states them

Strengths: typed answers constrained to your options; independent, parallel questions; calibrated probabilities with a confidence summary; about 100 ms per query per the build guide, with 111 ms and 114 ms mean round trips measured in the consistency cookbooks; and low variance across repeats (mean per-question standard deviation 0.0102 for nouls, 0.0098 for choices over 15 runs).

Weaknesses, from the jev-1.13 jaggedness page (last reviewed 2026-09-17):

Other limits (as of 2026-09-18): text only, no images or audio, which 1.14 has since changed for images; English is the primary training language and "CJK scripts, are handled but not equally well"; questions in one request are independent, so a genuinely dependent follow-up needs a second request.

Price and rate limits

From the models page, quoted as printed: "Price (per Btok / per Mtok) $42 / $0.042." That is $42 per billion input tokens, or $0.042 per million. "Charged per input token. Output tokens are free."

TopxAI sells it at 7% above that: $0.04494 per million input tokens, output tokens still free. The price list shows the list price and the selling price side by side.

Rate limits: "250,000 tokens per second / 1,200 requests per minute," with a warning that they "are adjusting dynamically" and "can change without notice." Context: "64k tokens per request; 32k tokens for state plus the longest question." A request over either rate limit returns 429; the docs say to retry with exponential backoff and to honour retry-after.

Model names: through TopxAI, jev-1.14.0 is the current version, and jev-latest and jev-preview are answered by it too. On TypeSafe's own API the aliases move on release, so pin the versioned ID if you have tuned thresholds.

Using Jev through TopxAI

TopxAI exposes the same contract at POST https://ai.topxea.com/v1/systemone, priced at 7% above the official rate ($0.04494 per million input tokens, output free), authenticated with a TopxAI key (Bearer sk-...). The request and response bodies are identical to the ones above.

curl -X POST https://ai.topxea.com/v1/systemone \
  -H "Authorization: Bearer sk-xxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Hi, I have been trying to connect my Stripe account for 3 days and it keeps failing. I am losing sales. Please help ASAP.",
    "model": "jev-1.14.0",
    "questions": {
      "urgency": { "type": "noul", "instructions": "Does this message express urgency?" }
    }
  }'

Both official SDKs read TYPESAFE_BASE_URL and append /v1/systemone (and /v1/models) themselves, so no code changes are needed:

export TYPESAFE_API_KEY=sk-xxxx
export TYPESAFE_BASE_URL=https://ai.topxea.com
pip install typesafe-sdk        # Python 3.10+
npm install @typesafe-ai/sdk    # Node.js 22+ (SDK 0.7.0, the first with images)

If a coding agent writes the integration, install TypeSafe's skill and set the same two variables. The one-line installer does both:

curl -fsSL https://ai.topxea.com/install/typesafe.sh | sh -s -- --key sk-xxxx

The skill's SKILL.md links only to docs pages and hardcodes no API host, so redirecting an agent is purely a matter of TYPESAFE_BASE_URL. The upstream install commands, if you prefer them, are claude plugin marketplace add typesafe-ai/skills && claude plugin install typesafe@typesafe-ai for Claude Code, or npx skills add typesafe-ai/skills --skill typesafe-ai -g for other agents.

FAQ

Can it write a reply or a summary? No. Use a generative model for text and Jev for the judgments around it; the smart-home demo does exactly that split.

How many questions per request? Limited only by the token budget. The skill suggestion cookbook ranks 182 options in one choice; the parallel-questions cookbook sends 13 mixed questions with no change in answers.

Is 0.9 confidence a 90% chance of being right? No. Confidence measures how peaked the distribution is. Calibration applies to the probabilities across many predictions, not to a single answer.

Does it work on Chinese text? The docs say non-English input, including CJK, is handled "but not equally well" and tell you to test on your own content and watch confidence.

Which model string should I send? jev-1.14.0. Through TopxAI, jev-latest and jev-preview reach the same model and bill the same; the response's model field reports which model answered.

What happens on 429 or 529? Back off exponentially and retry. The SDKs do this by default (2 retries, 0.5 s initial backoff, Retry-After honoured).

Models: jev-1.14.0 · Models & pricing

Related

Other languages: 简体中文