System One Decision Models: Decoupling Classification from Generation

As a system builder, my workflow is rarely linear. While working on one problem, related opportunities and technical primitives pop up. Before I know it, I am managing multiple parallel micro-projects, testing ideas from different angles, and seeing how a single underlying concept applies across completely different domains.

Over the past few weeks, between updating web infrastructure, writing articles, and doing my coaching I have been investigating new AI architectures, one specific model stood out: Jev (from TypeSafe AI).

Where standard LLMs are trained to reason, synthesize, and generate open-ended text responses, Jev is designed as a low-latency, deterministic decision engine. It does not output natural language prose. Instead, it evaluates input states against strict question primitives and returns calibrated probabilities or typed selections directly to application code.

The Architecture: System 1 vs. System 2 in AI Pipelines

In cognitive science, Daniel Kahneman introduced the distinction between System 1 (fast, instinctual, binary judgment) and System 2 (slow, deliberate, analytical reasoning).

Current AI pipeline design routinely over-allocates resources by using System 2 generative LLMs for System 1 tasks:

The Problem: Using a full LLM or Vision Model to evaluate simple conditions, like rating email priority, categorizing a file, or checking if an image contains a person, requires sending large system prompts, enforcing JSON Schemas via structured output constraints, and parsing text output. This introduces high latency, high token costs, and potential schema drift or formatting failures.

The Solution: A dedicated decision model evaluates statements directly against fixed primitives, returning raw probabilities or enumerated choices without generating intermediate text tokens.

Instead of open-ended generation, the model evaluates input against three core decision types:

Choice (Multi-Class Selection): Selects one option from a pre-defined set (X, Y, Z) and returns a probability distribution.

Score (Ordinal Rating): Evaluates input against a numeric scale (e.g., rating email importance from 1 to 5).

Binary / Null (Boolean Assessment): Evaluates a proposition (e.g., "Is this picture an animal?") and returns a probability score between 0 and 1.

Three Real-World Implementations

Testing Jev across three active projects highlighted where low-latency decision models solve real engineering bottlenecks:

1. CerAImic Nerve Center: Quality Control Gates

In my CerAImic Nerve Center framework, passing unvalidated natural language between agents introduces compound drift, latent errors, and schema failures.

By placing Jev at the boundary of agent execution, it acts as a high-speed circuit breaker:

Input Gate: Evaluates incoming payloads before calling expensive reasoning models ("Is context sufficient?", "Is prompt injection present?", "Select target domain agent: A/B/C").

Output Gate: Evaluates agent outputs against expected quality criteria ("Does this conform to schema?", "Is confidence > 0.85?"). If Jev flags a failure, the Nerve Center rejects or reroutes the payload immediately without downstream propagation.

2. Automated Media Sorting: Disentangling Downloads

Like many collectors of memes, political commentary, and online media, my downloads folder frequently degrades into a single flat directory of non-descriptive filenames (e.g., IMG_94021.jpg).

Running every incoming image through a commercial Vision LLM API to write captions and suggest folder structures is far too slow and cost prohibitive. By running Jev locally on my own stack, I can process thousands of downloaded images continuously with zero API token costs and near-instant local response times.

Using Jev as a first-pass vision classifier changes the pipeline:

A directory watcher triggers on new file creation.

Jev Vision Primitives:

Files with high confidence scores (>0.90) are automatically renamed and moved to their destination folder in milliseconds. Only ambiguous files (Unknown or low confidence) are forwarded to a full vision LLM for deep text extraction or manual review.

3. Edge Security Infrastructure: Scaling Multi-Camera Workflows

Early in my consulting work, I built an automated system for a security firm where camera motion alerts triggered AI image evaluation to notify security agents whether a person was an employee, family member, or unknown individual. While vision LLMs handled this well conceptually, they failed on speed and operational cost when scaled.

At large venues or multi-camera facilities, streaming high-frequency video frames to a vision LLM destroys token budgets and introduces multi-second delays into critical alert loops.

Implementing Jev creates a multi-tiered security pipeline:

Tier 1 (Motion Detection): Triggers frame capture on physical movement.

Tier 2 (Jev Vision Gate): Evaluates boolean and choice primitives in milliseconds ("Is human present?", "Is uniform/badge visible?", "Threat score 1-5").

Tier 3 (Vision LLM / Human Notification): If Jev registers a high threat score or an unrecognized subject, it escalates the payload to a generative vision model for detailed scene synthesis and pushes an alert to security personnel.

Engineering Summary

Decoupling decision-making from text generation prevents compute bloat. By placing fast, cheap, and calibrated decision engines at the perimeter of an architecture, you protect heavy reasoning models, enforce strict quality controls, and keep processing pipelines both fast and cost-effective.