System 1 vs System 2 in AI: Fast by Default, Slow on Purpose

A practical guide to fast decision models, reasoning LLMs, and the architecture that connects them.

Image: Milad Fakurian / Unsplash. Conceptual illustration, not a depiction of separate brain systems.

A support message arrives: “I was charged twice. Please refund the duplicate payment.”

An AI system could send the entire request to a reasoning model. It could generate a plan, interpret the message, identify the payment issue, decide which tool to call, inspect the account and draft a response.

Or it could recognize the billing intent immediately, extract the relevant identifiers, retrieve the transaction record and apply a deterministic duplicate-payment check. Only an ambiguous case would need a reasoning model.

The second design reserves expensive computation for the part of the job that actually needs it. It also separates interpretation from permission: recognizing a refund request does not authorize a refund.

That is the useful engineering idea behind System 1 and System 2 AI.

The distinction, in one image

AGNT field guide. Save the comparison as a reference. These are operating modes, not universal model categories or latency guarantees.

Download the square infographic (2160 × 2160 PNG)

Share it or embed it on your own site. Please keep the credit link:

<a href="https://agnt.gg/articles/research/system-1-vs-system-2-ai">
  <img src="https://agnt.gg/assets/articles/system-1-vs-system-2/system-1-vs-system-2-infographic.png"
       alt="System 1 vs System 2 in AI: fast decisions versus deliberate reasoning" width="1080" height="1080">
</a>
<p>Infographic by <a href="https://agnt.gg/articles/research/system-1-vs-system-2-ai">AGNT</a></p>

Two modes of AI: fast decisions and deliberate reasoning

Daniel Kahneman popularized the distinction in Thinking, Fast and Slow: System 1 is fast, automatic and associative; System 2 is effortful and deliberate. In AI architecture, the analogy describes two complementary ways to handle a task.

• System 1 emphasizes fast decisions: classifiers, entity extractors, routing models and structured decision models such as Jev.
• System 2 emphasizes deliberate reasoning: reasoning-enabled LLMs, planners, search procedures and tool-using deliberation loops.

The distinction concerns how a system solves a problem. A direct response draws on learned patterns; a deliberative process spends additional computation exploring, checking or revising an answer. Model size and inference strategy are separate design choices, and an LLM can serve either role.

The survey From System 1 to System 2 traces the development from foundational LLMs to reasoning LLMs. The Talker–Reasoner architecture illustrates how the roles work together: a fast component handles conversation while a separate component performs planning and tool use. [1][2]

For engineers, the choice is where to use a direct prediction and where additional reasoning is worth the time and cost.

System 1: decide without generating an essay

Many software decisions have a small output space. A request belongs to a support queue. A document contains a company name. A proposed response satisfies a rubric. An incoming message needs escalation.

Generating free-form text for each of those decisions adds work that the application may never use. Specialized models instead target the output the software actually needs: a class, a span, a score or a typed judgment.

GLiNER: extract the information

GLiNER is a compact named-entity recognition model built around a bidirectional transformer. Given text and entity types, it identifies matching spans rather than generating an answer token by token. Its original paper describes parallel entity extraction and reports strong zero-shot results on the NER benchmarks studied. [3]

That makes it a useful candidate for extracting names, organizations, dates or domain-specific entities before a larger model sees a document. Zero-shot flexibility also matters: a fast model need not be confined to the fixed label set of a traditional classifier.

The boundary remains important. Extracting a clause, a company or a date does not establish what a contract legally permits. An entity extractor is not a general-purpose analyst, and an extraction score is not a guarantee that sensitive information has been found exhaustively.

Jev: make the typed judgment

TypeSafe presents Jev as a “System One” model designed for structured decisions rather than string generation. The intended interface is unstructured state in, typed answers and probabilities out. Routing, evaluation and guardrail decisions are natural applications. [4]

An extraction model asks, “Where is the information?” A decision model can ask, “Which option best fits this state?” Those are related, but different, jobs. Jev and GLiNER should not be treated as interchangeable tools.

There is an important caveat to TypeSafe's claim that Jev “can't hallucinate.” A model that cannot generate arbitrary prose avoids that particular output failure. It can still select the wrong option, misjudge a case or attach misleading confidence to a decision. Output validity and factual correctness are separate properties.

What the early benchmarks actually show

LiteLLM reported a routing benchmark comparing a pinned Jev version with Claude Haiku 4.5. Each classified 80 authored cases three times, for 240 measured calls per classifier. [5]

Metric	Jev	Haiku
Median classifier latency	126.81 ms	688.40 ms
Match with authored expected tiers	95.00%	73.75%

LiteLLM reported 5.43× faster median classification and 96.12% lower registry-priced classifier cost. Its own limitations deserve equal attention: the prompts were synthetic, the expected tiers had no independent review, and the study did not evaluate final-answer quality.

Separately, LangChain reported promising Jev evaluation results, including 0.44 seconds average latency and lower continuous-score variance in its test. That is a different workload with a different latency statistic; it should not be merged with LiteLLM's median into one universal performance claim. Consistency is also not accuracy: a judge can repeatedly give the wrong score. [6]

