JEV and System One Models: How AI Agents Make Decisions for $0.04 per Million Tokens

AI coding agents hit an economic wall: every frontier model call costs $5–50 per million tokens. For routine tasks — type validation, format checking, binary decisions — this is overkill. In September 2026, TypeSafe AI released JEV — the first System One model that solves this problem radically: $0.042/MTok input, output free, 70–500ms latency, zero hallucinations.

What Are System One Models

Traditional LLMs are System Two models. They generate text autoregressively: token by token, building a chain of reasoning. This is universal, but slow and expensive.

System One models work differently. They don’t generate text — they make decisions. The mechanics:

1. Parallel sampling — the model evaluates multiple answer options simultaneously
2. RLCD (Reinforcement Learning for Calibrated Decisions) — reinforcement learning for calibrated decisions
3. Non-autoregressive generation — the model outputs a ready decision, not a step-by-step derivation

Result: 40–200× faster than LLMs, no hallucinations, no type errors. The model doesn’t “invent” an answer — it reads it from the probability distribution.

Cognitive psychology analogy: System Two is when you solve 237 × 48 long-form. System One is when you instantly know that 7 × 8 = 56. The first requires effort and time, the second is intuitive and instant.

JEV is named after William Stanley Jevons — a 19th-century economist who studied the relationship between resource usage efficiency and total consumption (Jevons Paradox).

JEV-as-a-Judge: The Cascade Approach

The arXiv:2609.26550 paper (Li, Miao, Krishnan, Padman — Carnegie Mellon) shows how JEV works as a judge for decision validation.

JEV-as-a-Judge metrics:

Cascade (accept confident, escalate unsure):

JEV returns not only a decision but also a confidence score. If confidence is high — the decision is accepted. If low — the task escalates to a frontier model.

Cascade results on 1,610 held-out pairs:

• Accuracy: 0.9 points higher than GPT-6
• Cost: 41% of GPT-6 cost

This is not a compromise — it’s an improvement. The cascade catches edge cases where JEV is uncertain and passes them to the powerful model. Routine tasks are handled cheaply and quickly.

Where JEV is weaker: math, code, logic — tasks where the verdict needs to be derived (reasoning), not recognized (pattern recognition). For such tasks, the cascade escalates to frontier models.

JEV Primitives: Choice, Noul, Score, Box

OpenRouter integrated JEV with 4 primitives for different decision types:

1. Choice — binary or multiple selection

• Example: “Is this code correct? Yes/No”
• Example: “What type of error? TypeError / SyntaxError / RuntimeError”

2. Noul (Null or Value) — checking for value presence

• Example: “Is this parameter required? Yes/No”
• Example: “Is the field filled correctly? Yes/No”

3. Score — numerical rating

• Example: “Rate this code quality from 1 to 10”
• Example: “How relevant is this document? 0.0–1.0”

4. Box (jev-1.14 only) — object localization on images

• Example: “Where is the Submit button on the screenshot?”
• Returns bounding box [x, y, width, height]

Context: 262,144 tokens — enough to process large files and documentation.

Ecosystem: 22 decision models from 13 providers:

• OpenAI: gpt-6-luna-decisions
• Microsoft, Perplexity
• Cloudflare Clef
• Inception Mercury
• Liquid AI
• Upstage Solar

OpenRouter Cookbooks:

• Gate Agent Tool Calls — validate agent tool invocations
• Auto-Approve Coding Agent Permission Prompts — auto-approve permissions for Claude Code, Codex, Cursor, OpenCode
• Cut LLM Cost with Jev-Verified Cascade — cascade for cost savings

TaoCoder Integration: How We Use JEV

In TaoCoder (our AI agent platform for enterprise development), JEV handles three tasks:

1. Stage Gate

JEV works as a controller for transitions between agent stages. Before moving to a new stage (e.g., from writing code to testing), JEV checks:

• Does the result match the specification
• Are there type errors
• Are imports and dependencies correct

If JEV is confident (confidence > 0.85) — the agent moves to the next stage. If not — the agent stays on the current stage and refines the result.

