AI Literacy Tutor

Understand AI.
Think for Yourself.

Mercurius AI helps learners ask better questions, challenge ideas, and build real understanding in the age of artificial intelligence.

Here to help you think, not think for you.

A real lesson, replayed

Try a real lesson.

This is a real Mercurius lesson, replayed: Unit 1, Lesson 1, “What happens when you type a prompt,” recorded on October 7, 2026.

Our team scripted the student’s taps. Mercurius’s replies are unedited.

Unit 01 · Lesson 1

What happens when you type a prompt

3 turns, recorded October 7, 2026

  1. Mercurius:

    Here's a wild fact to kick us off:

    The word "bank" — as in riverbank or as in Chase Bank — looks completely different to you, but to an AI reading your prompt, it starts as the exact same string of characters.

    That's the first problem every LLM has to solve.


    Tokenization is how your text gets converted into something a model can actually process.

    When you type a prompt, the model doesn't read words — it breaks your text into chunks called tokens, then maps each token to a number.

    Example:

    The word "unbelievable" might become three tokens: "un" + "believ" + "able." The word "cat" is probably one token. GPT-4 works with a vocabulary of roughly 100,000 tokens — each one a unique number the model can do math on.

    Key idea:

    Tokenization turns your text into a sequence of numbers — that's the only form an LLM can actually work with.

    Here's what makes this tricky: the model sees a number, not a meaning. So "bank" (money) and "bank" (river) start as the same token — the model has to figure out which one you meant from context. That disambiguation happens later, deeper in the network.


    Check: A student types: "I went to the bank to fish." Which statement best describes what the LLM sees first?

    1. A) The word "bank" with its meaning already understood from context
    2. B) A sequence of numbered tokens — "bank" is just a number, meaning unknown yet (the student’s pick, correct)
    3. C) A search query sent to a database to look up "bank"

    In this session, the student picked B.

  2. Student:

    I picked B) A sequence of numbered tokens — "bank" is just a number, meaning unknown yet

    Mercurius:

    Exactly right — and you picked up on the key nuance: meaning comes later, not at the tokenization step.

    That "later" is where our next micro-concept lives.


    So the model has a sequence of numbers. Now what?

    Next-token prediction is the core job of every LLM — and it's simpler and stranger than most people expect.

    The model doesn't "think through" your question and compose an answer. It asks one question, over and over: given everything I've seen so far, what token is most likely to come next?

    Example:

    Finish this: "The cat sat on the ___." Your brain jumps to "mat" or "floor" — high confidence. Now try: "She handed him the ___." Dozens of words fit equally well — low confidence. An LLM works exactly this way, assigning a probability to every token in its vocabulary and sampling from that distribution.

    Key idea:

    An LLM generates text by predicting one token at a time — it never "looks up" an answer, it calculates what word is most likely to come next.

    This is why AI can sound fluent and still be wrong — fluency is a side effect of predicting plausible continuations, not true ones.

    It also means the model's entire response — every word — is built one token at a time, each prediction feeding into the next.


    Check: Why can an LLM produce a confident-sounding but completely false answer?

    1. A) It searched the wrong database (the student’s pick, not correct)
    2. B) It ran out of training data mid-response
    3. C) It optimizes for likely next tokens, not for truth (correct answer)

    In this session, the student picked A.

  3. Student:

    I picked A) It searched the wrong database

    Mercurius:

    Good instinct to think about where information comes from — but LLMs don't search databases at all.

    There's no lookup happening. No index, no query, no retrieval (unless a separate search tool is explicitly bolted on). The model has no internet connection mid-response.

    What it does have is billions of parameters — numerical weights adjusted during training — that compress patterns from text it saw during training. When it generates a response, it's running math on those weights, not fetching anything from anywhere.

    So the real problem is this: the math is optimized to produce plausible-sounding continuations, not accurate ones. A token that sounds right scores well. A token that's true but awkward might score lower.

    Truth and plausibility often overlap — but not always. And the model can't tell the difference.


    Check: Which best describes what an LLM is actually doing when it generates a response?

    1. A) Retrieving stored answers from a knowledge base
    2. B) Running math on learned weights to predict likely next tokens
    3. C) Summarizing the most relevant web pages it found
    Show the answer

    The answer is B.

That’s where this replay stops.

The full lesson continues in the app. There, Mercurius replies to your own answers, so your lesson won’t read word for word like this one.

Download on the App Store

Free on the App Store. Requires iPhone, iOS 17 or later.

Learn AI. Think Better.

Understand AI with clarity, curiosity, and confidence.

Download on the App Store

Free on the App Store. Requires iPhone, iOS 17 or later.