AI Jev Explained: System One Model & RLCD (2026 Guide)
What is AI Jev? Learn how the System One Model makes typed AI decisions, what RLCD (Reinforcement Learning for Calibrated Decisions) is, and try Jev online free on iajev.
Most AI models are built to talk. AI Jev is built to decide.
If you have ever asked a chatbot to "just return one of these four labels" and gotten back a paragraph, a malformed JSON object, or a slow and expensive answer, you already understand the problem Jev is designed to solve. Jev is the first public System One Model: a new class of AI that takes context in and returns a typed decision with probabilities and a confidence score. It does not generate free-form text.
In this guide you'll learn:
- what AI Jev is and where it came from,
- what a System One Model is, and how it differs from System Two reasoning models,
- what RLCD (Reinforcement Learning for Calibrated Decisions) is, and how it compares with RLHF and RLVR,
- where Jev shines, where it breaks, and how to try Jev online in minutes.
Want to see it before you read about it? Paste a real support ticket, review, or user message and watch Jev pick an answer with probabilities.
TL;DR: AI Jev in 30 seconds
| Question | Short answer |
|---|---|
| What is Jev? | A decision model from TypeSafe AI, launched September 2026. It returns typed answers, not text. |
| What is a System One Model? | A model built for fast, bounded judgments inside software, such as classification, routing, and scoring. |
| What is RLCD? | Reinforcement Learning for Calibrated Decisions. It trains the model so that its probabilities match how often it is actually right. |
| Is it a ChatGPT replacement? | No. It complements LLMs. Jev decides, and an LLM writes when writing is needed. |
| How can I try it? | Use the free preview in the iajev Playground, then scale with the iajev API. |
What Is AI Jev?
AI Jev (often searched as Jev AI or the Jev model) is the first public model from TypeSafe AI, a San Francisco lab that emerged from stealth on September 15, 2026. Its founder, Diogo Almeida, previously worked at OpenAI and is one of the co-inventors of RLHF, the training technique behind ChatGPT.
The idea behind Jev is simple to state:
Most decisions inside software are small, fast judgments. Examples include "Which team gets this ticket?", "Is this review negative?", and "Which tool should the agent call?" We have been paying slow, expensive chat models to make them.
Jev takes a state (your context) and a question with defined outcomes. It returns:
- the selected answer (always one of the options you defined),
- a probability for every option,
- a confidence score you can use to decide whether to act automatically or escalate to a human.
One developer described it as a "smart if statement." Normal code can branch on order.total > 100. Jev lets code branch on judgments like "is this customer about to cancel?"
Where the name comes from: Jev is a nod to economist William Stanley Jevons and the Jevons paradox. When a resource becomes cheaper to use, people find far more ways to use it. The bet is that when a decision costs a fraction of a cent, you'll put intelligent decisions everywhere.
What Is a System One Model?
The term System One Model borrows from Daniel Kahneman's Thinking, Fast and Slow:
- System 1 is fast, intuitive, automatic judgment.
- System 2 is slow, deliberate, step-by-step reasoning.
Today's frontier LLMs and reasoning models are optimized for System 2 work: open-ended answers, code, long analysis. A System One Model is optimized for the opposite end: fast, bounded decisions over outcomes you define in advance.
| System One Model (Jev) | System Two / Chat LLM | |
|---|---|---|
| Output | Typed decision + probabilities | Free-form text (or JSON generated token by token) |
| Speed | Built for sub-second decisions | Seconds, sometimes much longer |
| Output shape | Always one of your defined options | Can drift, add prose, or fail to parse |
| Uncertainty signal | Probabilities + confidence, trained for calibration | Self-reported, not guaranteed calibrated |
| Best for | Classification, routing, triage, scoring, verification | Writing, coding, summarizing, multi-step reasoning |
| Can it write text? | No | Yes |
The key insight is that these are complements, not competitors. A well-designed AI system uses a System One Model for the many small decisions and saves the expensive System Two model for the tasks that truly need reasoning or writing.
How Jev produces a decision
Instead of generating an answer one token at a time, Jev evaluates your context against the options and returns a probability distribution in a single pass. TypeSafe says multiple questions against the same context can be answered in parallel. Two practical consequences follow:
- The answer can't fall outside your options. If you ask Jev to pick from
Billing / Technical / Sales / Fraud, it cannot invent a fifth category or return broken output. Note what this does and doesn't mean: the format is guaranteed, but the decision can still be wrong. That's why probabilities and confidence matter. - Latency is low. TypeSafe reports end-to-end latency in the tens to hundreds of milliseconds. Treat vendor numbers as a starting point, and measure on your own workload.
Jev's decision types: Choice, Score, and Noul
Jev defines three question primitives:
- Choice: pick one option from a list (e.g., which team should handle this ticket?).
- Score: a position on a described scale (e.g., bug severity from cosmetic to blocking).
- Noul: a yes/no probability (e.g., does this message ask for a refund?).
On iajev today: we expose Choice, with 2–8 candidate answers per question. Need a yes/no decision? Use two text choices like
Yes / NoorApprove / Reject.
Try a Choice decision right now Our ready-made tools come with the question and choices already set. Just bring your context.
Classify a Support Ticket · Detect User Intent · Pick an Agent Tool
What Is RLCD? Reinforcement Learning for Calibrated Decisions
RLCD stands for Reinforcement Learning for Calibrated Decisions. It is the training method TypeSafe introduced with Jev, and it is what makes Jev's probabilities useful rather than decorative.
What "calibrated" actually means
A model is well calibrated when its stated probabilities match reality across many predictions. Among all the answers a calibrated model gives 90% probability to, about 90% should turn out correct. The same holds for 60%, 30%, and every other level.
Calibration is a property of many predictions, not one. A calibrated model can still get a single high-confidence answer wrong. What calibration gives you is a probability you can build business rules on, like "auto-approve above 0.9, send to review below 0.5."
RLCD vs RLHF vs RLVR
These three acronyms describe different training objectives:
| Method | Full name | What it rewards | Typical result |
|---|---|---|---|
| RLHF | Reinforcement Learning from Human Feedback | Answers human raters prefer | Helpful, fluent chat responses |
| RLVR | Reinforcement Learning with Verifiable Rewards | Outputs a program can check (tests pass, math is right) | Stronger coding and math reasoning |
| RLCD | Reinforcement Learning for Calibrated Decisions | Probabilities that match how often decisions are correct | Honest uncertainty on structured decisions |
Here is the simple way to remember it:
- RLHF optimizes for what people like to read.
- RLVR optimizes for what a checker can verify.
- RLCD optimizes for knowing how sure to be.
For automation, that last property is often the one that matters most. A chatbot that sounds confident and is wrong 20% of the time is a problem. A decision model that says "I'm only 55% sure" lets your system route that case to a human before the mistake happens.
Note: iajev lets you run and inspect Jev decisions. It does not let you train or fine-tune the model, and RLCD is TypeSafe's training method, not something you configure.
Comparing hosted Jev with an open model? Read our Jev vs Laya comparison for free usage, self-hosting costs, and evaluation tradeoffs.
Jev vs LLM: Do You Still Need ChatGPT or Claude?
Yes, for different jobs. Here's how to think about Jev vs LLM and Jev vs structured output / JSON mode:
| Approach | Strength | Limitation |
|---|---|---|
| Hand-written rules / regex | Free, instant, predictable | Breaks the moment meaning matters |
| Trained classifier | Fast and cheap at runtime | Needs labeled data and a separate model per task |
| LLM + JSON mode / function calling | Flexible, understands any text | Slower and pricier. The format is constrained, but the probabilities aren't calibrated |
| Jev (System One Model) | Flexible like an LLM, typed like a classifier, with calibrated probabilities | Can't write, summarize, reason at length, or do reliable math |
A common architecture is "Jev decides, the LLM writes":
- Jev classifies the incoming message's intent in milliseconds.
- Simple intents (order status, password reset) go straight to deterministic code, with no LLM needed.
- Complex or sensitive intents go to an LLM or a human.
The expensive model now runs only where it adds value.
AI Jev Use Cases
Jev fits anywhere your software needs one judgment over known outcomes. Here are proven patterns, each with a ready-made iajev tool:
- Support ticket routing. Send each ticket to Billing, Technical, Sales, or Fraud. Try the Support Ticket Classifier.
- Intent detection. Does the user want to buy, get help, cancel, or learn more? Try the Intent Classifier.
- Agent tool selection. Which tool should the AI agent call next: search, calculator, code, or database? Try the AI Router.
- Lead qualification. Is this lead hot, warm, or cold? Try the Lead Scorer.
- Feedback classification. Is this a bug report, feature request, praise, or question? Try the AI Classifier.
- Review sentiment. Is a review positive, neutral, negative, or mixed? Try the Review Classifier.
- Moderation and verification. Custom choices like
Approve / Reject / Review, or risk tiers likeLow / Medium / High. Build them in the Playground.
Browse all ready-made Jev tools Pick a workflow, paste your context, and get a decision with probabilities in seconds.
Where Jev Breaks (Read This Before You Automate)
A decision model is only useful if you know its limits. Based on TypeSafe's own guidance and early developer testing:
- It can't write. No replies, summaries, explanations, or code. Use an LLM for that.
- Math, counting, and date comparisons are unreliable. Do arithmetic and date logic in your code, then pass Jev the result.
- It only knows what you give it. Jev has no access to outside knowledge and can't look anything up.
- Too much irrelevant context hurts accuracy. Filter first, and send only what the decision needs.
- It reads your question literally. Vague or double-negative questions produce worse answers.
- It is text only. Images, audio, and video aren't supported.
- Typed does not mean correct. A valid option can still be the wrong option. Always check confidence.
How to write questions Jev answers well
- Ask one judgment per question. "Does this message ask for a refund?" works. "Analyze this and decide what to do" doesn't.
- Give an escape hatch. Add
OtherorNone of the abovewhen your options might not cover every input. - Make options mutually exclusive. Overlapping choices split the probability and lower confidence.
- Test on your own labeled examples before trusting any threshold.
How to Try Jev Online (Free Preview)
You don't need an API key to start. The iajev Playground offers a limited free preview:
- Describe the situation. Paste a message, ticket, or the facts that matter (up to 8,000 characters).
- Define the decision. Use a ready-made question or write your own with 2–8 possible answers.
- Read the signals. Compare probabilities and confidence, and inspect the raw JSON.
Pro tip: run a "before → after" test. Keep the question and choices identical, change one detail in the context (add a plan tier, a country, a budget), and run again. Watching the probabilities shift is the fastest way to build intuition for how Jev reasons about your data.
Your first decision takes under a minute
Using the Jev API Through iajev
When you're ready to automate, the iajev REST API gives you the same decisions as JSON.
cURL example: intent detection
curl https://iajev.com/api/v1/decisions/run \
-H 'Authorization: Bearer YOUR_API_KEY' \
-H 'Idempotency-Key: YOUR_UNIQUE_REQUEST_ID' \
-H 'Content-Type: application/json' \
--data '{
"state": {
"message": "Your app is great but I found a cheaper option. How do I close my account?",
"plan": "pro"
},
"decision": {
"type": "choice",
"question": "What does this person want to do?",
"choices": ["Buy", "Get help", "Cancel", "Learn more"]
}
}'
Python example
import os
import uuid
import requests
resp = requests.post(
"https://iajev.com/api/v1/decisions/run",
headers={
"Authorization": f"Bearer {os.environ['IAJEV_API_KEY']}",
"Idempotency-Key": str(uuid.uuid4()),
"Content-Type": "application/json",
},
json={
"state": {"review": "Shipping was slow, but the product itself is excellent."},
"decision": {
"type": "choice",
"question": "What sentiment does this customer review express?",
"choices": ["Positive", "Neutral", "Negative", "Mixed"],
},
},
timeout=10,
)
print(resp.json())
The API works with any language that can send HTTP + JSON: Python, Node.js, TypeScript, Go, Java, or Rust. No dedicated SDK is required. Keep your API key on the server.
Turn confidence into business rules
The real power of a calibrated decision model is confidence gating:
decision = resp.json()
if decision["confidence"] >= 0.9:
act_automatically(decision) # clear case
elif decision["confidence"] >= 0.5:
ask_user_to_confirm(decision) # probably right, verify
else:
route_to_human(decision) # genuinely uncertain
These thresholds are only a starting point. Tune them on your own labeled examples, based on what a wrong decision costs you. Check the API documentation for the exact response fields.
Jev API pricing on iajev
iajev uses simple credits:
- Each started 1,000 input tokens = 1 credit, with a minimum of 1 credit per successful decision.
- Output tokens are free.
- Price per credit depends on your subscription or credit pack.
Most classification requests are short, so a typical decision uses a single credit. See current plans on the Pricing page.
Ready to ship Jev in production? Create an API key, add credits, and route your first real decisions today.
FAQ: AI Jev, System One Models & RLCD
What does AI Jev do? AI Jev turns context into a typed decision. You give it a situation and a set of possible answers. It returns the selected answer, a probability for each option, and a confidence score.
Is Jev an LLM? Not in the usual sense. Jev doesn't generate free-form text. It's a System One Model designed for structured decisions, and it's meant to work alongside LLMs, not replace them.
What is the difference between a System One Model and a reasoning model? A System One Model makes fast, bounded judgments over options you define. A reasoning (System Two) model works through open-ended, multi-step problems and produces text.
What does RLCD stand for? Reinforcement Learning for Calibrated Decisions. It is the training approach that aims to make Jev's probabilities match how often its decisions are actually correct.
RLCD vs RLHF: what's the difference? RLHF rewards responses humans prefer, which makes chat models helpful and fluent. RLCD rewards calibrated probabilities on decisions, which makes a model honest about how sure it is.
Can Jev hallucinate? Jev can't return an answer outside your defined options or produce malformed output. It can still choose the wrong option, which is why you should use confidence thresholds and human review for high-stakes cases.
Can I use Jev Score or Noul on iajev?
iajev currently supports Choice. For yes/no tasks, use two choices. For levels, use ordered choices like Low / Medium / High.
Is Jev free? The iajev Playground offers a limited anonymous free preview. Signed-in usage and API calls use paid credits.
How do I measure Jev's accuracy? Build a small benchmark from labeled examples in your own workflow. Measure accuracy, latency, and cost, then check that high-confidence answers are right more often than low-confidence ones.
Start Making Faster, Clearer AI Decisions
AI Jev represents a genuinely different direction in AI. Instead of making machines better at chatting, it makes software better at deciding: fast, typed, and honest about its uncertainty thanks to RLCD.
The best way to understand a System One Model is to feed it a decision you make every day and watch the probabilities.
Bring a real question. Define your choices. See where the probabilities lead.