System 1 vs System 2 AI: when to decide fast and when to reason

System 1 AI is a fast decision model that answers a fixed question about some text (pick an option, rate it, or say yes or no) in one pass, with a probability. System 2 AI is a reasoning model, usually an LLM, that works step by step and writes text. The names come from Daniel Kahneman's Thinking, Fast and Slow.

Daniel Kahneman's Thinking, Fast and Slow (2011) popularised a two-part model of human thinking. System 1 is fast, automatic and intuitive: you recognise a face, read a sign, or notice that someone is angry without deciding to. System 2 is slow, effortful and deliberate: you multiply 17 × 24, compare two mortgage offers, or check a proof line by line.

The framing is a useful metaphor for AI systems, not a claim about neuroscience. TypeSafe, the company behind the Jev decision API, names its product category "System One models" and says in its documentation that the name comes from Kahneman's concept: "System 1 thinking is fast and intuitive. System 2 is slower and more deliberate. Here, the emphasis is on fast, focused judgments." The open-source Laya model, which powers Laya Studio, describes itself the same way: a "non-autoregressive System 1 decision model".

Mapped onto software, the split looks like this:

The value of the framing is practical. Most of what an automated system asks a model is not "write me an essay" but "which of these five buckets does this belong in, and how sure are you?" That is System 1 work. Paying System 2 prices and latency for it is the main reason many LLM-backed workflows end up slow and expensive.

For a longer discussion of the architectural difference behind this split, see encoder vs decoder models and non-autoregressive models.

A System 1 decision model takes two inputs:

1. State: the thing being judged. A support ticket, an email, a chat transcript, a JSON record, an agent trace.
2. Typed questions: what you want to know about the state, with the allowed answers spelled out.

It returns one typed answer per question, each with a probability distribution. It does not generate prose. In the Jev wire protocol, which Laya also speaks, there are three question types:

See choice, score and noul for the full semantics.

A complete Laya Studio request looks like this:

curl -s https://api.laya.studio/v1/systemone \
  -H "Authorization: Bearer lsk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "state": {"subject": "Duplicate charge on invoice #4411",
              "body": "We were billed twice for March. Refund the duplicate today or we cancel."},
    "questions": {
      "department": {"type": "choice", "instructions": "Which team should handle this?",
        "criteria": {"billing": "invoices, payments, refunds",
                     "technical": "bugs, outages", "sales": "pricing, new contracts"}},
      "urgency": {"type": "score", "instructions": "How urgent is this?",
        "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]},
      "churn_risk": {"type": "noul", "instructions": "Does the sender threaten to cancel?"}
    }
  }'

The response shape comes straight from the open-source package (agent.py), with a routing block added by the language router:

{
  "model": "laya-rl-agent",
  "answers": {
    "department": {"type": "choice", "choice": "billing",
      "probabilities": {"billing": 0.94, "technical": 0.03, "sales": 0.03},
      "confidence": 0.76, "action": {"act_probability": 1.0}},
    "urgency": {"type": "score", "score": 1.84,
      "legend": {"0": "not urgent", "1": "soon", "2": "critical deadline or blocking issue"},
      "probabilities": {"0": 0.02, "1": 0.12, "2": 0.86}, "confidence": 0.58,
      "action": {"act_probability": 1.0}},
    "churn_risk": {"type": "noul", "noul": 0.89, "confidence": 0.89,
      "action": {"act_probability": 1.0}}
  },
  "usage": {"input_tokens": 212, "output_tokens": 0},
  "routing": {"model": "english", "repo": "convaiinnovations/laya", "reason": "English Latin text"}
}

(The numbers above are illustrative.) Three things matter for the System 1 / System 2 comparison:

• There is nothing to parse. The answer to department is always one of the keys you supplied. No regex over free text, no JSON-mode retries.
• output_tokens is 0. Laya does not generate. All three questions are answered in one batched forward pass.
• Every answer carries a distribution. That distribution is the hook that lets you decide, in code, when System 1 is enough and when to escalate.

Note one limit from the Laya model card: action.act_probability "carries no usable signal yet" (it reads 1.0 for almost every input). Gate on confidence or the probabilities instead.

The strongest argument for a System 1 layer is arithmetic. An LLM generating a JSON object token by token pays one decoder step per output token, on top of reading the prompt. A decision model reads the input once and scores every option in parallel.

Figures from the Laya model card (Tesla T4 GPU, measured in-process, byte-identical questions for each checkpoint):

