The Rise of System One AI: How TypeSafe's Jev and the 'Noul' Primitive Are Redefining Software Decisions

For the past few years, the software engineering world has been trying to force a square peg into a round hole. We have been renting massive, slow, conversational LLMs—System 2 thinkers—to make fast, intuitive, System 1 judgments. We ask generative models to decide if a message is angry, if a user intent matches a function, or if a document contains a specific clause. We write complex parsing logic to extract a simple "yes" or "no" from a paragraph of generated prose, crossing our fingers that the model doesn't hallucinate or break our JSON schema.

This architectural mismatch changed on September 15, 2026, when TypeSafe AI came out of stealth with $40M in funding and launched Jev, the world’s first public System One model. Built by Diogo Almeida—co-inventor of Reinforcement Learning from Human Feedback (RLHF)—Jev strips away the text generation entirely. Instead, it takes unstructured program state and returns typed, probabilistic decisions in a single parallel pass.

At the core of this new TypeSafe AI console ecosystem is a revolutionary data primitive known as the Noul.

Live Use Cases:

Try this completely free Entire Website SEO Health Audit, that completes 8 concurrent runs, measures more parameters than ScreemingFrog, Ahrefs, and other tools, and provides you a detailed result in 1.3 seconds, thanks to Jev. And yes, no need to even signup, or pay (obviously).

Another use case it a tool that accepts your backlinks in any format of upload, and audits them to provide you with deepest insights and value, for immediate decision making capability.

The Anatomy of the Noul

The TypeSafe API exposes three structured evaluation types: Choice (for categorical classification), Score (for numeric scaling), and Noul.

A Noul is fundamentally a boolean evaluator, but rather than returning a binary true or false, a Noul represents the probability that a specific yes/no proposition is true. When you pass a natural language instruction to the API (e.g., Noul(instructions="The message conveys urgency or time-sensitivity")), Jev evaluates the input state and returns a .noul property containing a single float from 0 to 1. This number is not just a random confidence score tacked onto a text generation; it is a meticulously calibrated probability that serves as the model's core belief.

Because there is no autoregressive text decoding, Jev does not produce conversational tokens. This subtraction buys incredible performance. End-to-end response latencies sit between 70ms and 500ms. Input tokens cost just $0.042 per million, and because the model emits a typed value instead of generating text, output tokens are completely free. You can throw massive amounts of context at a Noul in real-time without the latency penalties that traditionally kill agentic workflows.

The Evolution: From RLHF to RLCD

To understand why the Noul is so reliable, we have to look at how Jev is trained. Standard generative models rely on RLHF, a method that aligns model behavior with human conversational preferences. RLHF is fantastic for making a chatbot sound helpful, but it notoriously results in overconfident models. Standard LLMs will confidently hallucinate an incorrect JSON structure or state a falsehood with 99% certainty because they are rewarded for sounding authoritative, not for being accurate.

TypeSafe AI recognized that System One models require a different training paradigm. Jev is trained using RLCD (Reinforcement Learning for Calibrated Decisions). Instead of optimizing for human preference, RLCD optimizes the model's output probabilities directly against empirical outcomes.

If a standard LLM can classify something correctly 95% of the time but cannot reliably flag the 5% it is unsure about, you cannot safely automate around it. Because RLCD trains the Noul to be structurally calibrated, higher confidence genuinely corresponds to higher accuracy. This calibration allows developers to set hard confidence thresholds in their code. If Jev returns a Noul of 0.98, your code can automatically execute a critical function. If it returns a 0.60, your system can safely route the task to a human or a slower System 2 LLM for deeper reasoning. RLCD makes the AI a trustworthy component inside a standard if statement.

5 Transformative Use Cases for the Noul Primitive

The speed, cost, and reliability of the Noul unlock architectures that were previously impossible or economically unviable with conversational LLMs. Here are five ways developers are using the Noul to build smarter software.

1. Confidence-Gated Customer Support Routing

Traditionally, routing support tickets required chaining multiple LLM calls or relying on fragile prompt engineering. With Jev, developers are utilizing speculative fan-out patterns. Because Jev evaluates questions in parallel, you can ask 10 questions simultaneously without a time penalty.

A developer can pass a user's support history as the state and define multiple Nouls:

• Noul(instructions="The user explicitly asks for a refund or credit")
• Noul(instructions="The user is threatening legal action")

If the refund Noul returns 0.95, the code immediately triggers the refund API. If it returns 0.50, the ticket is flagged for human review. This replaces complex generative parsing with simple, deterministic routing logic.

2. Autonomous Trading and Execution Guards

In financial or autonomous systems, passing natural language straight to a function call using a generative LLM is highly risky due to hallucinations. Function calling with TypeSafe turns natural-language requests into ordinary typed functions by mapping conditions to confidence-aware questions.

Before executing a trade, an agent can compile market data and user intent into the state, querying a Noul: Noul(instructions="The user's intent unequivocally matches a market sell order for AAPL"). Because Jev has a 0% hallucination rate on structured outputs, the execution engine can trust the probability float. If the Noul is above the threshold, the trade executes; if not, it prompts the user for clarification.

3. Real-Time Interactive Agents and Gaming

The latency of token-by-token LLMs (often 3 to 30 seconds) makes them useless in real-time loops. Jev’s 70-500ms latency allows it to act as an instant decision engine for game agents or robotics.

In TypeSafe's smarthome and Doom-playing demos, the model evaluates structured game state text roughly 10 times a second. An agent can rapidly evaluate Noul(instructions="An enemy is currently visible in the forward viewport") and instantly trigger an attack animation. While it doesn't possess deep reasoning, it provides the "fast twitch" intuition that autonomous systems have been missing.

4. Parallel Document Briefings and Extraction

Extracting boolean facts from massive documents is traditionally expensive and slow. TypeSafe's cookbooks highlight running a 13-question regulatory briefing over lengthy texts like the GDPR Wikipedia article.

By batching 13 independent Nouls (e.g., Noul(instructions="The document mandates explicit user consent for non-essential cookies")) into a single TypeSafe call, the extraction is over 10x faster and 12x cheaper than asking a standard LLM one question at a time. The parallel evaluation means the model scans the 32k-token context once and returns all 13 probability floats simultaneously.

5. Multi-Stage Reasoning Cascades (SDE)

Instead of sending every task to an expensive, slow frontier reasoning model (like Opus or GPT-5), developers are building Structured Data Extraction (SDE) cascades.

In this pattern, a cheap generative model summarizes a text, and Jev is used as a highly reliable, low-cost verifier. By querying a Noul like Noul(instructions="The summary accurately reflects all numerical data in the source state"), Jev acts as a quality gatekeeper. If the Noul returns a high probability, the pipeline completes. If it returns a low probability, the system escalates the task to a high-tier System 2 model. This mini-to-verify-to-reasoning cascade achieves the quality of a massive reasoning model at a fraction of the cost.

The Future of Primitive-Based AI

The AI industry has spent years trying to make models do everything—chatting, reasoning, formatting, and deciding. TypeSafe AI’s Jev proves that composition is often better than a monolith. By isolating intuitive judgments into a fast, cheap, mathematically constrained primitive like the Noul, we can stop treating AI as an unpredictable conversationalist and start treating it like a standard software component. RLCD and System One models represent the necessary maturation of AI from a flashy demo into a reliable engineering tool.