How to use Jev, the AI model built for decisions instead of conversations

Picture 1,700 unsorted emails sitting in an inbox. A human would need hours to triage them. A frontier chatbot could do it too, but it would take minutes and cost real money in tokens. Now picture the same 1,700 emails sorted, scored, and routed in a few minutes for a total bill of 18 cents. That's not a hypothetical — it's what a new model called Jev was built to do, and it's forcing a lot of developers to rethink what "using AI" even means.

Jev isn't a chatbot. It doesn't write essays, debug your code, or hold a conversation. It does exactly one thing: it looks at a piece of information and picks an answer from a list you give it, along with a probability for how confident it is. That narrow focus turns out to be a big deal, because most of what businesses actually need from AI isn't creativity — it's judgment calls, made over and over, at scale.

What exactly is Jev?

Jev comes from TypeSafe AI, a San Francisco lab that came out of stealth on September 15, 2026 with $40 million in seed funding, calling it a System One model — a new class of model built to make fast decisions inside software rather than to chat with people. The company was founded in 2024 by former OpenAI researcher Diogo Almeida, along with Erik Gafni and Sasha Sheng. Almeida isn't a random founder chasing a trend — he's a co-author of the InstructGPT paper, which formed an important basis for ChatGPT.

The name itself is a clue to the philosophy. The model is named after William Stanley Jevons, the 19th-century economist whose eponymous paradox describes how the falling cost of a commodity can lead to it being used more and more — in this case, the falling cost of intelligence should lead to its widespread deployment.

You can think about it through the lens of a well-known idea from psychology. System 1 is fast, intuitive thinking, while System 2 is slow, deliberate reasoning — and Jev automates the fast, repetitive decisions that software makes millions of times a day, leaving slow reasoning to humans or LLMs.

The official site, jevai.net, sums up the pitch bluntly: Jev is the first System One Model — a new class of AI built for machines, not conversations. Unstructured state goes in, type-safe probabilistic decisions come out, with no tokens generated, no hallucinations, and calibrated answers in 70–500 milliseconds.

How is that different from just asking ChatGPT to classify something?

You could absolutely ask a regular LLM to sort emails or score leads. Plenty of people already do. But there's a structural mismatch between how those models work and what classification actually requires.

Traditional autoregressive models generate tokens sequentially, so producing a long answer requires a sequence of model operations. That's fine for writing a paragraph. It's overkill for answering "is this email urgent, yes or no."

Jev throws out that generation step entirely. You supply three things — the state (the data to evaluate), the question (what decision to make), and the choices (the valid outputs) — and Jev returns the top choice, a probability distribution across all choices, and a confidence score. There's no risk of the model going off the rails because it never generates free-form text, and parallel sampling generates all outputs in a single query.

That single design choice solves two problems developers have complained about with LLM classification for years. First, speed — the company reports up to 200x faster inference and 400x lower cost than comparable LLMs on classification tasks. Second, and arguably more important, is calibration. Standard LLMs are notoriously overconfident even when you explicitly prompt them for a probability, and if a model can classify something correctly 95% of the time but can't tell you which 5% it's unsure about, you can't safely automate around it. Jev's calibration lets you set a confidence threshold and only auto-act above it, routing the uncertain cases to a human or a slower LLM.

What kinds of questions can you actually ask it?

Instead of generating a written response, Jev answers one of three question types: choice (pick from a list of options you supply), score (rate something on a scale you define), or null (return a probability that a yes/no statement is true).

That's a small toolkit, but it maps onto a surprising number of real business problems:

• Support ticket routing — making cheap, quick judgments like which team should handle a support ticket, whether a refund was requested, or whether a message is urgent, so application code can act on the result immediately.
• Lead scoring — running a "score" question against incoming form submissions to rank them before a sales rep ever sees them.
• Agent guardrails — checking whether an AI agent's own claims match what actually happened. In one documented test, a simulated agent audit found tool results explicitly said a save operation had failed due to denied permissions, but the agent's own final message claimed the draft had saved successfully — Jev correctly classified the task as failed and assigned a 93% probability that the success claim was unsupported by the evidence.
• Model routing — deciding which model should even handle a request. Model routing is another potential use for Jev, predicting whether a given workload requires a specific model, since using an LLM for that job would be expensive but Jev's low cost and speed make that kind of real-time sorting possible.

