From System 1 and System 2 to Decision Models: The Long History Behind AI That Doesn't Write

Psychology spent 130 years separating fast judgment from slow reasoning. AI spent a decade building only the slow kind. Now a new class of model does the fast kind, and on one yes/no question it answered in about 0.4 seconds where Gemini took about 5.6.

Vishal Bulbule · Google Developer Expert (Google Cloud) · TechTrapture

---

1. The idea in plain words

Someone throws a ball at you and you catch it. You did not calculate its speed. Now a friend asks whether you can organise a football match next Sunday. You stop and think: who is free, which ground, who brings the ball.

Same brain, two modes. Psychologists call them:

• System 1: fast, automatic, effortless.
• System 2: slow, deliberate, effortful.

Most of what you do in a day runs on System 1. System 2 comes on when something is new, hard or important.

AI has its own version of this split:

• An LLM is built to write. Ask it something and it produces text, which your code then has to read.
• A decision model is built to decide. You give it some text and a fixed question, and it returns a typed answer with a probability. It cannot write a sentence.

The easiest picture: an LLM is an essay exam, and a decision model is a multiple-choice answer sheet. On an essay you can write anything, including something wrong, confident and beautifully worded. On the answer sheet you can only fill a bubble that already exists, and this sheet also records how hard you pressed the pencil.

An LLM is an essay exam. A decision model is an answer sheet that also records how hard you pressed the pencil.

---

2. The whole history

The idea that AI needs a fast mode looks new. It is the latest step in a very old argument.

The same idea in two fields. Events are evenly spaced, so the distance between them is not to scale.

2.1 Psychology finds the two modes

1890: William James. In The Principles of Psychology, James separates associative thinking, which runs on past experience, from true reasoning, which can handle a situation you have never met.

Mid-1970s: Wason and Evans. Studying how people solve logic problems, Peter Wason and Jonathan Evans suggest that people's stated reasons may not be what actually produced their answers. Two different processes seem to be at work. This is where modern dual-process theory starts.

1974: Tversky and Kahneman. In a separate line of work, Amos Tversky and Daniel Kahneman publish "Judgment under Uncertainty: Heuristics and Biases" in Science. People use mental shortcuts, the shortcuts usually work, and they fail in predictable ways.

1984 and 1996: Evans, then Sloman. Evans names the two processes heuristic and analytic. Steven Sloman makes the case for an associative system and a rule-based system.

2000: The names arrive. Keith Stanovich and Richard West need neutral labels for a crowded field, so they propose System 1 and System 2. Kahneman did not coin these terms, and his book says so.

2002: The Nobel. Kahneman wins the Nobel Memorial Prize in Economic Sciences for the work he did with Tversky. Tversky had died in 1996, and the prize is not given posthumously.

2011: Thinking, Fast and Slow. Kahneman's book takes the two systems to a general audience. He also warns readers that they are fictional characters, a way of telling the story, and not two physical parts of the brain. The best-known demonstration comes from Shane Frederick's Cognitive Reflection Test (2005): a bat and a ball cost $1.10, and the bat costs $1 more than the ball. Your System 1 says the ball costs 10 cents. It costs 5.

After the book: the pushback. The history doesn't end in agreement. Some researchers argue that a single system on a continuum fits the evidence better (Osman, 2004). Evans and Stanovich themselves move to "Type 1 and Type 2 processes" in 2013, partly because "systems" sounds like two separate machines. And in 2017, responding to a critical analysis of the book's priming chapter, Kahneman accepted that he had put too much faith in underpowered studies. Kahneman died in March 2024.

So treat System 1 and System 2 as a useful map of how judgment works. It is not settled brain science.

2.2 AI borrows the words, then goes the other way

2019: Bengio says deep learning is stuck on System 1. At NeurIPS 2019, Yoshua Bengio gives a talk called "From System 1 Deep Learning to System 2 Deep Learning". Deep learning was good at fast, intuitive perception, he argued, and it had to grow into reasoning, planning and causality. That was the direction the field wanted to go.

2017 to 2022: Models learn to please (RLHF). Reinforcement learning from human feedback rewards a model for responses people prefer. Christiano and colleagues showed deep RL from human preferences in 2017. OpenAI's InstructGPT paper applied it to language models in March 2022, and ChatGPT followed that November. TypeSafe's docs credit its founder, Diogo Almeida, as a co-inventor of RLHF; he is the fourth author on the InstructGPT paper.