These results make a strong case for testing specialized decision models on your own workload. They do not establish that a fast model replaces a general-purpose LLM.

System 2: spend computation to improve the answer

Some tasks resist immediate classification. A production incident has conflicting evidence. A migration must preserve multiple invariants. A question requires combining information from several documents. A plan must account for what earlier actions changed.

Here, additional inference-time work can be useful: decomposing the task, exploring alternatives, calling tools, testing a candidate and revising it.

Chain-of-thought prompting was an important step. Wei and colleagues showed that intermediate reasoning demonstrations improved performance on arithmetic, commonsense and symbolic reasoning tasks in the models they studied. [7]

Later work broadened this into test-time computation: repeated sampling, self-correction, search and other ways of spending inference resources. The test-time-compute survey organizes these techniques along the progression from intuitive inference toward deliberate reasoning. [8]

In practice, the reasoning model is often only one component. A coding agent can propose a patch; the compiler and tests supply evidence about whether it works. A financial assistant can explain a reconciliation; a ledger query supplies the underlying transactions.

Longer reasoning is not inherently better. The paper Do NOT Think That Much for 2+3=? studies overthinking: spending excessive computation on simple problems for little benefit. Its proposed methods reduce overhead while preserving performance on the evaluated tasks. [9]

Nor does a fluent explanation prove the conclusion. For consequential work, the target should be a result supported by checks, rather than a convincing account of how the model says it reached it.

Why this idea keeps returning

The System 1/System 2 connection predates the current product announcements.

In his 2019 NeurIPS lecture, Yoshua Bengio argued for expanding deep learning beyond intuitive perception toward reasoning, planning, causality and systematic generalization. That was a research agenda, not a claim that making a model slower makes it intelligent. [10]

Several later research threads give the metaphor practical substance:

Research thread	What it contributes
Chain-of-thought prompting	Intermediate steps can improve task performance. [7]
Reasoning LLMs and test-time compute	Inference effort becomes an explicit design variable. [1][8]
Talker–Reasoner agents	Conversation and deliberation can be assigned different responsibilities. [2]
SOFAI	A metacognitive component selects between fast and slow solvers. [11]
System 2 distillation	Some benefits of expensive reasoning can be transferred into cheaper direct responses. [12]
Structured decision models	Classification and judgment can have a dedicated interface instead of being expressed as generated prose. [4]

These lines of work support a practical conclusion: choosing how much computation to spend is itself part of the system design.

The difficult component is the switch

A fast model and a strong reasoning model do not automatically make a good hybrid. The router must decide when the fast result is sufficient and when it is dangerous to trust it.

SOFAI makes this explicit through a metacognitive module coordinating fast and slow solvers. Its published experiments concern particular planning and decision tasks, not a universal guarantee about hybrid agents. The architectural lesson is still valuable: the controller deserves its own evaluation. [11]

Production routing depends on four questions:

1. Capability: Can the fast path handle this kind of task?
2. Uncertainty: Is its confidence meaningful on cases like this one?
3. Risk: What happens if the decision is wrong?
4. Authority: Is the resulting action permitted?

A classifier may be highly confident that a message requests deletion. That confidence says nothing about whether the sender may delete the account.

Likewise, a score of 0.95 should not be treated as a 95% chance of correctness without calibration evidence. Thresholds need to be chosen against labeled, representative data, with separate attention to costly errors and distribution shifts.

A practical architecture therefore looks like this:

Input
  → deterministic validation and access checks
  → extraction and fast decision
  → risk-aware routing
      → routine, supported case → bounded action policy
      → uncertain or complex case → reasoning and tools
      → high-stakes case → required review or approval
  → tests, rules or external verification
  → action and recorded outcome

In this architecture, the policy gate enforces permissions independently of model output. A model can recommend an action; authorization rules determine whether it may proceed.

Worked example: the refund request

Return to the customer who says they were charged twice.

The fast path can identify billing intent and extract the order reference. The system retrieves the authoritative transaction record. Deterministic checks establish whether there are two settled charges for the same order, whether one has already been reversed and whether policy permits an automated refund.

If the record is clear and the action falls within the authorized limits, there may be no reason to ask an LLM to deliberate over it.

If the records conflict, the payment spans several accounts or the customer is asking for an exception, the system escalates. A reasoning model can assemble the evidence and recommend a resolution. A human may still need to approve it.

Before money moves, the action layer checks the amount, permissions and idempotency key. Afterward, it checks whether the payment processor actually accepted the refund.

Each component has a job it can be tested against. The classifier interprets the message. Retrieval supplies facts. The reasoner handles ambiguity. The action layer enforces authority. The processor response establishes what happened.

That division is more useful than describing the entire pipeline as “an AI that thinks.”

The economics: when does a fast path pay off?

Consider an illustrative workload, not a measured benchmark:

• A fast decision costs $0.0001 per request.
• A reasoning call costs $0.01.
• Twenty percent of requests require escalation.

The average model cost of the cascade is:

$0.0001 + (0.20 × $0.01) = $0.0021 per request

Compared with using the $0.01 reasoning call for every request, that is a 79% reduction. At one million requests, the model-call bill would be $2,100 rather than $10,000, under these assumptions.

Those numbers exclude retrieval, verification, retries, engineering, hosting and human review. They also assume the fast path preserves acceptable quality. If a missed escalation causes expensive mistakes, nominal inference savings can disappear quickly.

For a sequential cascade, escalated requests also pay the fast-path overhead before reasoning begins. Average latency can improve while the slowest cases get slightly slower. Measure p95 and p99 latency, not just the mean.

A useful evaluation records cost per successfully completed task, end-to-end completion quality, false accepts, unnecessary escalations, tail latency and review burden. Optimizing the router's standalone accuracy is insufficient.

The feedback loop: learn which decisions no longer need deliberation

The distinction need not remain fixed after deployment.

In Distilling System 2 into System 1, Yu and colleagues investigate transferring improved outputs from more expensive reasoning techniques into direct model generations without intermediate reasoning sequences. Several techniques can be distilled successfully in their experiments, reducing inference cost relative to the System 2 approach. [12]

The appealing operating pattern is:

Deliberate on difficult cases
  → verify the outcomes
  → collect trustworthy examples
  → train or distill a cheaper path
  → evaluate it on held-out cases
  → retain escalation for what remains difficult

The verification step matters. Recycling a reasoner's answers without checking them can teach the fast model to reproduce its mistakes more efficiently.

Distillation also does not imply that every novel task can be compressed into a reliable classifier. It is a way to move some recurring work into a cheaper path, provided the evidence supports doing so.

Where the metaphor breaks

System 1/System 2 is useful shorthand. It becomes harmful when it hides distinctions that matter operationally.

Fast is not synonymous with shallow. A specialist may outperform a general model on its target task. Expert-like direct performance can reflect extensive training rather than trivial computation.

Slow is not synonymous with correct. Extra sampling and search are useful only when the system can identify better candidates. Overthinking is a documented failure mode. [9]

Structured is not synonymous with trustworthy. Returning a valid label prevents malformed prose, not an incorrect decision.

Confidence is not permission. Calibration estimates reliability; authorization determines what may happen. They need different mechanisms.

A framework is not a brain scan. These terms help describe an architecture. They do not establish human-like cognition or consciousness in a model.

What to build next

Start with one high-volume decision whose desired output is clear: routing a support ticket, extracting entities from incoming documents or flagging a case for review.

Build a representative evaluation set before choosing a model. Include ambiguous inputs, missing information, adversarial cases and examples outside the expected distribution. Compare a deterministic baseline, a specialist and the general model you already use.

Then introduce escalation. Set the threshold according to the cost of mistakes, evaluate the entire pipeline and keep a path to human review. Add complexity only when it improves the measured outcome.

A reasoning model should not have to rediscover a routine decision on every request. A classifier should not be forced to guess its way through a novel problem. Give each a bounded responsibility, and make the handoff explicit.

Fast by default. Slow on purpose. Verified before consequences.

Research and further reading

Sources are grouped by their role. Paper abstracts and primary project pages support the research summaries; the Jev numbers are attributed reports, not measurements performed by AGNT.

1. Li et al., From System 1 to System 2: A Survey of Reasoning Large Language Models (2025). Broad map of reasoning models, methods and benchmarks.
2. Christakopoulou, Mourad and Matarić, Agents Thinking Fast and Slow: A Talker-Reasoner Architecture (2024). Separating conversational responsiveness from deliberation and planning.
3. Zaratiana et al., GLiNER: Generalist Model for Named Entity Recognition using Bidirectional Transformer (2023), and the GLiNER repository. Original extraction approach and evolving implementation.
4. TypeSafe, Introducing System One Models & Jev (2026). Vendor description and claims; not independent validation.
5. LiteLLM, JEV Classifier benchmark (2026). Routing measurements with explicit limits on label quality and generalization.
6. LangChain, Jev-as-a-Judge for Agent Evals (2026). Early evaluation results; consistency should not be confused with correctness.
7. Wei et al., Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (2022). Foundational evidence for intermediate-step prompting.
8. Ji et al., A Survey of Test-Time Compute: From Intuitive Inference to Deliberate Reasoning (2025). Taxonomy of additional inference-time computation.
9. Chen et al., Do NOT Think That Much for 2+3=? On the Overthinking of o1-Like LLMs (2024; revised 2025). Computational waste and strategies for reducing it.
10. Bengio, From System 1 Deep Learning to System 2 Deep Learning, NeurIPS (2019). Early research framing for reasoning, causality and compositional generalization.
11. Fast, slow, and metacognitive thinking in AI, npj Artificial Intelligence (2025). SOFAI architecture and task-specific experiments.
12. Yu et al., Distilling System 2 into System 1 (2024). Transferring some reasoning benefits into cheaper inference.

Conceptual background: Daniel Kahneman, Thinking, Fast and Slow (2011). The cognitive framing is an analogy here, not validation of an AI mechanism.