Unit 3 video transcript: What a language model does differently

Release candidate. The unit videos are added in the first release.

The words spoken in the Unit 3 video, scene by scene, as its captions show them, with what the animations show marked [On screen: ...] where they play. Each speaker is named where the speaker changes. The Unit 3 reading covers the same material.

The narration is spoken by synthetic voices made for this course, each shown on screen as a drawn robot. No person is speaking.

Unit 3 — What a language model does differently

Narrator: Unit 2 showed a procedure where every step was written down, the order was part of the meaning, and running it twice gave the same answer both times.

What changes for the learner

A language-model service is also software. It has algorithms, state, and control flow. An algorithm is a fixed set of steps that turns valid input into output and stops; the ordered procedure of Unit 2 is one. The difference that matters to you is that its answer does not expose a step-by-step trace proving each claim. That changes what you can infer by reading it, and how you have to check it.

The loop

Here is the mechanism, in plain language. A text-generating system takes the text so far: your prompt, plus whatever it has already produced. It has a fixed vocabulary of small pieces of text, called tokens. Roughly, a token is a common word or a fragment of a longer one. For each token, the system computes a probability that it comes next. One token is then selected and added to the end. Then the whole thing runs again, with that token now part of the text so far.

[On screen: A short piece of text, 'The capital of Australia', sits at the top of the frame. Below it a bar chart shows five candidate next tokens with their illustrative, hand-authored probabilities. The bars grow in, one candidate is marked 'selected', and that token flies up and joins the end of the text. The bars then clear and re-form with different candidates and different probabilities, because the text they are conditioned on has changed. This happens three times and builds the fluent but false sentence 'The capital of Australia is Sydney.' First: is 0.57, was 0.18, has 0.11, comma 0.08, remains 0.06; is is selected. Second: Canberra 0.31, Sydney 0.28, Melbourne 0.20, Perth 0.12, Adelaide 0.09. Canberra is the correct answer and has the highest illustrative probability, but sampling selects Sydney. Third: full stop 0.62, comma 0.16, and 0.09, today 0.07, because 0.06; the full stop is selected. The closing text states that the numbers are explanatory rather than measured model output, marks 'Sydney' as false (Australia's capital is Canberra), and states that next-token selection is not a truth check.]

That is the loop. One token at a time, each step depending on everything before it in the available context. A paragraph is that step repeated many times. Here the step selected Sydney, not the likeliest token. Why a less likely token can be selected is the first consequence, coming up. Fluent, and false: selecting a plausible token is not a truth check.

The Transformer in one picture

The models this unit describes are built on an architecture called a Transformer, introduced in twenty seventeen.

[On screen: On the left, tokens become representations. Attention links show 'capital' and 'Australia' combining into the representation for 'is', which outputs next-token scores. A note below states that attention combines context; it is not a database lookup, a citation, or a truth test. Then, on the right, under the heading 'A deployed assistant has layers', a system stack builds up: base transformer, post-training, optional retrieval, and optional tools.]

It turns tokens into numerical representations, long lists of numbers. Across many layers, attention gives each position a weight for every token up to that point. A position is one token's place in the text. Each weight comes from how closely two representations match. Each position then combines information from those tokens by weight, so some tokens count far more than others. In the picture, "capital" and "Australia" count most at "is". The last layer produces scores for the possible next token. Attention is a way of combining context. It is not a database lookup, a citation, or a truth test. None of the argument that follows depends on that architecture. It rests on next-token generation over a context, and would hold if the architecture changed.

A deployed assistant has layers

Pre-training adjusts the base model's parameters, the large set of numbers it is built from. It uses a large collection of text, called a corpus, to improve next-token prediction.

The assistants people use are usually post-trained as well, to follow instructions. In post-training the model is trained further on examples of the responses its makers want, written by people, and on people's rankings of several of its own responses. That changes the style and format of what comes out, and how closely it follows an instruction; it adds no check of whether a claim is true. A product may also add search, document retrieval, calculators, code execution, memory, or other tools.

[On screen: Left side, headed basic generation: a user question points straight down to a direct final answer, visible to the user, with the note: straight to the answer, no intermediate steps. Right side, headed agentic processing (extra work): a user question leads to a generated plan (generated text, not an audit trail), then a tool action that calculates or searches, drawn in a different colour from the generated steps, then a generated critique, with a dashed arrow from the critique back up to the plan marked 'may loop', and then a final answer, visible to the user. Only the two final answers are marked visible to the user. A closing line reads: extra work can improve the result; it does not make every claim correct.]

On the left, basic generation goes straight from a question to an answer. On the right, a process that loops before it answers, often called agentic, adds a generated plan, a tool action and a generated critique.

Questioner: Do those tools make the answers correct?

Narrator: Those additions can improve the result. They do not make every generated claim correct by definition.

The training text ends at a date

[On screen: A schematic time line with no real dates. Pages of text gather on it, labelled 'training text, collected up to a date', until a dashed line marks the training cut-off. The region after the line is labelled 'written after it: not in the base model', and faint pages appear there. A question arrives at the right-hand end of the line: 'what is the rule now?'. Marked 'no tools', the answer is drawn from the older pages before the cut-off and is labelled 'an outdated state, presented as the current one'. Then the label changes to 'with search': a search reaches one of the later pages, which is marked as fetched, and the answer now rests on the fetched page, an arrow running from that page to the answer, with the note that it needs the checks Unit 4 gives for retrieval. Two questions close it: when does this system's training text end, and did it fetch anything this time?]

Pre-training uses text collected up to a date, the training cut-off, and nothing written after that date shaped the base model's parameters. Now ask about something later, such as a new result, a changed rule, or this year's figures. A model without tools may still answer, instead of saying it cannot know. Without tools it can produce a plausible answer from older text, and present an outdated state as the current one. Its own cut-off, asked of the model, is generated text like any other. For the date, check the provider's documentation.

Search and other tools change this, but only for what they fetch. Search fetches newer pages, and the answer then rests on what it fetched, which needs the checks Unit 4 gives for retrieval. As of November 2026, one provider's documentation says its assistant may search without being asked, so the same question can be answered from training text one day and from a fetched page the next.

So, for anything that may have changed, two questions. When does this system's training text end? And did it fetch anything this time? A link in the answer is generated text, not a record that anything was fetched. Where the product shows a record of its searches, that is the evidence; where it does not, the second question stays unknown. Either way, open what it links. That tells you whether the source is sound, not whether it searched this time. And if it names no source, find one yourself.

Consequence 1

Now the consequences, and there are three that matter for your work.

[On screen: The prompt 'A Bernoulli number is' forks into two runs, run 1 and run 2, with the same prompt and context. Below, one bar chart forms over five candidate next tokens with illustrative, hand-authored probabilities ('a' 0.46, 'one' 0.21, 'defined' 0.14, 'an' 0.11, 'the' 0.08), labelled as the same distribution for both runs. Run 1 samples 'a' and run 2 samples 'defined'; each token flies up to its own run. Blank chips then extend each run, and a label says each run now continues from different text. The closing text says the values are illustrative and that repetition can show stability or change, but it does not tell you which answer is correct.]

First: selection can involve sampling rather than always taking the maximum. Sampling draws the next token at random, with likelier tokens drawn more often. The random numbers usually come not from a physical process but from a pseudo-random number generator, a fixed calculation started from a number called a seed. The same seed repeats the same draws, so with everything else unchanged the same text comes out again.

From different seeds, the same prompt and context can produce different text on different occasions. A fixed deterministic procedure should repeat under fixed conditions. A language-model service can vary because of sampling, changed settings, tools, or a changed model.

Questioner: So does asking twice tell me which is right?

Narrator: Asking again can show stability or change, but it does not tell you which answer is correct.

Questioner: And asking whether it is sure?

Narrator: That tests something else. A study published in 2024, of assistants from 2023, found that those trained with human feedback shift towards what the user appears to believe, and that a bare "are you sure?" can lead to a reply that retracts a correct answer. So that question tests how the system reacts to pressure. It does not test whether the answer is right. Ask neutrally, or ask for the evidence against the answer.

Consequence 2

Second: the system is built to produce a continuation that fits its context. Correctness is not worked out separately at that step. In a system with no search or database attached, nothing at that step consults a record of what is true. Where a system does have retrieval attached, that changes where you have to point your checking, not whether you have to check.

Consequence 3

Third, and this is the one to take away. Fluency does not establish correctness.

Questioner: Can I tell a false sentence by how it reads?

Narrator: A true sentence and a false sentence can both be well formed, specific, and confident-sounding. A false one need not look any rougher. So the cues you normally use to judge whether writing is reliable can accompany correct or incorrect content. Those cues are fluency, specificity, a confident tone, correct formatting and plausible detail. None is sufficient evidence alone. It also reads as though a person wrote it, and a person who says "I checked" has usually checked. From a system, "I checked" is generated text like the rest, not a record of a check, so look for the work itself: a source you can open, output you can run again, or the product's record of the searches it ran.

Hallucination

The established term for fluent false output is hallucination. The course's glossary defines it; the course uses it because it is the term you will meet elsewhere. Be careful with it, though, because the word makes it sound like an unusual event, a malfunction. It is the same process that produces the correct output, on an occasion when the plausible continuation and the true one were not the same thing.

Two things this is not

Two things this unit is not saying. It is not saying the output is random. Even when it samples, the token probabilities constrain which continuations are likely. And it is not saying do not use these systems; this course has you use one in Unit 7. What it is saying is that looking alone does not establish which case you are in.

The wrong question, and the right one

So the question is never "does this look right?" It is "how would this be wrong, and what check catches that?" And there are three broad answers, which is your activity.

Three kinds of check

Some outputs need exact checking. A calculation, a conversion, a piece of code — things with a right answer you can compare against, by running them or by recomputing them yourself against values you already know.

Checker: The lab's oracle, its trusted source of correct Bernoulli values, is checked this way. Run it, and it compares its values with twenty-two published ones and agrees with all of them.

Narrator: Even with no known values, units of measurement give a cheap exact check. A result whose units do not match what was asked for is wrong before you look at a digit. Some need source checking. A date, a citation, an attribution, a claim about what a document says — things that cannot be executed at all, only looked up in the record. No amount of running the output tells you whether the reference exists. And some are low-risk drafting. A first attempt at a paragraph you were going to rewrite, a list of possible titles, a rephrasing of your own notes. Errors are cheap, visible, and yours to fix on the next pass. A judgement fits none of the three. Check its premises by source or calculation, and keep its conclusion a proposal.

Your turn: triage by failure mode

The categories are not about how important the task is. They are about how an error would reach you, and that is what decides the check. And one output can span kinds: generated code with a comment about who invented the method needs an exact check and a source check. Go and sort the ten outputs in the activity into the three kinds. Then take the checkpoints.

Closing, 20 seconds, no speech. A candidate record on the left, a check against an independent reference in the middle, and a bracketed claim on the right fade in side by side. Below them: Continue with the course material, ai.qyber.dev/edu-ai-literacy-ada-verification/, Course playlist: youtube.com/playlist?list=PLPsBWTfgvakM, All links are also in the description, and Keep your record. Check the next claim.