JJoche Ojeda.NET · XAF · AI · architecture
Sep 25, 20266 min read/2026/09/25/system-1-and-system-2-ai-model-types/

System 1 and System 2: The Two Types of AI Thinking (and Why Jev Is a "System One" Model)

JevSystem OneSystem TwoReasoning ModelsKahnemanLLM

I've written three posts about Jev now — what it is, how to test it from C#, and what can replace it. In all three I kept using a phrase — "System One" model — as if it were obvious. A reader asked the fair question: what actually are System 1 and System 2, and why does Jev call itself one of them?

The name isn't marketing. It's borrowed, almost verbatim, from how psychologists describe human thinking — and once you see the two types, you stop asking "which model is smartest" and start asking the far more useful question: which kind of thinking does this decision even need?

Where the names come from

In Thinking, Fast and Slow, Daniel Kahneman split human cognition into two modes. System 1 is fast, automatic, effortless, intuitive — it's what reads a word, recognizes a face, or answers "2 + 2" before you've decided to. System 2 is slow, effortful, deliberate — it's what multiplies 17 × 24, plans a route, or weighs a contract clause. System 1 is always running and almost free. System 2 is powerful, expensive, and lazy — you invoke it only when System 1 can't cope.

The crucial part Kahneman spends a whole book on: we constantly mistake one for the other. We let fast, confident intuition answer questions that actually needed slow, careful reasoning — and, less often noticed, we burn slow deliberation on things intuition had already nailed.

That is exactly the mistake teams are now making with AI models.

The two types of AI model

Until recently, "an LLM" meant one thing. In 2026 there are two genuinely different kinds of model, and they map onto Kahneman's split with almost no distortion.

System 1 models — answer in one reflex

A System 1 model takes your input and returns an answer in essentially a single forward pass. No visible deliberation, no intermediate steps, no narration. It pattern-matches and commits.

  • What it is: a classifier, an embedding-based router, a constrained-decoding pick — and, purpose-built, Jev, which takes context plus a set of typed questions and returns a typed value with a calibrated probability in ~0.4 seconds.
  • Strengths: fast, cheap, and — when built right — calibrated, meaning its confidence actually tracks how often it's right. Bounded output: it returns one of your options, never a paragraph, never malformed.
  • Limits: it does not reason. No chain of steps, no self-correction, no explanation of why. Ask it something that genuinely requires working through sub-problems and it will still answer instantly — and confidently — and sometimes wrongly. That's not a bug; it's what "fast" costs.

System 2 models — deliberate before answering

A System 2 model thinks before it answers. It spends inference-time compute generating intermediate reasoning — chain-of-thought, exploring options, checking itself — before producing a result. This is the family of "reasoning" models: the o-series, extended-thinking modes, test-time-compute approaches.

  • What it is: a model that produces (and often hides) hundreds or thousands of reasoning tokens on the way to an answer.
  • Strengths: genuinely solves multi-step problems — proofs, multi-hop analysis, planning, tricky code. It can show its work, and more thinking measurably improves hard-task accuracy.
  • Limits: slow and expensive, sometimes by orders of magnitude. And it "overthinks" — burn it on a trivial classification and you pay for a page of deliberation to produce an answer System 1 had in one pass.

The mistake almost everyone is making

Here's the pattern I see in real systems: a support ticket comes in, and it's fed to a frontier reasoning model with a prompt like "think step by step about which team should handle this and respond in JSON." That is System 2 pricing for a System 1 decision. Routing a ticket into one of five buckets is a reflex, not a proof. You're paying a mathematician to answer "2 + 2" — slowly, and with a paragraph of justification you throw away.

The inverse mistake is rarer but just as real: handing a genuinely hard, multi-step problem to a fast classifier and trusting its instant, confident answer. Fast and confident is not the same as correct.

The skill in 2026 is not choosing the smartest model. It's classifying your own decisions — is this a fast decision or a slow one? — and routing accordingly.

They're not rivals — they're a hierarchy

The best architecture isn't "pick one." It's the same one your own brain uses: System 1 runs everything by default, and escalates to System 2 only when it isn't sure.

A System 1 model like Jev gives you the two things that handoff needs: a bounded answer and a calibrated confidence. So the rule becomes trivial — take the fast answer when confidence is high; when it drops below a threshold, abstain and escalate to a reasoning model or a human. That's not a metaphor. It's a few lines of code, and it's the whole reason I keep every engine behind one IDecider in github.com/egarim/systemone-deciders:

// System 1: fast, cheap, calibrated. Answers in one pass.
var fast = await system1.ChooseAsync(ticket, "Which team?", teams, abstainBelow: 0.75);

if (!fast.Abstained)
    return fast.Value;                      // confident reflex — done, ~0.4s, fraction of a cent

// System 1 wasn't sure. Escalate to System 2: slow, expensive, deliberate.
return await system2.ReasonAsync(ticket, "Which team, and why?");

Most traffic never reaches the second call. You pay System 2 prices only for the genuinely hard minority — exactly as your own attention works. The calibration is what makes this safe: if the fast model's confidence didn't track reality, the threshold would be meaningless and you'd either escalate everything (no savings) or escalate nothing (wrong answers). Calibrated confidence is the interface between the two systems.

Where Jev fits

Jev is a purpose-built System 1 model — the first one marketed explicitly as its own category rather than a small chat model in disguise. It doesn't try to reason; it tries to be the fastest, cheapest, best-calibrated reflex you can put in front of a decision. That's why its own name is a warning: Jev is named after Jevons, the economist who observed that when a resource gets cheaper, you consume far more of it. When a good decision costs 0.4 seconds and a fraction of a cent, you stop rationing decisions — you put one at every branch in your system. The System 1 layer is what makes that affordable.

And the field is converging on this two-system view from several directions at once: Meta's researchers are working on "System 2 distillation" — teaching a model to fold slow reasoning into a fast reflex — while router approaches like DynamicMind switch a single model between fast and slow modes per query. Different mechanisms, same insight: match the system to the task.

The takeaway

There are now two kinds of AI thinking, and they are as different as recognizing a face and proving a theorem:

  • System 1 — one reflexive pass, fast, cheap, calibrated, bounded, no reasoning. Jev, classifiers, constrained decoding.
  • System 2 — deliberate, slow, expensive, shows its work, solves genuinely hard problems. Reasoning models, chain-of-thought, test-time compute.

Neither is "better." The teams that win in 2026 are the ones who stop paying System 2 prices for System 1 decisions — who let a fast, calibrated model handle the reflexes and reserve the slow, expensive thinker for the problems that are actually hard. Build the handoff, put a confidence threshold at the seam, and your system starts to think the way you do: fast by default, slow on purpose.

Building a System 1 → System 2 handoff in .NET, or arguing that the whole framing is too tidy? Tell me via the links on the about page.