2024 to 2025: Models learn to reason (RLVR). Reinforcement learning with verifiable rewards pays a model only when an answer can be checked, as in maths or code. OpenAI's o1 brought reasoning models to the mainstream in September 2024, the Tülu 3 paper from Ai2 described and named RLVR that November, and DeepSeek-R1 followed in January 2025. Smarter, but also slower and more expensive.

Bengio's wish came true. Both paths made AI better at writing: writing answers, then writing its reasoning. That is System 2, and nearly all the money went there.

15 September 2026: The third path (RLCD). TypeSafe launches Jev, which it calls the first public System One model. It is named after William Stanley Jevons, who noticed in The Coal Question (1865) that better steam engines made England burn more coal, not less. Cheaper use means more use. TypeSafe's training method is reinforcement learning for calibrated decisions: the reward is for picking the right answer and being honest about how sure it is.

TypeSafe's AI primer sets out the three paths: RLHF, RLVR and its own RLCD.

October 2026: A category in three weeks.

• 1 Oct: Cloudflare releases Clef and Clef-flash with open weights, and states that it follows the System One API, so a Jev integration can switch by changing the endpoint and model.
• 1 Oct: AWS's Strands Labs releases Strands Decider 2B, open source and small enough for a laptop.
• 6 Oct: OpenAI's Decisions API enters beta with GPT-6 Luna, reaching general availability on 22 Oct.
• 3 Nov: Sarvam releases Prism, with open weights.

When a competitor copies your interface, you have started a standard. Amazon S3 went the same way.

Cloudflare's changelog: Clef follows the System One API, so moving from Jev means changing the endpoint and model.

---

3. The problem

Look at what software actually asks AI all day. Is this email spam? Which team gets this ticket? Is this tool call safe to run?

Those are System 1 questions, and we answer them by hiring a novelist to write one word. It's like calling a lawyer to ask whether the traffic light is red. The lawyer will be right. You will also get a bill and three paragraphs.

TypeSafe's founder put the gap this way: "Models have been superhuman at chat for years, so where is all the automation?"

There are three real costs for anyone running AI in production:

1. Shape. Your code needs a value. An LLM gives it prose, so you parse it, ask for JSON, and handle the day it invents a new label.
2. Latency. Small decisions stack. Five checks at a few seconds each is a long wait before the real work starts.
3. Price. When each check costs real money, you sample instead of checking everything.

If you are building AI apps today, you are paying System 2 prices for System 1 questions.

---

4. How a decision model works

There are two parts to a request: the state (your text) and the questions. Jev has three question types for text:

• Noul: yes or no, as a probability. Like the chance of rain.
• Choice: pick one from a list. Like choosing a counter at the post office.
• Score: where on a scale. Like a doctor asking about pain from zero to ten.

A fourth type, Box, finds a location in an image. TypeSafe labels image support "dreamer-ready", its own wording for not yet production ready.

The TypeSafe Playground from the recording: state on top, questions below, with the question types shown as cards.

This is the call from the video, one customer review with three questions in one request:

review = "The delivery was 30 minutes late, but the pizza was amazing and still hot."

response = client.system_one(
    state=review,
    questions={
        "is_happy": Noul(instructions="Is the customer happy?"),
        "sentiment": Choice(
            instructions="What is the customer's sentiment?",
            criteria={"happy": None, "neutral": None, "not_happy": None},
        ),
        "how_happy": Score(
            instructions="How happy is the customer?",
            criteria=["Unhappy", "Mixed feelings", "Very happy"],
        ),
    },
)

Jev returned 78% for happy, happy at 0.88 with confidence 0.82, and 1.17 on the 0-to-2 scale, in 0.45 seconds. Gemini 3.8 Flash, given the same review, took 7.76 seconds to write that it was mixed but leaned positive, and explained why. If you need the explanation, that is a good answer. If your code only needs to branch, it has to parse all of it.

Gemini 3.8 Flash on the pizza review: a useful answer, in prose, after 7.76 seconds.