How much does it actually cost to run?

This is where the numbers get almost absurd compared to normal LLM pricing. Input costs $0.042 per million tokens. Every answer ships with an epistemically honest probability, and output tokens are free — too cheap to meter.

Independent testers have backed up the cost claims. One analysis found running roughly 10 queries per second was estimated to cost about $7 per hour, with individual classification calls in testing costing fractions of a cent, such as 0.0014 of a cent per sentiment score. A developer at Bryo AI ran a head-to-head test against Gemini for classifying business emails and found Gemini was slightly more accurate, but 10 to 20 times more expensive. What stood out to him more than the price gap was the confidence scores — calling it the only one that hands back a real probability, which makes it ideal for automating workflows.

How do you get started building with it?

The primary way in is TypeSafe's own API and documentation, available through typesafe.ai. It's reachable through TypeSafe's HTTP API at POST https://api.typesafe.ai/v1/systemone using the model route jev-latest, with official Python and JavaScript SDKs.

A basic request looks like this against the public endpoint described on jevai.net:

POST /v1/decide
{
  "input": "Customer says their order never arrived after 3 weeks.",
  "schema": { "route": "string", "score": "number" }
}

Which returns something like a routing label and a confidence-backed score, ready to plug directly into your application logic without any parsing step.

If you're already building with LangChain, there's a more integrated path. The LangChain integration exposes Jev through TypeSafeClassifier — you pass your state and questions to .invoke(), and get classification results rather than a chat response. Getting it running is a matter of a couple of commands: install langchain-typesafe and set your TYPESAFE_API_KEY, then make a call using a TypeSafeClassifier instance with a state string and a questions dictionary. Full setup details live on LangChain's Jev integration guide.

For a broader technical walkthrough of the API's schema options and SDK setup, DataCamp's breakdown of System One models is worth bookmarking, and it points out something important: for the full schema reference and SDK setup, TypeSafe's own docs are the source of truth.

Where does Jev fall short?

It's not a universal upgrade. Jev is useless for open-ended generation, and it doesn't write the schema for you. You need to know, ahead of time, exactly what the valid answers look like. The obvious caveat is that this only works when the space of valid answers is bounded and known up front.

It also won't explain itself. The limitation worth flagging is that Jev gives you a number, not a rationale — there's no natural-language explanation attached to the decision. If your workflow needs a "why," you're back to pairing it with a real LLM.

On raw accuracy, it's competitive but not dominant. On TypeSafe's 4-workflow benchmark, Jev scores 67.8% accuracy, roughly tied with GPT-5.6 Terra (67.9%) and a few points below GPT-5.6 Sol (74.1%) and Opus 5 (73.1%). The trade-off is that you're getting that accuracy at a tiny fraction of the latency and cost — which for high-volume, low-stakes decisions, is usually the right trade to make.

What's the actual business opportunity here?

This is the part worth sitting with if you're building anything right now. Every business has some expensive, slow queue of incoming information — support tickets, leads, applications, transaction logs, video footage — that currently gets triaged by a human, or not triaged at all. TypeSafe's own stated use cases include AI-powered workflows and "smart if-statements" — classify, route, score, extract, or branch inside ordinary software — plus map-reduce over large corpora and real-time applications where roughly 100 ms latency is acceptable.

If you can put a fast, cheap, calibrated decision-maker at the front of one of those queues, you've effectively built a filter that was previously too expensive to run at scale. That's not a flashy AI feature — it's boring infrastructure. But boring infrastructure that turns a $10-per-decision human process into a $0.0001-per-decision automated one tends to make for a pretty good business.

The models that get the headlines are the ones that write, reason, and chat. But somewhere underneath every one of those flashy products is a pile of small, repetitive judgment calls that nobody wants to pay a premium to make. Jev is a bet that whoever builds the plumbing for those calls — not the chatbot on top — ends up owning the more durable part of the stack.