Jev: a model that decides instead of writes

Most AI agents spend a lot of money asking a large language model questions that have short answers. Is this email urgent? Which team owns this ticket? Is this bash command risky? You don't need an essay for those. You need a label and a number.

That's the gap TypeSafe AI built Jev for. TypeSafe calls this a System One model: "a class of AI models built to make fast, structured decisions that software can use directly." It doesn't generate text. It reads some text and answers typed questions about it.

What you send and what comes back

You send one piece of state and a set of questions. There are three question types (Choice, Score, Noul):

• Choice picks one option from a fixed set, up to 255 options. The answer has the chosen option, a probability for every option, and a confidence between 0 and 1.
• Score rates the text against 2 to 10 ordered levels. The answer has a fractional score (the probability-weighted mean of the level numbers), the probabilities, a legend and a confidence.
• Noul is yes or no. The answer is one number from 0 to 1, the probability of yes, with no separate confidence value.

One naming wrinkle: Vercel's AI SDK calls the yes/no type boolean, and Vercel's docs say its TypeSafe-compatible API accepts "noul for Boolean questions." Same type, two names. Vercel has also renamed its "evaluation" API to "decision" models, so older pages still use the old wording.

A minimal example

This is the example from the langchain-typesafe package page (version 0.0.1a3). Install it with uv add langchain-typesafe and set TYPESAFE_API_KEY.

from langchain_typesafe import Choice, Noul, Score, TypeSafeClassifier

classifier = TypeSafeClassifier()
result = classifier.invoke(
    {
        "state": "Stripe has failed to connect for three days. Help ASAP.",
        "questions": {
            "department": Choice(
                instructions="Which team should handle this?",
                criteria={
                    "billing": "Payment or subscription issues",
                    "technical": "Product or integration issues",
                },
            ),
            "urgent": Noul(instructions="Does this message express urgency?"),
            "frustration": Score(
                instructions="How frustrated does the customer appear?",
                criteria=["calm", "frustrated", "angry"],
            ),
        },
    }
)
print(result.choices["department"].choice)
print(result.nouls["urgent"].noul)
print(result.scores["frustration"].score)

Three questions go in as one call. Your code reads the typed results and branches on them. The API behind this is a single endpoint, POST https://api.typesafe.ai/v1/systemone, with a bearer key.

Where it fits in an agent

Jev doesn't replace your main model. LangChain's harness post positions it beside the LLM: the LLM does open-ended reasoning, and Jev makes the quick decisions along the way. LangChain ships two experimental middlewares for this (provider docs), both marked "may change without notice":

• ModelRouterMiddleware routes a request to a cheaper or stronger model based on criteria you define.
• AutoModeMiddleware scores tool calls, such as bash commands, for risk and blocks them before they run. Its block threshold is fixed at 0.5 in the current source. It is not a constructor argument, even though the docs mention a threshold.

Limits worth knowing

• Text in, typed answers out. Input is text only. Context is 64k tokens per request, with 32k for the state plus the longest question (models page).
• Valid doesn't mean correct. Jev can't output an invalid type, but it can still return a wrong value that fits the schema. Your code owns the policy.
• The internals are private. TypeSafe hasn't published the architecture, parameter count or training data, and an independent paper says so too. The training method is named as reinforcement learning for calibrated decisions (RLCD).
• Pricing and limits can change. The models page lists jev-1.13.0 at $0.042 per million input tokens with free output, and warns rate limits can change without notice.

How fast and cheap is it, really?

TypeSafe's headline numbers are 193.6x faster and 444.6x cheaper, which it says are on the higher end of real-world gains. Independent measurements are much lower:

• Median user reports: InfoQ cites an analysis of 12,759 launch tweets with a median 7x speedup and 30x cost saving (second-hand summary of the OpenChamber analysis).
• Leiden University paper: it measured Jev at 0.09 to 0.27 seconds per call against 0.75 to 1.04 seconds for GPT-6 Luna. At batch prices, it found no cost advantage over that model (arXiv 2610.06625).
• Calibration: that paper's Choice confidence is almost exactly a rescaling of the chosen option's probability (correlation 0.9997). Its calibration beat Luna's token probabilities but was not consistently better than Qwen's.
• Community benchmark: the ejs-5 benchmark, whose author says "We are not neutral," found Jev 5.7 to 11.8x faster and 120 to 242x cheaper than Claude Opus 5, but less accurate.
• No-reasoning comparison: a LessWrong study across 14 benchmarks, comparing against models that don't use chain-of-thought, calls Jev's capabilities "very jagged."

The honest summary: Jev is clearly faster than a general LLM on short classification, and often cheaper. The size of the gain depends heavily on what you compare against and how you price it.

When to use it

Use it for the cheap, repeated, structured decisions: triage, routing, moderation, a safety check before a tool call. Keep a stronger model for the work that needs reasoning or writing, and send low-confidence cases to it or to a human. Test it on your own data first, because accuracy varies by task.