In 2011, psychologist Daniel Kahneman popularized the ideas surrounding dual process theory in his book “Thinking, Fast and Slow”. Its main thesis is a differentiation between two modes of thought: “System 1” is fast and instinctive, while “System 2” is slower, more deliberative, and more logical. The book summarizes decades of research to suggest that we have too much confidence in human judgment and proposes methods to make better decisions based on probabilities rather than heuristics.
According to Kahneman, we humans struggle to reason probabilistically. We tend to associate new information with existing patterns or thoughts, rather than creating new patterns for each new experience. The easier it is to recall the consequences of something, the greater we perceive those consequences to be. We fail to account for complexity and the fact that our understanding of the world consists of an insufficient set of observations. We underestimate the role of chance and therefore falsely assume that the future will be like the past.
One of the biggest challenges for software developers incorporating LLMs into system architectures is that for the past eighty years, computer science has involved cold, hard, deterministic logic. Compiled source code produces instruction sets that flow through chains of AND, OR, NOT, NAND, NOR, XOR, and XNOR gates made of transistors. The same input always results in the same output. This speed and predictability are what have made computers so reliable for high-stakes systems. LLMs, on the other hand, are highly probabilistic systems that take text input and produce a variant output each time. This output may also be false, hallucinated, non-factual, and convincing. In other words, they have a reliability profile similar to or worse than the humans they are trained to interface with.
This randomized and unreliable output is related to the “slop” problem. Trained on the corpus of human language and aligned to be sycophantic, answers may be presented in verbose ways that unintentionally exploit our cognitive biases surrounding framing, anchoring, and optimism. As LLMs penetrate more of our human knowledge space, we are confronted with a staggering cognitive load problem related to verification. Productivity gains are already proving to be offset by the deleterious effects of cognitive offloading and the compounding problem of accurate verification. Knowledge workers are now part of systems where agents automate, but are constrained by the processing and decision speed of their minders.
As of this writing, the hallucination rate for frontier AI models can vary significantly, with reports indicating that frontier models still have startlingly high hallucination and inaccuracy rates. Additionally, purpose-built legal AI tools have shown an error rate of over 17% despite being marketed as hallucination-free.
While it’s clear that LLMs are miraculous, these failure rates are underrepresented and drowned out by the hype surrounding AI writ large.
Why are the rates so high? It’s a side effect of how they work and how they’re trained. Reinforcement Learning from Human Feedback (RLHF) optimizes models for human preference rather than factual correctness. RLHF trains models to fabricate plausible-sounding explanations rather than signal a lack of knowledge, inadvertently encouraging hallucinations through reward hacking.
LLMs are thus necessarily limited by design in their potential for systems automation with any substantial stakes. We keep coming back to the fundamental problem that a probabilistic black box with a high hallucination rate cannot be used as part of a system where failure could lead to substantial liability. Society seems to be finally coming around to this realization in a hilarious unfolding drama as OpenAI and Anthropic approach their IPOs while simultaneously doom-trolling an anxious public and begging for regulation. Alex Karp has his own incentives, but at least he’s willing to point to the emperor’s clothes and make the astute observation that these soon-to-be publicly traded companies have a massive liability problem related to reliability, intellectual property, privacy, and misuse. Amodei and Altman cannot square their ethical dilemma of aligning a fundamentally unreliable model paradigm with the “Godmode” panacea the public perceives and their investors are banking on.
This raises a question: are we extrapolating possible outcomes based on the wrong technology? The question is not “to AI or not to AI”, but what AI architecture should we choose and where is it appropriate to apply it. It is not a foregone conclusion that general-purpose transformer large language models are the right solution; its just the one that the brute-force approach of scaling compute demonstrated first and attracted all the venture capital.
Diogo Almeida, an OpenAI veteran, co-inventor of reinforcement learning from human feedback (RLHF), and contributor to InstructGPT and GPT-4, has noted that this glaring reliability problem requires entirely different approaches.
His argument is that products like ChatGPT and Claude Code represent increasingly capable iterations of a single paradigm: AI assisting a human who remains in the loop. If every automated process requires human supervision to guard against inherent unreliability, the system is no more autonomous than traditional deterministic software. We were automating long before LLMs. This dynamic imposes an artificial ceiling on what automation can achieve.
During a July presentation at the AI Engineer World’s Fair, Almeida asked a critical question: why does artificial intelligence seem simultaneously amazing and disappointing? He highlighted two contradictory views of the current technology landscape.
On one side, progress appears extraordinarily rapid:
- Models routinely surpass human performance on benchmarks.
- Capabilities continue to expand.
- Autonomous operating windows are lengthening.
- Systems accomplish complex intellectual tasks.
On the other side:
- Systems remain unreliable.
- Software engineering has not fundamentally transformed.
- Businesses cannot trust models with high-stakes decisions.
- Humans remain necessary for basic operational tasks.
- Most commercial products remain limited to chat interfaces and coding assistants.
Why can models solve advanced mathematics and protein folding problems yet fail at basic operational decisions? Because current systems were designed using RLHF and human-in-the-loop training rather than for direct task automation. The objective of RLHF is to assist and please a human operator, not to make independent probabilistic decisions. This does not fix the failures related to how a model stores “facts” or how it internally measures its own uncertainty.
Preference optimization has a distinct consequence, according to Almeida: models excel at appearing correct. We’ve optimized them to lie. He uses a humorous example. Give ChatGPT an audio file of farts and ask it to evaluate the “music.” Rather than identifying the recording, the model produces a thoughtful artistic interpretation.
Almeida’s new AI model, Jev, uses a different paradigm. It makes fast, inexpensive judgments without hallucinations instead of generating text. Rather than returning natural language for text prompts, Jev returns typed probabilistic decisions for other software or AI models to use.
Jev wasn’t trained on human preferences and doesn’t give a damn about them. It classifies input and provides clear direct confidence scores as probabilities. Jev uses a training method called Reinforcement Learning for Calibrated Decisions (RLCD) that optimizes the model so that its output probabilities reliably match actual accuracy. If Jev assigns a 90% probability to a structured choice, it is trained to be correct approximately 90% of the time, making its uncertainty metrics mathematically honest.
An AI’s probability score acts as the mathematical version of Daniel Kahneman’s WYSIATI (What You See Is All There Is) rule, representing confidence based strictly on its internal “known knowns”—its training data and prompt. By making probability explicit and mathematically calibrated, RLCD turns an AI’s confidence score into something actionable. Software developers can set strict thresholds—instructing the system to automatically execute a decision if the calibrated score is above 95%, but escalate to a human the moment the score drops, explicitly acknowledging when the AI has hit a blind spot.
To be clear, single pass classifier models date back to 2018 and zero-shot label pipelines to 2019. JEV does something that none of the older approaches can touch, which is dynamic instruction following without retraining. Unlike static classifiers that require retraining when labels or policies change, JEV can adapt to new semantic instructions at runtime.
This approach is invaluable when AI interactions require constrained answers for deterministic handling. When fed structured game-state data, for example, Jev can play video games like Doom at high speeds and with excellent results, demonstrating its utility for general automation.
With Jev, developers provide a state value, such as a JSON object or a string like “My card was charged twice.” The model evaluates this state using question primitives—Choice, Score, and Noul—which return typed, probabilistic responses.
For example, a routing query asking which department should handle a customer service ticket returns structured data: {“billing”: 0.08, “technical”: 0.85, “sales”: 0.07}, accompanied by a confidence score of 0.82.
While this format offers little value to end users seeking soothing and confident conversational answers, it provides software developers with the structured data required for reliable classification and decision-making.
The core proposition is that when software requires a specific operational decision like approval, rejection, routing, or tool invocation, generating natural-language text creates unnecessary ambiguity and error-prone overhead. A specialized decision model delivers required intelligence faster, cheaper, and in formats software consumes directly.
This principle mirrors general software engineering: apply appropriate abstractions instead of using one general-purpose tool for every problem. More importantly, it marks a broader evolution in artificial intelligence where models transition from systems designed to communicate with humans toward computational components embedded within autonomous software architectures.
The most important implication of Jev is not some revolutionary godlike intelligence potential, but its incredible speed, cost efficiency and practical fit in systems architecture.
Which of these options would describe an appropriate component in your system automation design?
A. Insanely fast, cheap, predictable and explicit.
B. Slow, expensive, unpredictable and ambiguous.
For automated software systems making thousands or millions of small decisions, repeated language generation is prohibitively expensive. The economics of artificial intelligence change dramatically when intelligence becomes this cheap.
Jev is positioned around a different cost structure. According to TypeSafe, it is priced at $0.042 per million input tokens, while output tokens are described as too inexpensive to meter. The significance is not merely that one model may cost less than another, but that lower inference costs can change what developers consider economically feasible.
The performance claims are substantial. Jev is extremely fast. TypeSafe reports that Jev is 193.6 times faster and 444.6 times cheaper than frontier models in peak in-house testing, with a cost per decision of approximately $0.0004 and pricing at $0.042 per million input tokens, with output tokens priced at zero. Independent testing from Every corroborated these directional claims, finding Jev roughly 25 times faster and 580 times cheaper than Claude Fable 5.1 on extraction tasks at 0.35 seconds versus 8.83 seconds per passage.
An autonomous agent may perform dozens of decisions during a single task. If each decision introduces substantial latency, cumulative delay becomes noticeable. Faster bounded models could operate as an intermediate control layer, making rapid decisions while larger models handle more complex stages.
The architecture embodied by Jev maps cleanly onto Daniel Kahneman’s framework of cognitive processing. System One thinking relies on fast, automatic, and low-effort intuition, whereas System Two engages in slow, deliberate, and computationally heavy reasoning. Traditional frontier language models have historically forced software systems to deploy heavy System Two machinery for every minor classification and routing task, creating massive latency and prohibitive costs. By providing an ultra-fast, inexpensive primitive for routine operations, this new class of models handles the high-frequency System One equivalent of automated decision-making. Meanwhile, larger models remain reserved for deliberate System Two analysis.
This design inherently shifts more of the burden of accuracy to engineering and systems designers. While the underlying mechanics remain probabilistic, this reality is made explicit through its typesafe output and “multiple choice” I/O, which lends itself to more thoughtful application and thus greater reliability. Developers must intentionally design their agent pipelines to accommodate clear probabilistic boundaries in business logic rather than relying on generalized generative models to paper over structural errors.
This division of cognitive labor carries profound implications for industry economics as low-cost automation solidifies its position as a primary revenue driver. When the marginal cost of routine machine decisions approaches zero, enterprises can scale autonomous agents across complex multi-step workflows without incurring destructive cloud infrastructure bills or crippling user-facing delays. Industries dependent on massive transaction volumes, real-time data extraction, and continuous operational triage will likely shift toward modular, tiered intelligence stacks. Companies that successfully integrate these layered cognitive models will capture a distinct competitive advantage, transforming high-frequency automation from an expensive luxury into a high-margin foundation for enterprise growth.