TypeSafe AI · released 15 Sept 2026 · a System-1 model
JEV: the if / else of AI.
JEV is not an LLM. It never writes a sentence. You give it state and typed questions. It gives back a probability for every option you allowed, with a calibrated confidence. It does this in milliseconds and for almost no cost.
- 70–500 ms
- end-to-end latency*
- ₹3.99
- per 1M input tokens
- Free
- output tokens
- 0%
- invalid outputs*
*TypeSafe's own figures. There is no independent benchmark yet.
state
question · choice
Which queue should handle this?
01 · The basics
What is JEV?
TypeSafe describes it as “an AI model built to make fast, structured decisions that software can use directly.” In classic machine-learning terms JEV is a classifier, like logistic regression. The difference is that it is general. You never train it on your data. You describe the options in plain English and it picks one.
01
Not an LLM
An LLM generates text one token at a time. JEV never generates text. It returns typed values: a choice, a score, or a yes/no probability.
02
A decision model
Input is state (text, JSON, logs, a chat history) plus questions. Output is a probability for each allowed answer and a calibrated confidence.
03
Classification as a service
Before JEV, a classifier meant collect data → train → deploy. With JEV you send a question with its options and get the prediction back. No training or fine-tuning.
Try it: route a support ticket
simulated · no API callThis is the video's example. Edit the message, or add your own option. JEV has no fixed label set, so the options are whatever you send it.
question: which queue should handle this?
→ Route to shipping. The answer is always one of your options. It can't return a label you didn't send.
02 · The core idea
Software needs System 1. We keep building System 2.
In Thinking, Fast and Slow, Daniel Kahneman describes two modes of thought. System 1 is fast and intuitive: you swerve when a car cuts in front of your bike. System 2 is slow and deliberate: you plan where your career should be in five years. Today's LLMs are System-2 machines, and much of software only needs System 1.
System 1 · fast
Intuitive, automatic, cheap. One shot, no deliberation.
- 🏍️ Swerve away from the car
- 📨 Route an email to the right team
- 🛡️ Flag an unsafe comment
- 🤖 Pick the next tool for an agent
Best tool: decision models like JEV
System 2 · slow
Deliberate, step-by-step, expensive. Think, plan, then answer.
- 🧭 Plan your next five years
- ✍️ Write an essay or code
- 🔬 Debug a multi-step problem
- 🗺️ Plan an agent's whole task
Best tool: reasoning LLMs
Quick game: System 1 or System 2?
0/0 correctSend this email to billing, shipping or support?
Write a cover letter for this job posting
Which of my agent's 10 tools fits this step?
Plan a 3-week migration from MySQL to Postgres
Is this YouTube comment abusive?
Is this user prompt a jailbreak attempt?
Explain why the quarterly revenue dropped
Game agent: jump, duck or run?
03 · Who & why
Built by one of the people who built ChatGPT
JEV comes from TypeSafe AI, founded by Diogo Almeida, a former OpenAI researcher who worked on the techniques behind ChatGPT. His argument is that the industry made models brilliant at talking to humans but never made them good at talking to software.
“
Models have been superhuman at chat for years. So where is all the automation?
Almeida's answer, from the TypeSafe site:
“Software needs System 1 thinking, but we keep building System 2.”
The problem
Automation demos fail in production. LLM calls are slow, costly and return messy text.
The diagnosis
LLMs are optimised to chat with humans, not to plug into software as a component.
The fix
A model whose only output is a typed decision that code can branch on.
2022
InstructGPT & RLHF
Diogo Almeida is a key researcher on the OpenAI team behind InstructGPT and RLHF, the alignment work that made ChatGPT possible.
2024
Leaves OpenAI, founds TypeSafe AI
The company works in stealth mode for about two years. Nobody knows what it's building.
15 Sept 2026
JEV launches
TypeSafe's first model, and the first of a new class it calls System One models. Access starts as an early-access waitlist.
16 Sept 2026
Vercel AI Gateway support
JEV becomes available as typesafe-ai/jev through Vercel's AI SDK (experimental_evaluate) and a TypeSafe-compatible HTTP API.
Sept 2026
Ecosystem arrives within days
Pydantic AI, LangSmith tracing, Cloudflare and AI/ML API add support. More than 70 community demos appear, along with the first open clones and JevBench.
04 · How to use it
State in, typed answers out
Every JEV call has the same shape. The state is anything text-like: a review, an email, a JSON record, a game screen serialised to text. The questions each have one of three types. There is no prompt engineering and no output parsing.
type: "choice"
Choice
Pick one option from a named set. You get the choice, a confidence and a probability for every option. Up to 255 options.
department → billing · shipping · technical
{ "choice": "shipping", "confidence": 0.86, "probabilities": {…} }
type: "score"
Score
Rate along an ordered scale (rubric). You get an interpolated score plus the probability of each rung.
frustration → calm · annoyed · angry · furious
{ "score": 2.31, "confidence": 0.71, "probabilities": {"0":0.01, …} }
type: "noul"
Noul (yes/no)
A boolean returned as a probability from 0 to 1. You set the threshold, for example 0.9 for fewer false positives.
refund_requested → true / false
{ "noul": 0.97 }
Five questions, one call, answered in parallel
simulated · no API callThe state is sent once and every question is answered at the same time. Adding questions barely changes latency or cost. In the video, five questions took ~7 s with an LLM and ~130 ms with JEV.
state (sent once)
“My package arrived damaged and I want a refund. This is the second time!”curl https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "My package arrived damaged and I want a refund.",
"questions": {
"queue": { "type": "choice", "instructions": "Which team should handle this?",
"criteria": { "billing": "payments, refunds", "shipping": "delivery problems",
"technical": "app bugs", "general": "anything else" } },
"urgent": { "type": "noul", "instructions": "Is this urgent?" },
"mood": { "type": "score", "instructions": "How upset is the customer?",
"criteria": ["calm", "annoyed", "upset", "furious"] }
}
}'Snippets follow the documented shapes from TypeSafe, Vercel and Pydantic. Note that Vercel's AI SDK calls the boolean type"boolean", while TypeSafe's native API calls it"noul".
05 · JEV vs LLM
The same decision, faster and cheaper
An LLM with structured output can also pick one of four options. JEV's claim isn't that it's smarter. It's that it makes the same kind of System-1 decision one to two orders of magnitude faster and cheaper, with typed output and honest confidence.
Speed race
simulated · no API callThe task is to classify a support message. Latencies are drawn from ranges in the video's live demo (GPT-5 took 6.58 s and 4.19 s, JEV took 472 ms and 781 ms) and TypeSafe's published range (70–500 ms vs 3–329 s).
JEVone forward pass → answer head
0 ms
Frontier LLMreasoning + token-by-token JSON
0 ms
Cost calculator
The video's scenario is classifying 10,000 emails a day at about 1,000 input tokens each. That comes to ~₹11 lakh a year on GPT-5 versus ~₹14,000 on JEV. Change the numbers to fit your own workload. JEV's output tokens are free.
Compare against
GPT-5 (as in the video) · per year
₹11.27 L
₹118.75 in / ₹950.00 out per 1M
JEV · per year
₹14,563
₹3.99 in / free out per 1M
77× cheaper
| LLM | JEV | |
|---|---|---|
| Per item | ₹0.309 | ₹0.00399 |
| Per day | ₹3,088 | ₹39.90 |
| Per month | ₹92,625 | ₹1,197 |
| Per year | ₹11.27 L | ₹14,563 |
List prices only. Real LLM bills also depend on caching, batching and retries, and a cheap LLM might be enough for some tasks. JEV's price is TypeSafe's published $0.042 per 1M input tokens.
It can't hallucinate a label
simulated · no API callQuestion: “My package arrived damaged and I want a refund.” Which category is it: billing, shipping, technical or general? An LLM writes an answer, so it can drift. Structured outputs reduce this but don't guarantee it, especially on smaller models. JEV only assigns probabilities to your options, so there is nothing to parse.
LLM · free-text output
Press the button to sample answers…
JEV · typed output
Waiting…
“Can't hallucinate” means it can't invent an invalid answer. It can still pick the wrong option. That is what the confidence score is for.
Side by side: JEV, LLM and a fine-tuned BERT
BERT is included because it's what you'd have used for classification before (and it's what the lab compares against).
| JEV | LLM | Fine-tuned BERT | |
|---|---|---|---|
| Output | Typed values: choice, score, yes/no | Free-form text, token by token | Fixed labels it was trained on |
| Latency | 70–500 ms | 3 s – minutes | ~50–100 ms on CPU (local) |
| Cost | $0.042 / 1M input, output free | $0.25–$10+ / 1M output | Your own server |
| Training needed | None: describe options in English | None (prompting) | Labelled data + fine-tuning |
| New label tomorrow? | Add it to the request | Edit the prompt | Re-label & re-train |
| Invalid output possible? | No, answers come from your options | Yes, format drift | No |
| Calibrated confidence | Yes, trained for it (RLCD) | Rarely, often overconfident | Softmax, often overconfident |
| Explains its answer | No | Yes | No |
| Writes text / code / plans | No | Yes | No |
| World knowledge | Broad | Broad | Narrow |
| Input | Text only (32K ctx) | Text, images, audio… | Text (512 tokens) |
Which one should I use?
The practical rule: LLMs do the heavy lifting, and decision models handle the many small decisions around them. Pick a task:
Use
JEV
High-volume choice question. Use confidence to send hard cases to a human.
06 · Confidence you can branch on
Calibrated confidence and RLCD
Every JEV answer comes with a confidence number that is trained to be honest. When it says 90%, it should be right about 90% of the time. TypeSafe calls the training method RLCD, Reinforcement Learning for Calibrated Decisions (sometimes misheard as “RLCV”). LLMs are known to overstate their confidence. An honest number lets you write code that trusts the easy cases and escalates the hard ones.
Confidence-based routing
simulated · no API callThe pattern from the video: above 90%, act automatically. Between 60% and 90%, ask a follow-up. Below 60%, send it to a human. Drag the thresholds and watch 80 tickets re-route.
In the automatic lane: 6 wrong out of 31 (19.4% error, ringed squares). Because the confidence is calibrated, you can predict that error rate before shipping.
const { choice, confidence } = answers.queue;
if (confidence >= 0.90) {
forwardTo(choice); // 31/80 automatic
} else if (confidence >= 0.60) {
askFollowUpQuestion(); // 47/80 one more JEV call
} else {
sendToHumanReview(); // 2/80 to people
}Reliability diagram
Stated confidence (x) vs how often the answer was actually right (y). The dashed line is perfect honesty. Points below it mean the model claims more than it delivers.
Illustrative curves, not measured data. TypeSafe hasn't published a reliability plot.
Why a calibration reward makes the model honest
Suppose the model is truly right 70% of the time on some kind of question. If each answer is penalised with a proper scoring rule such as the Brier score, (confidence − outcome)², the lowest expected penalty is at a confidence of exactly 70%. Bluffing costs more on average.
Expected penalty if it says 0.95
0.273
If it says the truth (0.70)
0.210
RLHF vs RLCD
Almeida worked on RLHF, which made ChatGPT helpful. RLCD applies RL to a different target: not “what do humans prefer to read?” but “are the probabilities true?”
RLHF · Reinforcement Learning from Human Feedback
- 1Pre-train. Predict the next token on web-scale text.
- 2Supervised fine-tune. Imitate human-written demonstrations.
- 3Humans rank outputs. Labelers compare answers → train a reward model.
- 4PPO. Optimise the policy to maximise that reward (with a KL leash).
Goal: answers people prefer. Side effect: confident-sounding text gets rewarded, which can make models overconfident.
RLCD · Reinforcement Learning for Calibrated Decisions
- 1Pre-trained backbone. World knowledge from pre-training (likely an existing model).
- 2Decision tasks. Synthetic state + question + options with known correct answers.
- 3Output a distribution. Probability for each option, plus a confidence.
- 4Reward = proper score. Reward honesty (e.g. Brier / log score); punish over- and under-confidence.
Goal: when it says 80%, it's right 80% of the time. That lets you set thresholds in code.
TypeSafe hasn't published RLCD's details (reward design, data or the metric it optimises). The right-hand pipeline is the standard way to train for calibration and matches public research such as RLCR (RL with calibration rewards, which uses a Brier-based reward). The video mentions a Brier-style metric, but treat the specifics as informed speculation.
07 · Under the hood (speculative)
How might JEV work inside?
TypeSafe has published no paper, dataset or methodology. What follows is the video's reverse-engineering, tidied up. Each claim is labelled with how sure we can be. You don't need any of this to use JEV, which is just an API call, but it explains why JEV is so fast.
What we actually know
Non-autoregressive
“a parallel sampler that generates all outputs in a single query rather than autoregressively” (TypeSafe).
Schema-constrained output
Only Choice / Score / Noul values you declare. 0% structured-output errors reported.
Parallel questions
All questions on a state are answered at once. Adding questions barely changes cost or time.
Calibrated confidence via RLCD
Reinforcement Learning for Calibrated Decisions. Details unpublished.
Transformer-based
Widely reported. TypeSafe only says “a new model architecture”.
Trained on synthetic data
Mentioned in the video as stated by TypeSafe. The data itself isn't disclosed.
Broad world knowledge (MMLU-Pro ≈ 84.6%)
Archer Hume's probe (~10,000 API calls, 17 Sept) also measured ECE 0.031 on 1,200 items. The video calls it “MMLU”. Not independently replicated.
Shared state, isolated question branches
Same probe: the state is encoded once, questions can't attend to each other, and a readout layer emits probabilities directly.
Decoder backbone + custom answer head
The explanation that best fits everything above. Speculation until a paper appears.
Prefill → decode vs prefill → answer head
LLM inference has two stages. Prefill reads the whole prompt in parallel and builds the key/value cache. Decode then produces one token per forward pass in a loop. JEV (probably) keeps the prefill and replaces the loop with a single softmax over your options.
input
What is the capital of India?
transformer layers · prefill
builds K/V vectors = “understands the question”
LM head · softmax over ~100k tokens → loop
each token = one more forward pass, fed back as input ↺
8 tokens took 8 sequential decode passes, and a reasoning model adds hundreds of hidden ‘thinking’ tokens first. The answer can also be anything in the vocabulary, including a wrong city or a paragraph.
The parallel sampler
One plausible design: encode the shared context once, then run every question as an independent branch on top of that cached context. Questions can't see each other's answers, which is why TypeSafe says they're answered “in isolation”.
This is the same idea as prefix caching in LLM servers: the expensive shared prefix is paid for once and every question reuses it.
The likely training recipe
- 1
Take a pre-trained decoder
An open model such as a Qwen-family LLM already has world knowledge, which explains the MMLU score without new pre-training.
- 2
Keep the layers that understand input
The transformer stack that does prefill: reading and encoding state + question.
- 3
Swap the LM head for an answer head
Score only the K options you sent instead of 100k+ vocabulary tokens. One pass, no loop.
- 4
Supervised training on synthetic decisions
Millions of generated (state, question, options → correct answer) examples. This fits the “synthetic data only” claim, since pre-training needs real web data.
- 5
RLCD for calibration
Reward honest probabilities so the confidence number means something.
Model size is unknown. The video guesses both “30–70B-class intelligence” and “under a billion parameters”. Archer Hume measured ~30k tokens in ~160 ms, which points to a sparse mixture-of-experts backbone. Open clones on JevBench use ~4B backbones. Anything in that range is plausible given the 70–500 ms latency.
08 · The demo from the video
Flipkart-style aspect ratings, with no model training
Flipkart shows separate ratings for camera, battery, display and so on. Its data-science team probably trained or fine-tuned a model (e.g. BERT) for that. With JEV you send each review with 14 questions (7 aspects × “is it mentioned?” + “how satisfied?”) and aggregate the answers. The video built this in about 100 lines.
Aster M1 5G
3.3 ★ 24 reviews (hypothetical phone)
All reviews
The display is gorgeous, AMOLED with deep blacks. Battery easily lasts a full day. Totally worth the price.
Camera is okay in daylight but night photos are blurry. Performance is smooth for daily use.
Phone heats up while gaming and BGMI lags after 20 minutes. Battery drains fast too.
Love the matte design and slim feel. The screen is bright even outdoors.
Build quality feels flimsy, the frame creaks. Overpriced for what you get.
Selfie camera is great and portrait mode is impressive. Charging is quick, 0 to 80 in 40 minutes.
Average phone. Display is fine, camera is average, nothing special for the money.
Super smooth performance, apps open fast. 120Hz refresh makes scrolling a joy.
Video recording has no stabilisation and photos look washed out. Disappointed with the camera.
Battery backup is solid, 7 hours screen on time. Design looks premium in the green colour.
Plastic frame but sturdy enough. Performance is decent, slight lag in heavy apps.
Best budget phone! Camera takes crisp photos and the display is stunning. Great value.
Battery drains overnight on standby. Charging also gets hot.
Looks beautiful and feels good in hand. Glass back attracts fingerprints though.
Night mode on the camera is slow. Screen brightness is good. Price is fair.
Screen started flickering in a week. Very poor quality, returned it.
Gaming is smooth on medium settings, no heating issue for me. Battery is good.
The design is bland, looks like every other phone. Camera is decent.
For ₹17,999 this is a steal. Display and performance both beat the competition.
Build quality is cheap, the buttons wobble. Battery is the only good thing.
Photos are sharp, colours accurate, video is stable. Very happy with the camera.
Charging is slow compared to others. Screen is fine for Netflix.
Sturdy frame, survived a drop without a scratch. Performance is snappy.
Too expensive for a plastic phone and the camera is mediocre. Not worth the money.
09 · What people built in week one
From slop detectors to Doom-playing agents
Within days the community had built 74+ demos, collected in awesome-jev-use-cases. They share one trick: turn the situation into text state (JEV is text-only, so game screens and web pages get serialised) and ask a small typed question on every event.
Instant compaction for Claude
A Claude Code plugin that scores every tool call in the context window for whether it must be preserved — context compaction in milliseconds.
state: tool call #214: grep output, 3k tokens
ask: Keep this in context?
→ noul 0.08 → drop
Flight search with Browser Use
A browser agent books Zurich → London by making each click/type decision with JEV instead of a slow LLM step. The whole flow runs in seconds.
~7 s end-to-end
state: page DOM + goal
ask: Which element next?
→ choice: #search-btn
Real-time slop detector
A browser plugin that scores every post in your feed as you scroll and banners the AI slop in red.
state: LinkedIn post text
ask: Is this AI slop?
→ noul 0.91 → red banner
724 competitor ads analysed
Systematic breakdown of a competitor's ad library — hook type, offer, angle — in one pass.
724 ads
state: ad copy
ask: Hook type?
→ choice: social-proof
Voice-controlled Mac
Speech is transcribed and JEV maps the utterance to the right OS action instantly.
state: “open my last download”
ask: Which action?
→ choice: open_file
jev-trader
An automated trading bot that makes a buy/hold/sell decision on every block. Fun — and risky.
decision per block
state: order book + recent trades
ask: Action?
→ choice: hold (0.72)
Doom gameplay agent
Game state is serialised to text every frame; JEV picks the next move fast enough to actually play.
state: enemy left, ammo 12, hp 40
ask: Next move?
→ choice: strafe_right
Real-time ad blocker
DOM elements are classified as ad / not-ad on the fly, e.g. on speedtest.net, and removed before you see them.
state: <div class=…> sponsored…
ask: Is this an ad?
→ noul 0.97 → hide
500 emails for 3.5 cents
Bulk inbox classification — the whole batch costs less than a single LLM call on a frontier model.
$0.035 / 500 emails
state: email body
ask: Which folder?
→ choice: invoices
Triage 1,500 emails
Large-scale inbox triage: urgency, owner and reply-needed, answered in parallel per email.
1,500 emails in seconds
state: email thread
ask: Needs a reply today?
→ noul 0.12
700 leads scored in 40 s
A sales-qualification pipeline: fit score and intent for every lead, fast enough to run on every signup.
700 leads / 40 s
state: lead profile
ask: ICP fit (1–5)?
→ score 4.2
Super Mario Bros agent
An NES platformer controlled by JEV decisions on a text rendering of the screen.
state: goomba ahead, pit at x+3
ask: Button?
→ choice: jump
PostgreSQL jev() function
A SQL function that filters a table in plain language: WHERE jev(description, 'is vegan?') > 0.8.
state: row.description
ask: Is it vegan?
→ noul 0.88
Keystroke oracle
A predictive launcher that guesses which command you want after every keystroke.
state: typed: “scr”
ask: Which command?
→ choice: screenshot
jevlike
An open experiment: a small model trained to make typed decisions the JEV way.
state: —
ask: Can we replicate it?
→ research
1kpapers
1,018 AI papers grouped by topic for about $0.08 in total.
$0.08 / 1,018 papers
state: title + abstract
ask: Topic?
→ choice: agents
Model router on JEV
JEV decides per prompt whether a cheap model is good enough or a frontier model is needed.
state: user prompt
ask: Which model?
→ choice: small (0.84)
Every's editorial vibe check
Editorial judgments on drafts against a house style — 1,709 judgments for under one cent.
1,709 judgments < $0.01
state: draft paragraph
ask: On-voice?
→ noul 0.64
Match a résumé to 400 companies
One candidate scored against 400 companies' openings on skills and seniority.
$0.0005 total
state: résumé + job post
ask: Fit?
→ score 3.6 / 5
Doomscroll filter
Every feed item is triaged into Read / Skim / Pass so you only read what matters.
state: post
ask: Read, skim or pass?
→ choice: skim
Predictive spreadsheets
Cells autofill from context in ~100 ms — AI as a spreadsheet primitive, not a chat window.
~100 ms fill
state: row context
ask: Category column?
→ choice: travel
Slay the Spire 2
A deck-building strategy agent that plays a move in about 0.7 s.
0.7 s per move
state: hand + enemy intents
ask: Which card?
→ choice: Defend
Chat bot without an LLM
A tool-calling bot where JEV picks the tool and fills arguments; replies are templated, so answers are instant.
state: “what's the weather in Pune?”
ask: Tool?
→ choice: get_weather
Self-sorting Downloads folder
macOS automation that files every new download into the right folder — no LLM involved.
state: filename + first page
ask: Folder?
→ choice: Receipts
The decision snippets are illustrative reconstructions of each demo's core question. See the original posts for details.
10 · Why it matters
AI moves from a feature to a primitive
When a decision costs almost nothing and returns in milliseconds, calling AI stops being a product announcement and becomes plumbing. It's just another branch in your code.
// AI as a *primitive*: just another if-statement
const { answers } = await jev(email, {
angry: { type: "noul", instructions: "Is this customer angry?" },
}); // ~200 ms, fractions of a paisa
if (answers.angry.noul > 0.9) escalateToSeniorAgent(email);An agent loop, split by System
■ LLM for heavy lifting · ■ JEV for the many small decisions
- llmPlan: find cheapest ZRH→LHR flight
- jevWhich tool? → browser (0.93)
- jevSafe to proceed? → yes (0.98)
- llmFill search form arguments
- jevGoal reached? → no (0.12) · continue
- jevNext element? → sort_by_price (0.88)
- jevGoal reached? → yes (0.95) · stop
- llmWrite summary for the user
5 of 8 steps are System-1 decisions, and each would otherwise cost a multi-second LLM call.
🤖
AI agents
Tool selection, “is this step safe?”, continue/retry/stop. These are the small decisions in every agent loop.
🏢
Business ops
Support triage, refund approvals, invoice fraud checks, lead scoring.
🛡️
Trust & safety
Real-time comment moderation, spam and fraud flags, jailbreak and prompt-injection screens before the LLM.
🗂️
Unstructured data
Logs, catalogues, tickets and call transcripts sorted into categories at scale.
⚡
Real-time systems
Game agents, live UI (ad blockers, feed filters), trading signals.
🧠
Context engineering
Keep/drop scoring for context compaction, and routing queries to the right model or retriever.
Seven predictions from the video (next 6–24 months)
- 01
Everyone copies it
Open clones exist already, Laya predates it, and frontier labs will likely ship their own decision models.
- 02
It disappears into the stack
Cloud platforms and frameworks will call decision models internally without you noticing.
- 03
LLM + decision model, together
A big model plans, and cheap decision models run every step in between. This does not replace LLMs.
- 04
Tooling grows around it
Tracing, evals and threshold tuning. LangSmith already traces JEV calls.
- 05
A new role: decision engineer
Someone who designs the questions, options and thresholds, and decides where System-1 AI goes.
- 06
Multimodal & web search
Text-only today. Images, audio and fresh knowledge are the obvious next steps.
- 07
Decisions on every interaction
When a decision costs about ₹0.0004, software can afford AI on every click and keystroke.
From the live Q&A
“Can we use it for agentic query routing instead of an LLM?”
Yes. That's a tailor-made use case. Retrieve from the vector store, search the web, or answer from internal knowledge? That's a small decision, so there's no need to spend an LLM call on it.
“If an agent needs planning, where does JEV fit?”
Planning and tool arguments stay with the LLM. Tool selection, “is this step safe?” and continue/stop checks can go to JEV. The heavy lifting stays with the LLM.
11 · The honest part
Limitations and open questions
A System-1 model trades depth for speed. That trade-off is the whole point, and it's also the main constraint. Use JEV where a mistake is cheap or can be caught by a confidence threshold.
No independent benchmarks (yet)
“40–200× faster, 20–100× cheaper” and “193.6× / 444.6×” are TypeSafe's own numbers from its own evals. Independent tests (JevBench, Archer Hume) are only starting, and on JevBench an open ~4B model already scores slightly higher.
Not very intelligent
It's System 1 by design. It struggles with arithmetic, date comparison and multi-step reasoning. It is fast, not deep.
No explanations
You get an answer and a confidence, but no reasoning. That makes it hard to justify in regulated settings such as banking or medicine.
Text only, 32K context
No images, audio or video yet. People work around this by serialising game screens and web pages to text.
No web search
Answers come from its parametric knowledge, so anything after the training cutoff is invisible to it.
Closed
No paper, weights, dataset or methodology. That's unusual even among closed labs, and open-source clones are already competing.
Adversarial text
The state is untrusted input. Text injected into it can sway decisions, so pair JEV with deterministic checks for safety-critical paths.
Bounded answers only
You must know the possible answers in advance (up to 255 per choice). Open-ended questions are out of scope.
12 · Evidence & ecosystem
How good is it, really?
The best numbers so far are TypeSafe's own four-workflow evaluation. On those workflows, JEV roughly matches a mid-tier frontier model's agreement with reference answers at a tiny fraction of the cost and latency. It trails the top models. That supports the positioning: not smarter, but fast and cheap enough to use everywhere.
Agreement with reference answers (%)
TypeSafe 4-workflow eval · higher is better · single axis from 0
Latency per case
0.4 s
vs 10–38 s for the LLMs
Cost per case
₹0.0380
vs ₹2.888–₹16.730
These are vendor-run evals. Treat them as a claim to verify, which is exactly what the BERT vs JEV lab lets you do.
Laya
The earlier competitor. Its creator built a non-autoregressive decision model trained with RL a year before JEV and published a paper and dataset. JEV got more attention largely because of its founder's profile.
JevBench v1.4.2
Benchmark Heaven's leaderboard: intelligence, calibration, speed and cost weighted equally over 534 public + 308 sealed decisions. At the time of writing an open ~4B model (decider-4b v2, 64.1) edges Jev 1.13.0 (63.3), with JevK5 (62.0) close behind.
Open clones
Within a week, open models built the same way appeared: a pre-trained backbone (e.g. ~4B Qwen) with a new answer head, trained on synthetic data.
Integrations
Vercel AI Gateway & AI SDK, Pydantic AI, LangSmith tracing, Cloudflare Workers AI, AI/ML API, and official Python & JS SDKs.
13 · Study notes
Video notes: CampusX on JEV
Everything above is built from this session plus current documentation. Jump to any chapter. Clicking a chapter restarts the embedded video at that point.
Resources: where I learned about JEV
Start with the docs, then the architecture post, then browse the demos.
TypeSafe docs: Introduction ↗
docs.typesafe.ai
The official starting point: System One models, and the Choice / Score / Noul primitives.
awesome-jev-use-cases ↗
GitHub · walidboulanouar
74 community demos ranked by engagement, in 7 categories. The source of the use-case gallery above.
Ship with Jev: GitHub projects ↗
shipwithjev.com
A hand-sorted catalogue of 278 open-source projects built with JEV: agents, games, research, tools, trading.
Jev's Architecture Unmasked ↗
Archer Hume · 17 Sept 2026
Reverse-engineering from ~10k API calls: shared state + isolated question branches, MMLU-Pro 84.6%, ECE 0.031, likely sparse MoE.
Building a Harness with Jev ↗
LangChain blog · 17 Sept 2026
Where JEV fits inside agent loops: fast typed decisions alongside a conventional LLM.
JevBench v1.4.2 ↗
Benchmark Heaven
Independent leaderboard for decision models on intelligence, calibration, speed and cost.
Corrections & clarifications
Where the session and today's facts differ, or where it was speculating:
Model size: unknown
The video suggests both “30–70B-class” and “under a billion parameters”. Neither is confirmed.
Costs are in rupees
The video's “Rs.119 / Rs.956 per million” is GPT-5's $1.25 / $10 at ≈₹95/$. JEV's “Rs.4” is $0.042.
“Can't hallucinate” ≠ “can't be wrong”
It can't output an invalid option, but it can still choose the wrong one. That's why the confidence score matters.
The calibration curve was illustrative
The video itself noted the figure wasn't real data. Archer Hume has since measured ECE ≈ 0.031 on 1,200 MMLU-Pro items.
MMLU → MMLU-Pro
The 84.6% the video quotes comes from Archer Hume's probe, and it's MMLU-Pro, the harder variant.
14 · Check yourself
Six-question quiz
1.What does JEV return?
2.Why can't JEV return an invalid label?
3.JEV says 0.9 confidence on 1,000 tickets. If it's well calibrated, about how many are wrong?
4.Which task should stay with an LLM?
5.The most likely reason JEV is so fast:
6.What does RLCD optimise for?