Skip to content

Introduction

Jev is TypeSafe's flagship model and the first System One model. Send state and typed questions; get structured answers your code can use directly.

Jev 是 TypeSafe 的旗舰模型，是第一个 System One 模型。 目标是 提供严格的结构化决策结果，让 业务 code 能够直接使用。

Large language models (LLMs) are designed to produce text for humans to read. When you need a model to make a judgment that your code will consume, that creates a mismatch: you are coercing a text-generation system into outputting structured decisions, then parsing the results back into something your code can depend on.

通用的 LLM，输出的是 文本结果，方便人来阅读；当需要跟代码程序结合时，需要经历 LLM -> txt -> 解析出结构化信息 -> 业务代码。

Jev is TypeSafe's flagship model and the first System One model. System One models are built to make fast, structured decisions that software can use directly. Jev evaluates typed questions against a state and returns structured results directly. No text generation, no parsing. You get typed values and probability distributions that your code can branch on, sort by, and route with. Choice and Score also return confidence, which your code can use to decide whether and how to act on an answer.

System One 来源于 思考的快与慢 中，是指，不需要经过深刻思考、分析推理，能够快速决策的系统。 Jev 下有 3 个概念：State、questions、structured result。不会生成文本、也无需解析文本来得到结构化结果。

Tips： 心理学家丹尼尔·卡尼曼（Daniel Kahneman）的著作《思考，快与慢》（Thinking, Fast and Slow）中的双系统理论，人类的思维方式概括为两个系统，

  • System One：快速、直觉式判断
  • System Two：缓慢、审慎的分析
%%{init: {"fontFamily": "Inter, sans-serif", "flowchart": {"rankSpacing": 35, "wrappingWidth": 300, "subGraphTitleMargin": {"top": 12, "bottom": 12}}}}%%
flowchart LR
    input["state + questions"]

    subgraph model["TypeSafe AI model"]
        evaluate["evaluate each question<br/>against the state<br/>in parallel"]
    end

    input -- "one request" --> model
    model -- "one response" --> answers["typed answers<br/>+ probabilities<br/>+ confidence<br/>(Choice and Score)"]
    answers --> code["<b>your code</b><br/>branch, sort, and route"]

TypeSafe primitives

TypeSafe exposes three AI primitives. Similar to software primitives, our AI primitives are modular, composable, structured, reliable, and fast. Each asks a different type of question and returns a different type of answer.

TypeSafe 定义了 3 类 AI 元语/原语，即，最小粒度的能力定义。

Question type Goal Returns
Choice Choose an option from a list choice, probabilities, confidence
Score Score the state on a rubric score, probabilities, confidence
Noul Is this statement true? noul (0–1)

All three question types can be mixed in a single API call. Every question is evaluated in parallel and in isolation against the same state in one go. Adding questions barely changes the response time. Each question is evaluated independently, so adding more questions does not create context-rot.

一次 API 调用中，可以发送多个 question，这些 question 会被 并行 且 相互隔离 处理，但是，会共享 State 上下文。

Atomic questions, composed in code

System One models work best when each question asks one specific, well-scoped thing. Think of each question as a gut-check determination: the kind of judgment a highly knowledgeable person could make in a few seconds given the right context.

If the question you want to ask would require extended reasoning or weighs multiple independent factors, decompose it. Ask each factor as a separate question, then combine the results with logic in your code. This keeps each individual evaluation reliable and gives you full control over how dimensions are weighted.

For example, instead of "rate this startup pitch," ask separately about market size, technical feasibility, and differentiation. Combine the scores with your own formula. When priorities shift, change a coefficient in your code rather than rewriting a prompt.

Next steps

  • Quick Start — Everything you need to get started immediately.
  • AI Primer — Why TypeSafe trains models for calibrated decisions instead of generated text.
  • Primitives (Questions) — How to define questions, choose between Choice, Score, and Noul, and ask several at once.
  • Confidence — How TypeSafe reports certainty, and how to use it architecturally.
  • Patterns — Common patterns for building systems with TypeSafe.