What Is Jev? TypeSafe AI's Decision Model and How Developers Use It

Introduction: An AI Model That Cannot Write

For the past few years, the AI race has been dominated by large language models (LLMs) that keep getting better at chatting, writing and reasoning. On 15 September 2026, TypeSafe AI went the other way and released Jev — an AI model that does not generate text at all. Jev does one thing: it makes decisions.

Jev was built by Diogo Almeida, a researcher who previously helped develop the methods behind ChatGPT (RLHF and InstructGPT) at OpenAI. After two years in stealth, TypeSafe emerged with a US$40M seed round led by DCVC. In this article we cover what Jev is, how it works, the latest updates, and how far developers have taken it in its first week.

What Are Jev and "System One Models"?

TypeSafe calls Jev its first System One Model. The name comes from Daniel Kahneman's Thinking, Fast and Slow: System 1 is fast, intuitive thinking, while System 2 is slow and deliberate. Jev is designed for the fast kind of decision, such as "which team should get this ticket?" or "is this message urgent?".

The name "Jev" references the Jevons paradox. In 1865, William Stanley Jevons argued that as steam engines used coal more efficiently, Britain would burn more coal, not less. The same logic applies here: when an AI decision becomes dramatically cheaper, software starts making far more of them.

The simplest mental model is a "smart if statement". Ordinary code branches on values it can compute, like if (order.total > 100). It falls apart when the condition is a judgment about meaning, such as "is this email about billing?". That is where Jev fits.

How It Works: State, Questions and Typed Answers

Every Jev call has two parts: the state (the text or data to judge) and the questions about that state. There are three question types, and a single call can mix them:

All questions are answered in parallel against the same state, so adding questions barely changes response time. Here is a request to the POST https://api.typesafe.ai/v1/systemone endpoint, taken from the official docs:

{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions"
      }
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

The response contains the chosen option (for example technical), the probability of each option, and a confidence score. Confidence is the number your code acts on: automate the confident answers and send the uncertain ones to a person or a larger model. One common gotcha: question IDs such as is_urgent never reach the model, so the full question must live in the instructions field.

Specs, Pricing and Performance Claims

According to TypeSafe's documentation, the current model is Jev 1.13 (jev-1.13.0), and the jev-latest alias points to it.

In TypeSafe's internal workflow evals, Jev scored 67.8% accuracy — level with Sonnet 5 — at about US$0.0004 per case versus US$0.1174 for Sonnet 5, and 0.4 seconds versus 78.1 seconds. There is an important caveat: the reference answers in these evals come from two large reasoning models, not from humans. So 67.8% measures agreement with those models. TypeSafe itself acknowledges possible bias, and the evals have not yet been independently reproduced.

As for the "cannot hallucinate" claim, it is narrower than it sounds: Jev can never return a value outside the schema you define (no broken JSON, no invented fields), but it can still pick the wrong valid option.

Latest Updates and Ecosystem

Because Jev is only a week old, the ecosystem is moving fast:

• Early access: access is still waitlisted at typesafe.ai, with API keys issued from the TypeSafe console.
• Official SDKs: available for Python (pip install typesafe-sdk) and JavaScript/TypeScript (@typesafe-ai/sdk).
• Agent skill: TypeSafe ships a skill for coding agents such as Claude Code, so an agent can learn the Jev API directly.
• Third-party integrations: Jev can be called through Vercel AI Gateway, and LangChain exposes it via TypeSafeClassifier.
• "Jaggedness" docs: TypeSafe openly publishes the weaknesses of jev-1.13, including unreliable counting, poor date comparison, and accuracy loss when the state is padded with irrelevant material.

How Far Has Adoption Gone?

The community directory Made with Jev (independent and not affiliated with TypeSafe) counted 295 public builds in the first 6 days, from 269 different authors. The median reported cost is US$0.000068 per decision — about 14,727 decisions per dollar — with a median latency of 300 ms. Interestingly, 58.1% of new repositories are TypeScript or JavaScript versus 30.6% Python, meaning early adoption is being driven by web developers rather than machine learning researchers.

Builds by use case:

Some of the most talked-about examples:

• Ultrafast browser agent: Browser Use built an open-source agent that searched Zürich–London flights on Google Flights in about 7 seconds for less than a cent. Its repository is the most popular Jev project, with more than 9,000 GitHub stars.
• Classifying 1,018 research papers: the 1kpapers project summarised papers with an LLM (US$3.99), then classified them with Jev for just US$0.08.
• Jev plays Doom: a real-time demo running at roughly 10 queries per second, costing about US$7 per hour.
• Instant compaction: Jev scores every tool call in an agent's history and drops the irrelevant ones, replacing a slow summarisation prompt.
• Robotics and trading: from an autonomous drone that uses Jev as an advisory tactical layer (while code always owns safety) to a market-making bot that decides on every block.

The pattern behind these builds now has a name — "Jev Engineering": an LLM writes, Jev decides, and code acts.

Keep in mind that these figures are self-reported by their authors. Only 140 of the 295 builds publish any figure at all, and accuracy data is almost entirely missing. Six days is also far too short to call a trend.

Why It Matters for Website Owners and Online Businesses

For people who run websites, Jev opens up automation that used to be too expensive with LLMs: sorting contact-form messages, moderating comments and spam, flagging urgent support tickets, and scoring leads. Here is a simple illustration of calling Jev from Laravel using the built-in HTTP client:

use Illuminate\Support\Facades\Http;

$response = Http::withToken(config('services.typesafe.key'))
    ->post('https://api.typesafe.ai/v1/systemone', [
        'model' => 'jev-1.13.0',
        'state' => $request->input('message'),
        'questions' => [
            'department' => [
                'type' => 'choice',
                'instructions' => 'Which team should handle this message',
                'criteria' => [
                    'billing'   => 'Payment, invoice or renewal issues',
                    'technical' => 'Website down, errors, DNS or email problems',
                    'sales'     => 'Pricing or new website project questions',
                    'other'     => 'Anything else',
                ],
            ],
            'is_urgent' => [
                'type' => 'noul',
                'instructions' => 'The message conveys urgency or time-sensitivity',
            ],
        ],
    ]);

$answer = $response->json('answers.department');

Practical tips from the docs and the community: include an other option so the model does not force a bad fit, pin the model version once you have tuned thresholds, and treat user-supplied content in the state as a potential manipulation risk.

When Jev Is Not the Right Tool

Jev does not replace an LLM. It cannot write articles, summarise, generate code or explain its reasoning. It is also a poor fit for arithmetic, counting, date comparison and decisions that require several dependent reasoning steps. Input is currently text only — images, audio and video must be transcribed or captioned first.

Conclusion

Jev offers a fresh perspective: not every AI task needs a model that talks well. For small, repeated decisions — classification, routing, scoring and guardrails — a model that is fast, cheap and returns calibrated confidence can be far more practical. Its first-week adoption has been remarkably fast, but its performance claims still come from TypeSafe itself. The smartest move is to test it on your own data, measure the accuracy, and then decide where Jev deserves a place in your application architecture.

References

• Made with Jev — What is Jev?
• TypeSafe AI — Introducing System One Models & Jev
• TypeSafe Docs — Quick start
• Made with Jev — The Jev Build Report
• DEV Community — How to Use Jev: A practical guide
• LangChain Blog — Building a harness with Jev
• Vercel — What is Jev?