Result: 70% of routine checks processed at $0.04/MTok instead of $15/MTok. Savings — 99.7%.

2. Gate for Terminal Commands

Agent calls a terminal command (execute_command) → JEV validates:

• Parameters are correct
• File path exists
• Command is safe (no rm -rf /)

If validation fails — the agent gets an error before execution, not after.

Result: 95% of errors caught before execution. Savings on rollbacks and repeated iterations.

3. Self-validation for the Agent

The agent can call JEV itself to check its own code through a special tool. JEV rates quality (Score 0.0–1.0) and returns the result to the agent:

• If score > 0.8 — the agent continues working
• If score < 0.6 — the agent sees issues and refines the code
• If 0.6–0.8 — the agent gets feedback and decides what to improve

Result: the agent controls code quality itself at $0.50–2.00 instead of $5–15 for external review.

Economics: JEV vs Frontier Models Cost Comparison

Cost comparison for typical tasks:

Typical enterprise project profile (10,000–40,000 lines of code):

• Without JEV: $50–150 on tokens (all tasks on frontier models)
• With JEV cascade: $15–40 on tokens (70% tasks on JEV, 30% on frontier)
• Savings: 60–75%

These are not theoretical calculations — we measured on real projects. JEV doesn’t replace frontier models, but radically reduces costs for routine tasks.

Limitations: Where JEV Doesn’t Work

Honest about limitations — JEV is not universal:

1. Math, code, logic — reasoning tasks

JEV is weaker on tasks where the verdict needs to be derived (step-by-step reasoning), not recognized (pattern recognition).

Examples:

• “Prove this algorithm is correct” — needs reasoning
• “Solve equation x² + 5x + 6 = 0” — needs reasoning
• “Find the bug in this code” — needs reasoning

For such tasks, the cascade escalates to frontier models.

2. Text Generation

JEV doesn’t generate text — it makes decisions. If you need to write an article, documentation, or code — JEV is not the tool.

3. Creative Tasks

“Come up with a product name”, “Suggest an architecture” — these are System Two tasks. JEV is not suitable.

4. Context > 262K Tokens

JEV supports 262,144 tokens of context. For most tasks this is enough, but for processing huge codebases (> 100,000 lines) you need to split into parts.

When to Use JEV

Use JEV for:

• Type and format validation
• Binary decisions (yes/no, correct/incorrect)
• Specification compliance checking
• Terminal command gate
• Code review (quality scoring)
• Error classification
• Safety checks (no dangerous commands)

Use frontier models for:

• Code, text, documentation generation
• Architectural decisions
• Code review with detailed step-by-step reasoning
• Math, logic, complex algorithms
• Creative tasks

Optimal strategy: cascade. JEV handles routine, frontier models — edge cases and complex tasks.

Conclusion

JEV and System One models are not a replacement for frontier models, but a radical cost reduction for routine tasks. For AI agents this means:

1. 60–99% savings on tokens for validation, checks, binary decisions
2. 70–500ms latency instead of seconds — the agent works faster
3. Zero hallucinations — JEV reads from the distribution, doesn’t generate
4. Cascade improves accuracy — 0.9 points higher than frontier model without cascade

In TaoCoder we integrated JEV as a stage gate, a terminal command barrier, and a self-validation tool for the agent. Result: enterprise projects cost $15–40 on tokens instead of $50–150.

System One models are not the future. This is the present. JEV is already available through OpenRouter, integrated into TaoCoder, and running in production.

If you’re building AI agents for enterprise tasks — rethink the architecture. Not all tasks require frontier models. For 70% of routine checks, JEV is sufficient, 100× cheaper and 40–200× faster.

Read also:

• TAO·CODER: Enterprise Development on Flash Models for ~$200
• Custom Modes and Scheduler: How an AI Agent Works on Schedule
• VSL: AI Agents Work with Web Pages Without Screenshots

Contacts:

• THINKING•OS AI Lab: https://thinkingos.tech
• TaoCoder: https://thinkingos.tech
• Email: hello@thinkingos.tech