Jev on the same review: three typed answers in one request, in 0.45 seconds.

Watch the walkthrough:

https://youtu.be/ZnDued7w9g8

---

5. What we measured

TypeSafe claims 70 to 500 ms, measured from the US West Coast. We tried it ourselves.

Method. One laptop in Pune, on camera, in the same session. Each model got the same fact to judge: cardio helps heart health. Gemini 3.8 Flash ran on Google Cloud through Vertex AI (location global), and both LLMs were told to answer yes or no. We timed the full call from Python and ran each model twice.

Model	Run 1 (s)	Run 2 (s)	Average (s)
Gemini 3.8 Flash	6.21	4.98	5.60
GPT-5.4 nano	2.14	2.17	2.16
Jev (jev-latest)	0.36	0.44	0.40

From the recording: all six runs on the results card, and the second round of runs in the terminal.

Average of two runs each, from a laptop in Pune. Gemini's dry run earlier the same day took 2.97 seconds, so read this as a demonstration and not a benchmark.

Both LLMs answered "Yes". Jev answered 95%, a number your code can put a rule on.

How far to trust this. Two runs each is a demonstration, not a benchmark. In our dry run earlier the same day, the same Gemini question took 2.97 seconds and Jev 0.32, so the LLM side varies a lot. Network path and Gemini's thinking both play a part, and we did not separate them. GPT-5.4 nano matters here: a small LLM closes much of the gap, and it was still about 5 times slower than Jev.

Why it adds up. Run five checks one after another and an agent waits about 28 seconds on Gemini, about 11 on nano and about 2 on Jev, using the averages above.

Cost

Jev charges $0.042 per million input tokens, and output is free, which TypeSafe describes as too cheap to meter. It has also said that it still has to prove this pricing is sustainable.

Take one million support tickets at about 400 tokens each. We use Gemini 3.8 Flash at its list price of $0.75 input and $3.75 output per million (read 6 Nov 2026; this is an introductory price until 31 Dec). For the long-answer case, we use a real spam-check answer from the video, which was 243 output tokens.

One million checks at 400 input tokens each	Input	Output	Total
Jev	$16.80	free	$16.80
Gemini 3.8 Flash, one-word answer	$300.00	very little	about $300
Gemini 3.8 Flash, 243-token answer	$300.00	$911.25	$1,211.25

One million checks at 400 input tokens each. Gemini 3.8 Flash at its list price read on 6 Nov 2026 ($0.75 input, $3.75 output per million, introductory until 31 Dec). The one-word figure leaves out output and thinking tokens, so it is a lower limit.

The one-word row is the lower limit. Thinking tokens are billed too, so a real run costs more. TypeSafe quotes a range of $0.20 to $10 per million input tokens across LLMs, which puts the same input alone at $80 to $4,000.

This is Jevons again. At $16.80 per million, you stop checking one in a hundred and check everything. The trade-off follows from that: a cheap check repeated a million times also repeats its mistakes a million times, so the total bill can go up as use grows.

---

6. Where it fits, and where it breaks

Three places to start in an existing AI app:

• Model routing. Score how hard a request is, then send it to a small or large LLM. A triage nurse before the senior doctor. A misjudged hard request gets a weak answer, so log and review the borderline ones.
• Agent routing. Replace an LLM router that reads a long prompt to pick one name with a Choice question. You lose the tailored clarifying question an LLM could ask.
• Guardrails. Scan every input and output, like airport bags. A later post tests this against Google Cloud's Model Armor.

The rule that makes these safe: code owns the flow, the model answers one narrow question, and when it isn't sure, a human or a bigger model takes over.

Where it breaks. These limits come from TypeSafe's own docs:

• It is not a calculator and does not count reliably. Do maths, counting and dates in code.
• Unrelated content in the state lowers accuracy, so filter it first.
• Hostile text in the state can move the answer.
• Choice leans toward the option listed first, so test by reordering.
• It cannot write, explain or plan.

Here the history comes back. Kahneman's System 1 is fast and often right, and it fails in predictable ways. It takes the bat-and-ball bait. Those limits look similar to me: an answer pulled by whatever came first, thrown off by irrelevant detail, and unreliable at arithmetic. That is my analogy and not a finding, and these models are not built like brains. The practical lesson still carries over: System 1 needs a System 2 watching it. In people that is attention. In your architecture it is code, thresholds and a fallback.

