JEV: The Decision Model That Turns AI Into Smart If-Statements
Why This Matters
For years, the default approach to AI-powered decisions in software has been: ask a general-purpose language model a question and parse its prose response. If you need to route a support ticket to the right department, classify an email as phishing or not, or decide whether a log line indicates a critical failure, you send the text to GPT or Claude, hope for structured output, extract it with regex or JSON parsing, and pray the model didn't hallucinate a new category.
Jev — released by TypeSafe AI on September 15, 2026 — replaces that entire pattern with something fundamentally different. It is not a chat model. It does not generate prose. You send it state and typed questions; it sends back one answer per question: a choice picked from your predefined options, a score on an ordered rubric you define, or a calibrated yes/no probability. Every answer comes with probabilities. Most calls complete in 70–500ms.
TypeSafe AI came out of stealth with a $40M seed round led by DCVC, and the company's co-founder is none other than Daniel Gross, the original ChatGPT inventor. The model is called "System One" — borrowing from Daniel Kahneman's framework of fast, intuitive judgments — because it is designed for the cheap branches software makes all day, not the slow reasoning tasks that require System Two deliberation.
This article explains what Jev actually does, how it helps in real applications, how to run a local open-source equivalent in your home lab, and the use cases where it genuinely outperforms traditional approaches.
What Is Jev?
Jev is TypeSafe AI's hosted System One model. At its core, it is a decision model — a model trained specifically to make structured judgments about input state, not to generate text.
The Three Answer Types
Every question you ask Jev is one of three types:
1. Choice — Pick one label from a set you define (up to 255 options). Returns the winner plus a probability for each option. For example, given a support ticket, Jev might return billing: 0.44 / technical: 0.41 / sales: 0.15, telling your application that this ticket is nearly evenly split between billing and technical categories.
2. Score — Rate an input against an ordered rubric (2–10 levels you define in plain language). Returns a continuous score that can land between levels because it's a probability-weighted average position rather than a single pick. A score of 2.5 means the model is split between the second and third levels.
3. Noul — Answer a yes/no question with a single calibrated probability from 0 to 1. For example, "Does this message convey urgency?" might return 0.999 — a 99.9% probability that the statement is true.
One State, Many Questions, One Pass
Here's what makes Jev architecturally interesting: it is not autoregressive. A chat model builds its answer one token at a time, each conditioned on the last — which is why latency scales with output length. Jev takes the state once and evaluates every question against it in parallel, returning everything in a single forward pass.
This means you can ask 13 questions about the same input in one call, and it runs roughly 10× faster and 12× cheaper than asking them sequentially. The questions are evaluated independently against the same state — nothing chains. If you need question B to depend on the answer to A, that's two calls with your own logic in between.
Cost and Speed
| Metric | Value |
|---|---|
| Latency | 70–500ms (TypeSafe claim; measure your own path) |
| Input cost | $0.042 per million tokens |
| Output cost | Free (typed values, not generated text) |
| Current model | jev-1.13.0 (also exposed as jev-latest and jev-preview) |
How Jev Helps
The Problem It Solves
Most AI applications spend the majority of their cost and latency on decisions that don't require language generation. Consider an agent loop:
- User sends a message
- LLM decides which tool to call (another model call)
- Tool executes
- LLM evaluates the result (another model call)
- LLM decides whether to continue or respond (another model call)
Each decision point is a full LLM call — slow, expensive, and overkill for what is essentially a classification or routing problem. Jev replaces those decision calls with typed evaluations that cost pennies and return in milliseconds.
The Hybrid Pattern
The typical production pattern is hybrid: Jev decides the branch; GPT, Claude, or another LLM writes whatever a person will read. This is why "Jev vs GPT" is the wrong framing — they solve different problems. Jev is the smart if statement in your application; the general-purpose model is still the writer.
What Jev Is Poor At
TypeSafe explicitly states that Jev is not trained to generate text. It is a poor fit for:
- Drafting, summarizing, or explaining
- Deep research or long reasoning chains
- Any task that requires prose output
If you need an AI to write content, use a language model. If you need an AI to decide which content to write, use Jev.
How to Run Jev Locally in Your Home Lab
Jev itself is not open source — TypeSafe has not released weights or training details, and there is no way to self-host the official model. However, a fast-growing ecosystem of community projects has emerged that reimplement the same typed-decision interface using open weights. These are independent projects, not affiliated with TypeSafe AI, but they use the same primitives (choice, score, noul) and can serve as drop-in alternatives for many use cases.
Option 1: Laya-MLX (Mac / Apple Silicon) — Easiest Path
Laya is a 421M-parameter open-source System One decision model that runs in-process on Apple Silicon Macs. No GPU, no server, no Python dependencies beyond the package itself.
# 1. Create and activate a virtual environment
python3.11 -m venv .venv && source .venv/bin/activate
# 2. Install Laya-MLX
pip install laya-mlx
# 3. Download the model (optional — auto-downloads on first run)
hf download aac6fef/laya-mlx
Then use it directly in Python:
import laya_mlx as laya
agent = laya.load("aac6fef/laya-mlx")
result = agent.predict(
"I was billed twice. Please refund the duplicate.",
{
"department": {
"type": "choice",
"instructions": "Who should handle this?",
"criteria": ["billing", "technical", "sales"],
}
},
)
print(result["answers"]["department"])
# → {'choice': 'billing', 'probabilities': {'billing': 0.72, 'technical': 0.18, 'sales': 0.10}}
Pros: Millisecond local calls, zero network dependency, no server, ~420MB memory footprint Cons: Apple Silicon only, smaller model means lower accuracy than the hosted Jev
Option 2: OpenJev (NVIDIA GPU / Docker) — API-Compatible
OpenJev is a bigger, GPU-served model that runs behind a Jev-compatible HTTP API on localhost:8080. It uses vLLM with DiffusionGemma and requires an NVIDIA GPU.
# 1. Clone the OpenJev repository
git clone https://github.com/TheoLeeCJ/openjev.git
cd openjev
# 2. Build and run via Docker (requires NVIDIA Container Toolkit)
docker compose up -d
# → Server available at http://localhost:8080
Or run directly on bare-metal NVIDIA hardware for full control of the vLLM runtime:
pip install openjev
openjev serve --model <path-to-gemma-checkpoint>
Pros: Jev-compatible HTTP API (drop-in replacement for hosted endpoint), bigger model, GPU-accelerated Cons: Requires NVIDIA GPU, Docker setup, more complex infrastructure
Option 3: Laya ONNX Runtime (AMD / Linux) — CPU or GPU
Laya's ONNX model runs on any x86_64 or ARM64 Linux machine, with optional hardware acceleration via AMD GPUs through ROCm. This makes it the most flexible option for home lab enthusiasts who don't have Apple Silicon or NVIDIA hardware.
CPU-Only Setup (AMD Ryzen 7 3700 and similar)
# 1. Create and activate a virtual environment
python3 -m venv .venv && source .venv/bin/activate
# 2. Install ONNX Runtime
pip install onnxruntime
# 3. Download the Laya ONNX model from Hugging Face
hf download Mattepiu/laya-onnx
Then use it in Python:
import onnxruntime as ort
import numpy as np
sess = ort.InferenceSession("laya.onnx")
# Run inference with your input state and typed questions
On a system like an AMD Ryzen 7 3700 (8-core/16-thread, 2020 release), expect single-question latencies in the 15–30ms range — not as fast as Apple Silicon's MLX path, but perfectly adequate for agent routing, support triage, and workflow gating where sub-50ms is acceptable.
GPU-Accelerated Setup (AMD Radeon / ROCm)
If you have an AMD GPU with ROCm support (e.g., Radeon RX 6700 XT, RX 7900 XTX, or Threadripper Pro), ONNX Runtime provides a MIGraphX Execution Provider that offloads model inference to the GPU. Since ROCm 6.0.2, AMD ships pre-built Python wheels — no compiling from source required.
# 1. Install ROCm (Ubuntu/Debian example)
sudo apt update
sudo apt install -y rocm-dev rocminfo
# 2. Verify your GPU is detected
rocminfo
# 3. Install ONNX Runtime with MIGraphX EP support
pip uninstall -y onnxruntime-migraphx
pip install onnxruntime-migraphx \
-f https://repo.radeon.com/rocm/manylinux/
# Note: numpy v2.0 is incompatible with these wheels;
# downgrade if needed:
pip install numpy==1.26.4
Then configure ONNX Runtime to use the MIGraphX provider:
import onnxruntime as ort
sess_options = ort.SessionOptions()
sess_options.add_session_graph_optimization_level(
ort.OrtLoggingLevel.ORT_LOGGING_LEVEL_INFO
)
# Specify MIGraphX as the execution provider
providers = ["MIGraphXExecutionProvider", "CPUExecutionProvider"]
sess = ort.InferenceSession(
"laya.onnx",
sess_options=sess_options,
providers=providers
)
The MIGraphX Execution Provider automatically partitions the model graph — operations it can run on your AMD GPU execute there, while unsupported ops fall back to CPU. This gives you GPU-accelerated inference without rewriting your code.
AMD hardware notes:
- ROCm support on consumer GPUs: ROCm 7.x added support for Radeon RX 6000/7000 series on Linux. The Ryzen 7 3700 itself is a CPU-only chip, but pairing it with a supported AMD GPU unlocks the MIGraphX path.
- Threadripper Pro: Full ROCm support with multi-GPU capability — ideal for home labs running multiple models.
- Integrated graphics (Ryzen APUs): RDNA 2/3 iGPUs (e.g., Ryzen 7 5700G, 8700G) are supported in ROCm 7.x and can serve as low-cost inference accelerators.
Pros: Works on any Linux machine, GPU acceleration available with AMD hardware, no vendor lock-in Cons: CPU-only inference slower than MLX, ROCm setup adds complexity, consumer GPU support varies by model
Option 4: @receptron/laya (Node.js / TypeScript) — No Python Required
If your stack is already JavaScript/TypeScript, Laya has an ONNX-based runtime that runs without Python:
npm install @receptron/laya
import { load } from '@receptron/laya';
const agent = await load('aac6fef/laya-onnx');
const result = await agent.predict(
"Is this email a phishing attempt?",
{
is_phishing: {
type: 'noul',
instructions: 'Does the email exhibit phishing characteristics?',
}
}
);
console.log(result.answers.is_phishing);
Pros: No Python, fits naturally into Node.js home lab services Cons: ONNX runtime may have fewer features than the Python/MLX versions
Home Lab Architecture Example
For a home lab setup, here's a practical architecture:
Here is the home lab architecture showing how n8n and OpenJev/Laya both feed agent routing, triage, and scoring via typed decisions inside the local boundary.
flowchart TD
subgraph Lab["Your Home Lab"]
n8n["n8n workflow engine"]
ml["OpenJev / Laya decision model"]
arc["Agent routing / triage / scoring"]
n8n -->|typed decisions| arc
ml -->|typed decisions| arc
end
This gives you:
- Zero network dependency — decisions happen locally
- No per-call cost — free inference after model download
- Privacy — your data never leaves your hardware
- Instant feedback — sub-second decision latency
Real Use Cases for Jev
1. Support Ticket Triage
Route incoming support tickets to the right department automatically. Instead of a general LLM generating a paragraph explanation, Jev returns billing: 0.44 / technical: 0.41 in milliseconds, and your application routes accordingly.
{
"model": "jev-latest",
"state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
"questions": {
"is_urgent": { "type": "noul", "instructions": "The message conveys urgency or time-sensitivity" },
"department": {
"type": "choice",
"criteria": ["billing", "technical", "sales"]
}
}
}
2. Agent Loop Optimization
Replace expensive LLM calls in agent loops with cheap Jev evaluations. Before calling a coding model, use Jev to decide: should this tool call run? Is the current state sufficient? What's the next best action? This can reduce agent loop costs by 400× on classification tasks.
3. Moderation and Safety Gates
Check whether content violates policy before it reaches a human moderator or gets published. Jev returns calibrated probabilities that you can threshold — for example, flag anything with toxicity > 0.8 for review while auto-approving the rest.
4. Lead Scoring and Routing
Score incoming leads against your ideal customer profile. Ask multiple questions in one call: is this a sponsor inquiry? What product category? How specific is the request? Each question shares the same state but is evaluated independently.
5. Log Analysis and Anomaly Detection
Parse application logs to detect anomalies. Split log lines into chunks, ask Jev whether each indicates a problem, what severity level, and which subsystem is affected. Rank by confidence and only escalate the top results to on-call engineers.
6. Citation and Fact Checking
Before publishing content, use Jev to check whether claims are supported by cited sources. Ask: does this paragraph contain unsupported assertions? Is each citation relevant? This is a natural fit because the questions are bounded and the answers are typed.
7. Browser Automation Routing
In browser automation agents, Jev can pick the next operation (click, type, scroll) and target element from a dynamic, indexed action space — then a separate model handles the actual execution. Jev decides what to do; the agent does it.
Limitations and Caveats
Questions Cannot See Each Other
This is the most significant architectural constraint. Every question is evaluated independently against the same state. If you need your second question to depend on the answer to your first, you must make two separate calls with your own logic in between. This forces a different design pattern than autoregressive models.
Local Models Are Smaller and Less Accurate
The open-source alternatives (Laya at 421M parameters, OpenJev's Gemma-based model) are significantly smaller than what TypeSafe has behind their API. Their calibration and quality are their own — not TypeSafe's. You must validate on your own labelled data before wiring thresholds in production.
Calibration May Be Off
Some third-party checkpoints ship uncalibrated confidence scores. The MLX build of Laya, for example, warns about out-of-range temperatures. Always validate calibration on your own data before relying on probability thresholds for critical decisions.
Not a Replacement for Language Models
Jev does not generate text. It is a decision model. If you need prose output, use a language model. The power of Jev is in the hybrid pattern: Jev decides the branch, the LLM writes the response.
The Bigger Picture: Why System One Matters
Jev represents a shift in how we think about AI in software. For years, the approach has been: every problem is a language generation problem. Send text to an LLM, get text back, parse it, repeat. This works but is expensive and slow.
System One models like Jev recognize that most decisions inside software are classification problems — route this, score that, check whether this condition holds. These are the cheap branches that happen thousands of times per application lifecycle. A model trained specifically for these judgments, with calibrated probabilities and typed output, can be orders of magnitude faster and cheaper than asking a general-purpose model to classify text in prose.
The trend mirrors what happened with databases: you don't run a general-purpose text processor when you need structured queries. You use the right tool for the job. Jev is the right tool for structured decisions; language models are the right tool for language generation. The best systems use both.
Getting Started
For immediate experimentation, TypeSafe offers a free browser-based playground at jevai.tools where you can try the model with interactive tools for routing, scoring, context pruning, and editable TypeScript policies.
For self-hosting in your home lab:
# Quickest path: Laya on Apple Silicon
python3.11 -m venv .venv && source .venv/bin/activate
pip install laya-mlx
Or for a Linux server with AMD hardware:
# CPU-only (Ryzen 7 3700, etc.)
pip install onnxruntime
hf download Mattepiu/laya-onnx
# GPU-accelerated (AMD Radeon + ROCm)
pip install onnxruntime-migraphx -f https://repo.radeon.com/rocm/manylinux/
Or for a GPU-accelerated, API-compatible server:
git clone https://github.com/TheoLeeCJ/openjev.git
cd openjev
docker compose up -d
# → http://localhost:8080
The ecosystem is growing fast. As of September 2026, there are 275+ GitHub repos built around Jev-style decision models, with new projects emerging daily. The awesome-jev curated list is the best starting point for exploring integrations, benchmarks, and community tools.
Final Thoughts
Jev is not a silver bullet. It doesn't generate text, it can't reason through chained questions in a single pass, and the local open-source alternatives trade accuracy for self-hosting. But for the specific problem of fast, typed decisions inside software, it represents a genuine paradigm shift.
The key insight is simple: most AI applications spend 80% of their cost and latency on decisions that don't require language generation. Jev targets that 80% with a model built specifically for it — calibrated probabilities, typed output, millisecond latency, and pennies per call.
For home lab enthusiasts who want to experiment with this pattern without cloud dependency, the open-source ecosystem (Laya, OpenJev) provides viable paths for every hardware profile — Apple Silicon via MLX, NVIDIA GPUs via Docker, and now AMD hardware via ONNX Runtime with ROCm GPU acceleration. The trade-off is accuracy versus autonomy, and for many use cases — especially those where you can validate calibration on your own data — that trade-off is well worth it.
Sources: Jev AI Tools, TypeSafe AI, Local Setup Guide, Flavio Copes Deep Dive, LangChain Blog, OpenJev GitHub, Awesome Jev, Jev Open Source Ecosystem, ONNX Runtime ROCm EP, Laya ONNX HF
Feature image: Falk2 / CC BY-SA 4.0 / Wikimedia Commons.