Every AI model you've used this year does the same trick: it predicts the next word. Jev, launched on September 15, 2026 by TypeSafe AI, does something different. It doesn't write paragraphs. It makes decisions — and hands your code a typed answer it can act on immediately.
Think of it this way: an LLM writes you an answer. Jev gives you a decision, a probability, and nothing else.
What "System One" actually means
TypeSafe calls Jev a "System One model," borrowing from Daniel Kahneman's Thinking, Fast and Slow. System 1 is fast, intuitive judgment. System 2 is slow, deliberate reasoning. LLMs are System 2 machines — powerful but expensive and slow. Jev is built to automate the System 1 layer of software: route this ticket, flag this content, score this lead.
The name itself is a wink at economics. It's named after William Jevons, who in 1865 described the Jevons Paradox: when a technology makes something cheaper and faster, people do far more of it. TypeSafe's bet is that cheap, fast decisions will lead to software making far more decisions — automatically.
The three question types
Jev's entire interface is three typed questions. You define the answer space in advance, so the model can never invent an option that doesn't exist or return malformed output.
Choice — pick from a defined set. Classification and routing. "Should this support request go to billing, technical support, or sales?" You define the options and their descriptions. Keep an other option for unknown cases so the model is never forced into a bad match.
Score — rate against an ordered rubric. Severity, priority, risk. Define levels from "no action needed" to "immediate escalation" and use the probability-weighted result to sort a queue.
Noul — judge whether a statement is true. TypeSafe's word for a yes/no question, scored 0 to 1. "Is the customer explicitly asking for a refund?" returns something like 0.87 — not a paragraph explaining itself.
How the API works
The production endpoint is POST https://thejevai.com/v1/systemone. You send three things: state (the context — a ticket, a message, a JSON object), model, and questions. A minimal example:
{
"model": "jev-latest",
"state": "A customer has tried to connect Stripe for three days.",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this request?",
"criteria": {
"billing": "Payments, invoices, refunds, or payouts",
"technical": "Bugs, outages, or integration failures"
}
},
"urgent": {
"type": "noul",
"instructions": "Does this message express urgency?"
}
}
}
The response comes back keyed by your question IDs, with the selected choice or score, probabilities, and a confidence level — plus usage and elapsedMs fields. Because the shape is fixed, your code can branch on it directly: high confidence → auto-route, low confidence → send to a human. When you're debugging these structured responses, pasting the raw JSON into a free JSON formatter like Toolxz's JSON Formatter makes the nested probability fields much easier to read.
Keep your API key in a server-side environment variable. Never put it in browser code or a public repo.
Pricing and speed
This is where Jev gets interesting for production use. Input costs $0.042 per million tokens and output is free. TypeSafe made it available without a waitlist on September 21, starting at $5 in credits — roughly 120 million tokens. Published latency is 70 to 500 milliseconds, well under half a second.
Compare that to routing the same decision through a frontier LLM: slower, more expensive, and you still have to parse the output and hope the JSON didn't break. For decisions you make thousands of times a week — sorting documents, tagging tickets, picking which model should handle a task — that cost and reliability gap matters.
Where it actually fits
Support ticket routing. Send the ticket text plus customer tier as state. One Choice question picks the team, one Score question estimates urgency. The queue sorts itself; low-confidence cases go to human review.
AI agent tool gating. Before an agent deletes data, charges a card, or sends an external message, a Noul question judges whether the intent is explicit and whether the request meets policy. This is the "smart if-statement" TypeSafe talks about — a safety check that runs in milliseconds instead of another full LLM call.
Queue prioritization. Split impact, time sensitivity, and customer status into separate Score or Noul questions, then combine them into a ranking formula in your own code. When the business changes its weights, you update code — not one giant prompt.
Model routing. Classify task difficulty before choosing a fast model, a deeper model, or a human workflow. Jev decides the path; your orchestration layer still manages the actual calls.
It's already been integrated into platforms including Vercel, Cloudflare, LangChain, and Langfuse, according to press coverage of the launch.
Why not just ask an LLM for JSON?
Asking an LLM to return JSON is still a fine pattern. Jev adds value in three specific ways: the answer boundary is explicit (no inferring intent from prose), one state can feed multiple questions evaluated in parallel (no chaining separate calls), and probability signals participate in control flow (automation level changes with the signal instead of treating every output as equally safe).
Honest limitations
Jev is two weeks old. Its benchmark claims have not been independently reproduced yet, so treat vendor numbers as marketing until third parties verify them. It accepts text, JSON objects, and arrays of text — images, audio, and video are not supported as direct inputs. It doesn't define your business policy: you still choose the answer space, thresholds, and review strategy. And for high-stakes actions — payments, deletions, permission changes — a probability is a signal, not a substitute for hard rules, authorization checks, and audit logs.
It's also not a replacement for ChatGPT, Claude, or Gemini. Open-ended research, explanations, and creative work still belong with generative models. Jev is a decision layer that sits beside them.
FAQ
Is Jev AI free? There's no unlimited free tier announced; access starts at $5 in credits (about 120M tokens at current pricing). The online playground lets you test decisions before paying.
Is Jev open source? No. It's a commercial API product from TypeSafe AI.
Can Jev replace an LLM in my app? Only for the decision parts — classification, routing, scoring, safety checks. Anything requiring generated text still needs an LLM.
How is Noul different from a boolean? It returns a probability between 0 and 1 rather than a hard true/false, so your code can set thresholds based on how costly a wrong call would be.
The bigger idea here is worth watching regardless of whether Jev itself wins: as agents multiply, the industry needs a cheap, reliable way to make the thousands of small judgments agents face. "LLMs generate strings, Jev returns decisions" might just be the shape of infrastructure to come.
Sources: TypeSafe AI official site (thejevai.com); Hugging Face blog guide to Jev AI; Zapier's Jev explainer; NDTV Profit launch coverage.
Top comments (0)