There are also some things we can't tell you yet. TypeSafe publishes little about how RLCD works. Calibration, the claim that matters most, is not something two latency runs can test, and we look at repeatability in a later post. The category is about two months old, and every vendor's speed numbers are its own.

Will decision models replace LLMs? I don't think so. They do different jobs, so you want both.

---

7. Key findings

1. The idea is old, and the application is new. The split between fast and slow thinking goes back to 1890. The names System 1 and System 2 date from 2000, and Kahneman made them famous in 2011. Decision models arrived in September 2026.
2. AI went all in on System 2. RLHF and RLVR both made models better at writing. RLCD trains for a typed decision and an honest probability instead.
3. In our small test, the speed gap was real. About 0.4 seconds for Jev, 2.2 for GPT-5.4 nano and 5.6 for Gemini 3.8 Flash, on two runs each from Pune.
4. The cost gap changes the design. One million checks cost $16.80 on Jev against at least $300 on Gemini 3.8 Flash. That makes checking everything affordable, and it also repeats any mistake at scale.
5. Use both. Fast model for decisions, slow model for thinking, code in charge.

How to start this week: find every place where an LLM writes a paragraph so that you can pull out one word. That is your first decision model call.

---

References

1. William James, The Principles of Psychology (1890).
2. P. C. Wason and J. St. B. T. Evans, "Dual processes in reasoning?", Cognition (1974–75).
3. A. Tversky and D. Kahneman, "Judgment under Uncertainty: Heuristics and Biases", Science (1974).
4. S. A. Sloman, "The empirical case for two systems of reasoning", Psychological Bulletin (1996).
5. K. E. Stanovich and R. F. West, "Individual differences in reasoning: Implications for the rationality debate?", Behavioral and Brain Sciences (2000).
6. D. Kahneman, Thinking, Fast and Slow (2011).
7. S. Frederick, "Cognitive Reflection and Decision Making", Journal of Economic Perspectives (2005).
8. M. Osman, "An evaluation of dual-process theories of reasoning", Psychonomic Bulletin & Review (2004).
9. J. St. B. T. Evans and K. E. Stanovich, "Dual-Process Theories of Higher Cognition: Advancing the Debate", Perspectives on Psychological Science (2013).
10. U. Schimmack, M. Heene and K. Kesavan, "Reconstruction of a Train Wreck" (2017), with Kahneman's comment: https://replicationindex.com/2017/02/02/reconstruction-of-a-train-wreck-how-priming-research-went-of-the-rails/
11. Y. Bengio, "From System 1 Deep Learning to System 2 Deep Learning", NeurIPS 2019: https://neurips.cc/virtual/2019/invited-talk/15488
12. P. Christiano et al., "Deep reinforcement learning from human preferences" (2017): https://arxiv.org/abs/1706.03741
13. L. Ouyang et al., "Training language models to follow instructions with human feedback" (2022): https://arxiv.org/abs/2203.02155
14. N. Lambert et al., "Tülu 3: Pushing Frontiers in Open Language Model Post-Training" (2024): https://arxiv.org/abs/2411.15124
15. TypeSafe, "Introducing System One Models & Jev" (15 Sep 2026): https://typesafe.ai/blog/introducing-system-one-models-and-jev
16. TypeSafe docs, AI primer: https://docs.typesafe.ai/introduction/machine-learning-primer
17. TypeSafe docs, Jev 1.13 known weak spots: https://docs.typesafe.ai/model-jaggedness/jev-1.13
18. Cloudflare changelog, Clef on Workers AI (1 Oct 2026): https://developers.cloudflare.com/changelog/post/2026-10-01-clef-workers-ai/
19. Strands Labs, Introducing Strands Decider (1 Oct 2026): https://strandsagents.com/blog/introducing-strands-decider/
20. OpenAI API changelog, Decisions API (beta 6 Oct, GA 22 Oct 2026): https://developers.openai.com/api/docs/changelog
21. Sarvam, Sarvam Prism (3 Nov 2026): https://www.sarvam.ai/blogs/sarvam-prism
22. W. S. Jevons, The Coal Question (1865).