JEV and System One models

What JEV is

Jev is TypeSafe AI’s first model, released in early access in September 2026. It is not an LLM: instead of generating text token by token, it takes a state (the context) and a list of questions you define, and returns typed answers with probabilities. The company sums it up as “a frontier-intelligence function call”.

The name is not an acronym: it honors the economist William Stanley Jevons, of the Jevons paradox (when something gets cheaper to use, total consumption goes up). The bet is that cheap, fast AI decisions will show up in places where nobody would call an LLM today.

Why “System One”?

The category comes from the two modes of thinking Daniel Kahneman describes in Thinking, Fast and Slow:

The idea is not to replace the LLM, but to take away the small decisions it makes all the time.

The problem: the agent loop

An agent runs in a loop, and each turn usually involves several micro-decisions: which model to use, whether a tool is dangerous, whether the request is urgent, whether the task is done. When each one becomes an LLM call, the loop gets slow and expensive, and you still have to parse a string that may come back in the wrong format.

The highlighted diamonds are System One decisions: closed questions with predictable answers. That is where JEV fits; the rectangle in the middle is still LLM work.

How it works

You define the possible outputs before the call. The model can only answer within them, so type errors (broken JSON, an invented label) disappear by construction.

What changes under the hood, according to TypeSafe:

• Parallel sampling: all answers come out of a single pass instead of a sequence of tokens. That is why adding questions barely increases response time.
• RLCD training (Reinforcement Learning for Calibrated Decisions): training aims for calibrated probabilities, meaning 0.9 should mean “right 9 times out of 10”. See the note on calibration.

The three question types

Example: the raw call

{
  "model": "jev-latest",
  "state": "I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales, please help ASAP.",
  "questions": {
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency"
    }
  }
}

The response has one value per question, plus the exact model version and token usage:

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 0.999 }
  }
}

The endpoint is POST https://api.typesafe.ai/v1/systemone, with the key in the Authorization header. There are SDKs for Python (typesafe-sdk) and TypeScript (@typesafe-ai/sdk).

In practice: deciding, and knowing when not to

The real gain is not just speed: it is being able to read the confidence and send doubtful cases to whoever decides better (a bigger LLM or a person).

With the LangChain integration (pip install langchain-typesafe and the TYPESAFE_API_KEY variable):

from langchain_typesafe import Choice, Score, TypeSafeClassifier

classifier = TypeSafeClassifier()
CONFIDENCE_THRESHOLD = 0.85


def route_ticket(text: str) -> str:
    response = classifier.invoke({
        "state": text,
        "questions": {
            "team": Choice(
                instructions="Which team should handle this ticket?",
                criteria={
                    "infra": "Deploys, availability and incidents.",
                    "billing": "Payments, invoices and subscriptions.",
                },
            ),
            "severity": Score(
                instructions="What is the impact on the customer?",
                criteria=["Cosmetic.", "Degraded for some users.", "Full outage."],
            ),
        },
    })

    team = response.choices["team"]
    if team.confidence < CONFIDENCE_THRESHOLD:
        return "human-triage"
    if response.scores["severity"].score >= 2:
        return f"{team.choice}-oncall"
    return team.choice

Both questions share the same state and are evaluated in the same request.

Where it fits in the harness

The harness is all the code around the model: the loop, the tools, the middlewares. The langchain-typesafe package ships two ready-made middlewares (still under experimental, installed with langchain-typesafe[experimental]):

Model routing: JEV reads the latest user request and picks the cheapest model that can handle it.

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import ModelChoice, ModelRouterMiddleware

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(model="openai:gpt-5.6-terra", criteria="Direct lookups, extraction and localized changes."),
        "powerful": ModelChoice(model="openai:gpt-6-astra", criteria="Architecture, novel root causes and high-stakes decisions."),
    },
    instructions="Choose the least costly model that can complete the task safely.",
)

agent = create_agent("openai:gpt-5.6-terra", middleware=[router])

Auto Mode (tool guardrail): before running a listed tool, JEV judges whether the call is risky. If it is, the tool does not run and the agent gets an error instead.

from langchain_typesafe.experimental.middleware import AutoModeMiddleware

# delete_all_backups is a regular @tool, defined earlier
agent = create_agent("openai:gpt-6-astra", tools=[delete_all_backups], middleware=[AutoModeMiddleware(tools=[delete_all_backups])])

For other decisions (triage, “is the task done?”), you can write your own middleware that calls TypeSafeClassifier in a hook such as before_agent and stores the answer in the agent state.

Limits and healthy skepticism

Almost every launch number comes from TypeSafe itself, and the company lists the biases: tests ran from laptops, the workflows were built by its own team, and the reference answers came from OpenAI and Anthropic models.

Practical constraints:

• 32k-token context.
• Up to 255 options per question; above that it uses a slower two-stage process.
• Closed API, with no published weights and no on-premise option. Access through a waitlist on the TypeSafe console or through Cloudflare Workers AI (typesafe/jev).

When to use it (and when not)

Rule of thumb: LLM to reason and write, JEV for the decisions along the way, always with a confidence threshold and an escape route.

Videos

• JEV Breakdown: The First AI Model Built For Code (Rob Shocks, 10 min): a playground demo of the three question types and an honest discussion of the numbers (the video embedded at the top).
• Pydantic is all you need (Jason Liu, AI Engineer Summit 2023): the earlier context of structured outputs with LLMs, which JEV takes to the extreme.

References

• Introducing System One Models & Jev: the official announcement, with the authors’ caveats.
• Building a harness with Jev: LangChain’s post with the middlewares.
• TypeSafe: quickstart and LangChain integration.
• TypeSafe Jev review and What “System One Models” actually are: external analyses (both companies sell competing or complementary products, keep that in mind).