Using big LLMs for structured decisions costs 8-30 seconds and high token fees - Jev, a System One Model, answers in 0.1 seconds at 400x lower cost with 0.00% structural errors versus 5.73-45.50% for GPT-5.6 and Claude, plus a full limitations breakdown.
Since AI went mainstream in 2022, software development has been driven mostly by Large Language Models (LLMs) like ChatGPT, Claude and Gemini. But when developers wire these big LLMs into automated workflows - to classify data, screen safety or route decisions - they hit structural bottlenecks: slowness, high cost and unpredictable output formats.
To solve this, Diogo Almeida, a former OpenAI engineer who worked on ChatGPT, and his company TypeSafe AI launched Jev - a new breed of model in the System One Model family, designed specifically for "structured decisions" inside software systems.
1. The LLM bottleneck: using a "writer’s brain" as a "sorting clerk"
Standard LLM inference is built on Token-Based Prediction - predicting the next token word by word - which mirrors System 2 in Daniel Kahneman’s psychology: slow, deliberate, energy-hungry.
When you ask an LLM a trivial decision like "is this email spam?" or "does this message belong to finance or tech support?", what actually happens:
- Output format must be forced: prompts or JSON mode are needed to bend the LLM into returning structured JSON
- Type errors: token-by-token sampling means the model may return a long explanation instead of JSON, or invent keys outside the schema - crashing the downstream program
- Latency and cost: generating text token by token takes many seconds (8-30 in large models) and bills for both input and output tokens
- Uncalibrated confidence: LLMs are routinely overconfident even when wrong, making branching logic in code fragile
2. What are Jev and the System One Model?
A System One Model borrows Kahneman’s System 1: fast, automatic, instinctive decisions (like answering 2 + 2 instantly without deliberating).
Jev is the first model in this family, with these operating principles:
- No text generation: Jev never answers in human language, writes no code and never chats
- Single Parallel Pass: a Parallel Sampler architecture reads the entire state once and evaluates every candidate answer simultaneously - no waiting for word-by-word generation
- Trained with RLCD (Reinforcement Learning for Calibrated Decisions): if Jev is 90% confident, the answer is right 90% of the time in the real world
Jev answers through 3 core primitives:
- Choice: pick one option from a predefined list (up to 255 options), e.g. triage ticket categories
- Score: return a numeric rating against rubric criteria, e.g. customer frustration from 0 to 2 (decimals like 1.4 allowed)
- Noul: binary True/False assessment returning P(True) between 0.00 and 1.00
3. Architecture comparison: with Jev vs without
| Dimension | Without Jev (all big LLM) | With Jev (front-line decision router) |
|---|---|---|
| Process architecture | Autoregressive (token by token) | Single parallel pass (all options at once) |
| Latency | 8.5 to 37.8 seconds per decision | 70 to 500 milliseconds (average 0.1-0.4s) |
| Cost structure | $0.20-$10.00 / 1M input tokens + output fees | $0.042 / 1M input tokens (output free) |
| Structural error rate | 0.58% to 45.5% (model-dependent) | 0.00% (type errors impossible) |
| Confidence calibration | Uncalibrated (usually overconfident) | Calibrated probabilities (RLCD-based) |
| Risky-case handling | Difficult without trustworthy probability numbers | Confidence-gated routing separates auto-decide cases from human-review cases |
4. Real-world examples in software
Example 1: AI agent safety guardrails (command safety)
Scenario: a software company like Vercel builds an AI agent managing cloud infrastructure. Before the agent runs a shell command on a live server (e.g. rm -rf /data), the system must assess risk first.
Without Jev: the system asks an LLM "is this command dangerous - answer in JSON". Processing takes 8-10 seconds, stalling the agent badly - and a malformed response could accidentally execute a dangerous command.
With Jev: the system sends the command state and database structure to Jev using the Noul primitive asking is_dangerous_operation. Jev returns probability 0.96 in just 0.114 seconds at a cost under one ten-thousandth of a dollar - the code blocks the command instantly and safely.
Example 2: customer support triage and email routing
Scenario: a SaaS company receives hundreds of thousands of customer emails daily to classify by department (billing, technical, sales, spam) and score urgency.
Without Jev: routing every email through a big LLM averages $0.01-$0.03 per message plus enormous total time.
With Jev: a Choice primitive picks the department and a Score primitive rates urgency (0-100) in a single pass. When confidence exceeds 90%, tickets route automatically - saving over 400x versus LLM-everything.
5. Real test results: performance, cost and stability vs big models
In real deployments alongside enterprise systems such as Vercel and Bryo AI tests, Jev’s structural advantages showed across speed, cost and stability.
Jev is priced at $0.042 per 1M input tokens ($42 per billion) with no output-token charges. Against typical LLM input prices of $0.20 to $10.00 per 1M tokens plus output fees, Jev cuts costs by roughly 400 to 450x on decision-type work. On speed, Jev’s 70-500 ms latency (averaging about 0.114-0.4s) is 20x to 200x faster than large LLMs.
| Model | Decision accuracy | Structural errors | Tool call errors | Average latency | Cost per case |
|---|---|---|---|---|---|
| Jev (TypeSafe AI) | 67.8% | 0.00% | 0.00% | 0.114-0.400 s | ~$0.000081-$0.0004 |
| GPT-5.6 Terra (OpenAI) | 67.9% | 0.58% | n/a | 8.566-10.100 s | ~$0.0139-$0.0304 |
| GPT-5.6 Sol (OpenAI) | 74.1% | n/a | 17.00% | 23.300 s | ~$0.0500+ |
| Claude Opus 5 (Anthropic) | 73.1% | 5.73% | n/a | 37.800 s | ~$0.1761 |
| Claude Haiku 4.5 (Anthropic) | n/a | 45.50% | n/a | ~1.500 s | ~$0.0020 |
While big models like GPT-5.6 Sol or Claude Opus 5 edge out Jev in raw logical accuracy by about 5-6 percentage points, they carry structural error rates up to 5.73-45.50% and tool-call error rates up to 17.00%. In continuously running automation, a single structural error can fail the entire pipeline - Jev’s 100% format stability is therefore decisive for high-reliability systems, with the most demanding cases handed off to big models via confidence-gated routing.
6. Technical limitations and risk boundaries
Because Jev deliberately strips away text generation and multi-step reasoning, developers must understand its failure modes to use it well:
- No explanations: Jev returns only probabilities and choices, never a rationale - a hurdle for strictly audited industries like finance and medicine
- Literal interpretation: Jev processes text as written; symbols, implications and complex contradictions are weaker areas than for large language models
- Not built for math, counting or dates: it cannot compute numbers, compare hex color codes or read dates as durations - dates are just text to it
- Degrades on multi-hop logic: nested negations or analyzing properties of properties are System 2 work - hand them to a big LLM
- 64k context and Context Rot: although Jev accepts up to 64k tokens of state, stuffing irrelevant noise quickly degrades answer accuracy - feed only the state the decision truly needs
- Prompt injection exposure: Jev treats state content as plain data; embedded instructions that bias decisions can slip through - see the OWASP Top 10 for LLM Applications for practices
7. Conclusion and where this goes
Jev and the System One Model do not replace LLMs - they fill a gap in engineering-grade AI. The complete AI architecture of the near future splits the work clearly:
- System One (Jev): the front-line instinct - filtering, deciding, risk-screening and routing at millisecond speed and negligible cost
- System Two (LLMs): the analytical brain - invoked only for complex cases, composed writing or deep reasoning
Combining deterministic decision models with natural-language generation is becoming the new standard that lets enterprise AI be fast, accurate, safe and affordably real - the same principle we apply when designing AI architectures for enterprise clients: big tools only where the job is truly big, and fast cheap tools where speed is the answer.
Sources
- OWASP Top 10 for LLM Applications genai.owasp.org