These are model-side numbers on a GPU. A hosted API such as Laya Studio adds network round-trip time on top, so measure from your own region before you set a latency budget.

For context on the System 2 side, TypeSafe's launch post states that end-to-end response time for frontier models is "3 to 329 seconds", against "70ms-500ms" for its own System One model. The independent Decision Model Benchmark (DMB) by nibzard measured Jev at 264–276 ms p50 and a range of constrained LLMs at roughly 0.3 to 5.6 seconds. It also noted that Jev's speed advantage over the fastest LLM setup it tested (gpt-oss-120b on Cerebras) was about 1.2x, not the 40–200x in the vendor claim. That nuance matters: if you run a small LLM on very fast inference hardware with reasoning turned off, the latency gap narrows a lot. The gap stays large against reasoning-mode models.

Cost follows the same shape:

• LLMs bill for input and output tokens, and output tokens are usually priced higher. A classification prompt with a long label list and a JSON answer pays for both.
• Jev bills input tokens only: "$0.042 / MTok ($42 per billion tokens)", with output tokens "FREE (too cheap to meter)", per TypeSafe.
• Laya Studio bills per input token: 1 credit = 1 input token, 30% below Jev's list price, with 5 free runs. See /pricing for current plans. Self-hosting the open-source model costs only your hardware.

For budgeting details, see the cost of using an LLM as a classifier and latency budgets for agents.

Use a decision model when all of the following hold:

1. The answer space is known in advance. You can list the options (departments, intents, severity levels) or phrase the question as true/false.
2. The judgment is local to the input. The answer is in the ticket, email or record, not in a chain of lookups.
3. The volume is high or the latency budget is tight. Every message, every agent step, every document.
4. You want to act on uncertainty. You need a probability to threshold on, not a yes/no that may or may not be reliable.

Typical System 1 workloads:

Laya's own benchmarks show where the fit is strong and where it is not. On the application themes in the project's BENCHMARKS.md (400 cases each), the English checkpoint scores 0.993 on email spam and 0.980 on phishing, though both sources were in its training mix. On held-out jailbreak detection it scores 0.708, and on held-out toxicity moderation 0.530, "barely above chance on a balanced split". A System 1 model is not automatically good at every classification task. Test on your own data.

A decision model cannot do the following, by design or by current capability:

• Generate anything. Replies, summaries, code and explanations need a generative model. TypeSafe's Jev documentation says the same about its own model: it "does not generate text, write code, or hold a conversation."
• Open-ended extraction. A decision model can pick a span from candidates you supply, but it cannot invent a field value that is not in the option list.
• Arithmetic, counting and date comparison. TypeSafe's "Jev 1.13 jaggedness" page lists math and numbers, counting, and date/time comparison as known failure modes and recommends doing that work in code. The same advice applies to Laya: keep arithmetic in your program.
• Multi-hop reasoning. Questions that need several inference steps ("is the customer's plan eligible given the policy on page 4 and their signup date?") belong to a reasoning model or, better, to code that breaks the question into atomic checks.
• Very large label spaces without preparation. Laya's option budget is shared: at default settings a 77-option question gets only about 3–4 tokens per label, and the model card reports 0.425 accuracy on Banking77 against Jev's published 0.870. Jev documents support for up to 255 options per Choice. For LLMs, the DMB benchmark notes that "every LLM handles 512 options".
• Zero-shot on narrow, synthetic workflows. The Laya card is direct about this: the base checkpoints are "near chance on typed-decisions zero-shot" (0.362 against a 0.461 majority-class baseline), and the 0.766 result belongs to the checkpoint fine-tuned on that benchmark. "Laya is a fast base to specialise, not a zero-shot decision engine."

The practical conclusion is not "System 1 replaces LLMs". It is that a System 1 layer can answer the simple, high-volume questions in front of an LLM, and hand the rest to it.

The standard pattern is confidence-gated escalation. Ask the decision model first. If it is confident, act. If not, escalate to a reasoning model or a person. TypeSafe documents the same idea as "confidence-gated routing"; see also act / escalate routing.

Pattern 1: gate on confidence

import os, requests

LAYA = "https://api.laya.studio/v1/systemone"
HEADERS = {"Authorization": f"Bearer {os.environ['LAYA_API_KEY']}"}

