# System 1 or System 2?

> Which steps of an AI feature should be fast and cheap, which should think, and how does one hand over to the other? System 1 is fast and cheap: code, a decision model or a small model, one call, at volume. System 2 is slow and deliberate: a top model at high reasoning effort, or an agent that loops with tools. Route per step, not per app: start each step on a top model, move it to the fast path once a replay of real cases proves the fast path does as well, and from then on everything takes the fast path first, checks in code catch what it got wrong, and only those cases climb. A person keeps the last word where the stakes or the law require it.

- A concept by Nicolas Dao (Cloudless Labs, Sydney): the decision before the tool
- Area: [Putting AI into software](https://cloudlesslabs.com/concepts/areas/ai/index.md)
- Last reviewed: 9 November 2026, by Nicolas Dao
- Web page: https://cloudlesslabs.com/concepts/system-1-or-system-2/

## What you'll be able to decide

Which steps of an AI feature belong on a fast path (code, a decision model, a small model) and which on a slow one (a reasoning model or an agent), what each costs per task, and how the fast path knows when to hand over.

## In short

### The options

- **A. Reflex:** A rule in code or a decision model: milliseconds, typed answers, nothing to parse. Tools: [Cloudflare Workers AI](https://cloudlesslabs.com/stack/cloudflare-workers-ai/index.md) (Skip).
- **B. A fast model:** A small model, one call: classification, extraction, routing, summaries, at volume. Tools: [OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md) (My default), [Amazon Bedrock](https://cloudlesslabs.com/stack/aws-bedrock/index.md) (Watching).
- **C. A thinking model:** A top model at high or maximum reasoning effort, one call: the hardest problems, where a wrong answer is expensive. Tools: [OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md) (My default), [Amazon Bedrock](https://cloudlesslabs.com/stack/aws-bedrock/index.md) (Watching), [Anthropic API (for client systems)](https://cloudlesslabs.com/stack/anthropic-api/index.md) (Skip).
- **D. An agent:** A model in a loop with tools: it investigates, acts and checks, for minutes or hours. Tools: [Lambda durable functions](https://cloudlesslabs.com/stack/aws-lambda-durable-functions/index.md) (Watching), [Self-hosted MCP servers](https://cloudlesslabs.com/stack/mcp-servers/index.md) (Use when it fits).

### The rule of thumb

Replay a week of real prompts on each candidate, and count the cost of the answers that passed, not the cost per token. From [Which model, at what price](https://cloudlesslabs.com/stack/guides/which-model/index.md).

### How the answer changes with scale

- **Low volume, high value:** Go straight to the thinking model: the token bill is noise next to the decision.
- **High volume:** The fast path takes everything first; only the unsure few per cent go up.
- **The frontier price drops:** Re-run the replay: work that needed the top tier may now pass a tier down.

## The problem, in plain words

Psychologists describe two ways of thinking (Daniel Kahneman, *Thinking, Fast and Slow*): System 1, fast, automatic and cheap, and System 2, slow, deliberate and effortful. You read a stop sign with System 1. You check a contract with System 2.

AI systems have the same split, and most teams get it wrong in one of two directions. Either every call goes to the biggest model, at its slowest setting, because "it's the most accurate"; or everything goes to the cheapest one, and the hard cases fail quietly.

The decision isn't which model the app uses. It's **which model each step uses, and what moves a case from the fast path to the slow one.**

## The picture

One month of supplier invoices. Each lane is narrower than the one above it: System 2 is the exception, not the route.

**Diagram:** Twenty thousand invoices a month take a fast lane checked by code; the thousand that fail a check go to a thinking model, the few dozen disputes to an agent that can wait for days, and new bank details or payments over the limit always to a person.

- **Fast path, every invoice:** 20,000 invoices a month → A small model extracts, against a schema → Code checks the order and the totals → About 19,000 paid. About $9 a month: most invoices are paid seconds after they arrive.
- **Thinking model, the ones that fail a check:** A check failed → Opus at high effort: invoice, order, contract → Explains the gap and proposes an action. About $120 a month for about 1,000 invoices.
- **An agent, the disputes:** A few dozen disputes → An agent with read-only tools → Waits for replies in a durable function → Assembles the case.
- **A person, always:** New bank details, or over the approval limit → A person approves.

## The options

**Reflex: code and decision models.** A rule, a lookup, or a [decision model](https://cloudlesslabs.com/concepts/llm-or-decision-api/index.md) that returns typed answers with a confidence. Milliseconds, almost free, nothing to parse.

**A fast model.** The small tier: Claude Haiku 5.5 at $0.10 / $0.50 per million tokens, or its open and OpenAI equivalents. In [Which model, at what price](https://cloudlesslabs.com/stack/guides/which-model/index.md) it's "the workhorse tier: classification, extraction, routing, summaries, at volume". One call, a second or two.

**A thinking model.** The top tier at high reasoning effort: Opus 5.5 at $4 / $20, for "the hardest problems: architecture, deep analysis, long autonomous work where a wrong answer is expensive". Effort is a dial, and it's priced: Sonnet 5.5 at maximum effort scores 54, at six times the cost of its high setting. Measured per task on the same test suite, Opus at maximum effort costs about 24 times Haiku at maximum ($10.04 against $0.41).

**An agent.** System 2 with hands: a model in a loop that reads, calls tools, acts and checks its own work, for minutes or hours. For anything that runs as an agent, the closed models still lead clearly. It's also the one that can burn money overnight.

## A concrete scenario

A company pays 20,000 supplier invoices a month.

- **Fast path, every invoice.** Once it matched Opus on a replay of a month of real invoices, a small model extracts supplier, ABN, amount, due date and order number against a schema. Code then matches the order in Postgres and checks that the lines add up to the total. About 95% pass and are queued for payment seconds after they arrive.
- **Thinking model, the 1,000 that fail a check.** The invoice, the order and the contract clause go to Opus at high effort, which explains the gap ("price rose 4% under clause 7.2") and proposes an action.
- **An agent, the few dozen disputes.** One with read-only tools (the email thread, the delivery records) assembles the case, running as a [durable function](https://cloudlesslabs.com/stack/aws-lambda-durable-functions/index.md) so that waiting days for the supplier's reply costs nothing.
- **A person, always,** for a change of bank details and for any payment over the approval limit. No model gets the last word on those.

At my assumed token counts (3,000 in and 300 out per invoice on the fast path, 10,000 in and 4,000 out per exception), that's about $9 a month for the fast path and $120 for the exceptions. All 20,000 on Opus at high effort, at 3,000 in and 4,000 out each, would be about $1,840, by my arithmetic from list prices. At this volume, price isn't what rules that out: the slow path takes far longer per invoice and still needs the same checks. At ten times the volume, it's prohibitive as well.

The checks are what make the split work. The fast path doesn't need to know it's unsure: **code knows**, when the totals don't reconcile or the order doesn't match.

## The trade-offs

| | Reflex | A fast model | A thinking model | An agent |
|---|---|---|---|---|
| Good at | Fixed answers: yes or no, a label, a score | Extraction, classification, routing, summaries | Deep analysis, hard reasoning, long documents | Work that needs looking things up and acting |
| Speed | Milliseconds | Seconds | Seconds to minutes | Minutes to hours |
| Price | Cents per million tokens, or free | Haiku 5.5 $0.10 / $0.50 | Opus 5.5 $4 / $20, plus the reasoning tokens | Many calls per task |
| How it fails | Visibly: a low confidence | Confidently wrong on the hard cases | Slowly and expensively, sometimes still wrong | Loops, spends, acts |
| How you check it | Thresholds on a labelled sample | A schema and business rules in code | Replay real cases; count the answers that passed | Tests, spending caps, approvals for risky actions |

## The rule of thumb

**Opus by default, fast once proven.** Start every step on Opus 5.5 at medium effort; a failed task costs more than the tokens saved. Move a step to the fast path (code, a decision model, a small model) only when a replay of real traffic proves it passes as often, with checks in code behind it. Spend reasoning where a wrong answer is expensive or the fast path has handed over. Put a person where the stakes or the law require one. And route per step, not per app: a cheap model to classify, a smart one for the hard part, behind the same key ([OpenRouter](https://cloudlesslabs.com/stack/openrouter/index.md)).

Reliability can be bought two ways: with more intelligence, or with a fast path that knows its limits. The second is usually cheaper, and it gets better every time the frontier's price falls.

## When the answer changes with scale

- **Low volume, high value:** skip System 1. For contract review, migration analysis or a monthly report, the token bill is noise next to the decision it supports.
- **High volume:** the fast path takes everything first. Chained calls should never pay twice for the first steps when the last one fails ([SQS retries or Durable Functions?](https://cloudlesslabs.com/stack/guides/retries/index.md)).
- **Long, fixed context:** cache it. Cached reads cost 0.05 times the input price on Sonnet and Opus 5.5. Watch Haiku's surcharge: five times the price above 100,000 tokens of prompt.
- **Agents at volume:** cap every key's spend, and give every agent a test that says when it's done.
- **The frontier moves every month.** In October, DeepSeek V4.1 Flash scored about 80% of Sonnet 5.5 for about 5% of the cost per task. Then the index was rebuilt, and it now scores 32 against Sonnet's 54. Benchmarks move as well as models, so trust your own replay, and re-run it when either changes: a step may move down a tier.

## Questions that change the answer

- What does a wrong answer cost, per case? That decides where System 2 starts.
- Can a check in code tell a good answer from a bad one? If so, the fast path can hand over on its own.
- Does the step need to look things up or act? Then it's an agent, with its own budget and approvals.

Doesn't cover:

- Picking the model inside each tier: that's [Which model, at what price](https://cloudlesslabs.com/stack/guides/which-model/index.md).
- Grounding answers in your own documents (retrieval, fine-tuning, long context) is its own concept.

## Check your call

- **Summarise 5,000 support calls a day for a dashboard the team reads each morning.** A fast model, one call each, with a weekly spot check of a sample. Volume is high and a weak summary costs little.
- **Review one 60-page supplier contract a month for unusual liability clauses.** A thinking model at high effort, and a person reads its findings. One a month is low volume and high value: the token bill is noise next to the decision.
- **Find out why an invoice was paid twice, using the email thread, the ERP and the bank feed.** An agent with read-only tools, waiting for replies in a durable function. Any refund it proposes goes to a person.

## The technology on this site

- [Which model, at what price](https://cloudlesslabs.com/stack/guides/which-model/index.md): the decision guide
- [Cloudflare AI Gateway, OpenRouter or LiteLLM?](https://cloudlesslabs.com/stack/guides/ai-gateway-choice/index.md): the decision guide
- [Durable functions or Step Functions?](https://cloudlesslabs.com/stack/guides/durable-or-step-functions/index.md): the decision guide
- [SQS retries or Durable Functions?](https://cloudlesslabs.com/stack/guides/retries/index.md): the decision guide
- [An AI chat or LLM feature](https://cloudlesslabs.com/stack/use-cases/ai-chat/index.md): the use case
- [Building with AI agents](https://cloudlesslabs.com/stack/use-cases/ai-dev/index.md): the use case
- [Week 43: DeepSeek V4.1 Flash 1017](https://cloudlesslabs.com/weekly/2026-w43/index.md): in The Stack Weekly
- [Week 43: Decision models (Jev, and Cloudflare's Clef)](https://cloudlesslabs.com/weekly/2026-w43/index.md): in The Stack Weekly

## Related

- [Ask an LLM, or call a decision API?](https://cloudlesslabs.com/concepts/llm-or-decision-api/index.md): read next
- [How much freedom should an AI step get?](https://cloudlesslabs.com/concepts/ai-autonomy/index.md): the decision after it
- [Putting AI into software](https://cloudlesslabs.com/concepts/areas/ai/index.md): the area, and the technology for each answer
- [Every concept](https://cloudlesslabs.com/concepts/index.md)
- [Map of every Markdown file on cloudlesslabs.com, with what each one answers](https://ask.cloudlesslabs.com)