def triage(ticket: dict) -> dict:
    body = {
        "state": ticket,
        "questions": {
            "queue": {"type": "choice", "instructions": "Which team should handle this ticket?",
                      "criteria": {"billing": "invoices, refunds", "technical": "bugs, outages",
                                   "account": "login, profile", "other": "anything else"}},
            "is_urgent": {"type": "noul", "instructions": "Does the ticket state a deadline or outage?"},
        },
    }
    r = requests.post(LAYA, json=body, headers=HEADERS, timeout=5)
    r.raise_for_status()
    return r.json()["answers"]

def route(ticket: dict):
    a = triage(ticket)
    q = a["queue"]
    if q["confidence"] >= 0.6 and q["choice"] != "other":
        return ("auto", q["choice"])           # System 1 is enough
    return ("llm", ask_reasoning_model(ticket))  # escalate to System 2

The threshold (0.6 here) is not universal. Choose it from your own logged data: pick the threshold at which accuracy on the auto-handled slice meets your error budget. Calibrated probabilities explains how to check that the numbers mean what they say before you rely on them.

Pattern 2: speculative fan-out

Because extra questions in the same call are cheap, ask everything you might need up front and let code decide what to use. Laya's model card reports 10 questions batched in 72.3 ms on the multilingual checkpoint, against 32.8 ms for one. TypeSafe's docs call this "speculative fan-out".

const res = await fetch('https://api.laya.studio/v1/systemone', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ' + process.env.LAYA_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    state: { message },
    questions: {
      needs_tool: { type: 'noul', instructions: 'Does answering this require a tool or private data?' },
      domain: { type: 'choice', instructions: 'What is the request about?',
        criteria: { code: null, billing: null, general_knowledge: null, chitchat: null } },
      difficulty: { type: 'score', instructions: 'How hard is this for a language model?',
        criteria: ['trivial lookup', 'easy', 'several steps', 'hard multi-step reasoning'] },
    },
  }),
});
const { answers } = await res.json();
const model = answers.difficulty.score >= 2 ? 'large-reasoning-model' : 'small-fast-model';

This is the model-routing preset (router_questions) shipped in the open-source laya package: a System 1 call decides which System 2 model, if any, should handle the request.

Pattern 3: System 1 as a guardrail around System 2

Run decision questions on the LLM's input and output: jailbreak attempt, prompt injection, sensitive data, harm severity. The package ships these as guard_questions. Be realistic about accuracy: Laya's held-out jailbreak figure is 0.708–0.762 depending on checkpoint, so treat it as one layer of defence, not the only one.

Pattern 4: System 2 as teacher, System 1 as student

Label a sample of your traffic with a reasoning model or with people, then fine-tune a decision model on it. The Laya card's typed-decisions result is an example: fine-tuning on the benchmark's 1,200-case training split took accuracy from 0.362 to 0.766, above the 0.735 teacher self-agreement ceiling.

Escalation only works if the System 1 model's confidence is meaningful. A model that reports 0.95 on answers it gets right half the time will auto-handle cases it should escalate.

This is a real risk, not a hypothetical one. The Laya model card documents that its English checkpoint, given Khmer text, scores 0.000 accuracy at 0.952 confidence, and its mean confidence "never drops below 0.885 at any accuracy level" on non-English languages. Laya Studio addresses that particular failure by routing on script before the forward pass, sending non-English text to the multilingual checkpoint. See language routing. The general lesson holds: check calibration before trusting a threshold.

On the Jev side, the DMB benchmark found that on forced-uncertainty items, where the correct behaviour is to express doubt, every LLM it tested admitted ignorance on 97.3–100% of items, while Jev did so on 49.7%, with an ECE of 0.246. AbdelStark's jev-benchmarks pilot found Jev assigned zero probability to the true label on 16% of DAIR Emotion examples. Laya ships over-confident too, and the card reports that refitting temperatures moves its mean ECE from 0.466 to 0.081.

The takeaway: no System 1 model's confidence should be trusted without measuring it on your own traffic. Expected calibration error and temperature scaling cover the tools.

Use this table to decide which system should answer a given question in your pipeline:

Most real systems end up with both: a System 1 layer that handles the bulk of simple decisions in tens of milliseconds, and a System 2 layer for the long tail.

Try it

Laya Studio is a hosted API powered by the open-source Laya model (Apache-2.0, by Convai Innovations). It is an independent service, not affiliated with Convai Innovations or TypeSafe, and it speaks the same /v1/systemone wire format as TypeSafe's Jev. Create an account, read the docs, or compare plans on /pricing. For a direct comparison of the two System 1 APIs, see Laya vs Jev. For how decision models compare to prompting a general LLM, see Laya vs LLM classifiers.