We Taught
Rocks to Talk
From Markov chains (1913) to autonomous agents (2026)
Andrey Markov works out the maths for things that depend on what came before.
Three decades before there's a machine to run it on.
public domain
He counted 20,000 letters of a novel. By hand.
Every proof in probability at the time assumed events were independent — one coin flip tells you nothing about the next. In 1906 Markov proved the same laws survive when each event depends on the one before it.
Then he needed to show it on something real. Pushkin's Eugene Onegin: strip the spaces, mark twenty thousand letters vowel or consonant, count which follows which.
The new thing isn't the counting. It's the object — a chain of events where each one is governed by a fixed table of odds, and which you can still prove things about. That object is now named after him.
8,638 vowels · 11,362 consonants
Letters are not independent — and they're still predictable. The last letter changes the odds for the next.
Letters were just the demo.
The states can be anything.
Markov used vowels and consonants. Swap in sunny and rainy and you can simulate weather in a game — coin-flips look wrong, because real weather clumps.
You need only the current state — not the whole history.
Every row sums to 1. That's the only rule.
Swap the weather for words and you have a language model — which is exactly what Markov did in 1913, counting vowels and consonants through the first 20,000 letters of Eugene Onegin. The same maths runs PageRank, predictive text, gene sequencing and Monte Carlo simulation.
Claude Shannon generates English by picking likely next words.
In the paper that invents information theory.
Who’s happy with autocomplete?
Who just thought “mat”?
You didn't parse that sentence. You've just seen those words together more often than the alternatives. That is the whole method.
Slide the window across billions of words — newswire, parliamentary records, eventually the web — and tally every sequence. That's the training.
Keep the last n words — the context window. Throw the rest away.
One count divided by another. No grammar anywhere.
A Markov chain over words — Shannon was doing this by hand in 1948. Bigger n means more context, but you need exponentially more text to have ever seen it, so in practice n stopped at about five. Everything past that window is invisible to it. Hold onto the phrase context window: your model today has one too. It's just gone from 5 words to hundreds of thousands.
Alan Turing asks, in print, “Can machines think?”
Seventy-six years ago.
Who already knows what the Turing Test is?
He asked the question — then changed it.
It opens “I propose to consider the question, ‘Can machines think?’” — then abandons it, because answering would mean defining thinking first.
“…too meaningless to deserve discussion.”
Turing, on his own question
His substitute is testable: could an examiner tell a machine from a person, in writing?
He called it the imitation game.
A judge, two hidden players, and a screen.
- 1A judge questions two hidden players, A and B.
- 2Everything goes through a teleprinter — typed words only.
- 3The judge says which is which.
- 4Now swap one player for a machine.
His bar: fool the judge 30% of the time over five minutes — he expected that by 2000.
Zellig Harris: you can tell what a word means by the company it keeps.
Meaning, treated as a statistic.
Is this email spam? Count the words.
Nobody reads the message. You turn it into a tally of its words and let the counts decide. Enough free, winner, click here — it's spam. That's the entire classifier.
The same trick sorts news into topics, routes support tickets, and ranks search results. Any question of the form "what kind of document is this?"
The cost: word order is gone. “Cancel my free trial” and “free — cancel my trial” are now the same document. Crude — and it runs libraries, then inboxes, then search, for fifty years.
Three words, and it already looks far more like the left pile than the right. No reading required.
Declared nearly solved, then defunded.
January 1954: an IBM 701 translates Russian for the press — 250 words, six grammar rules. IBM calls it “an unqualified success.”
“Five, perhaps three years hence … may well be an accomplished fact.”
Leon Dostert, Georgetown, at the demonstration
1966 — a government committee reviews the progress: “no immediate or predictable prospect of useful machine translation.” The money stopped.
Funding for machine translation collapses. 1966 is the year language research is declared a dead end — and the year the most convincing talking program yet turns up at MIT.
IBM press materials, 7 January 1954
Joseph Weizenbaum, at MIT, publishes ELIZA.
The first convincing chatbot.
Who thought the first chatbot was younger than you?
Keep it up if you thought it was younger than your parents.
He wrote it to show how little it took.
The script was called DOCTOR: it imitated a Rogerian therapist, because a therapist can know nothing about your life and still keep the conversation going by handing your own words back to you.
People confided in it anyway. Weizenbaum's own secretary, who knew exactly what it was, asked him to leave the room.
He spent the rest of his career arguing against what he'd built.
People queued to use it. It was copied onto home computers for the next twenty years, and practising psychiatrists proposed developing it into real therapy. Reading understanding into a machine that has none is still called the ELIZA effect.
Two kinds of rule. Neither one reads.
Reflect it: swap my → your, hand the sentence back.
Or match a word: mother and father are tagged
FAMILY — either fires the same stock line. Nothing is echoed.
Recognised nothing? PLEASE GO ON.
Stores your “my …” sentences. When it recognises nothing, it replays one: EARLIER YOU SAID YOUR …
Keywords carry a priority. In “everybody laughed at me”, everybody outranks me.
Several replies per rule, used in turn — so it never answers the same shape twice running.
don't → do not · you are → I am, so the sentence
comes back grammatical.
Every one of them is a lookup. Nothing consults the dashed box.
Terry Winograd builds a program that genuinely understands you.
Inside a world containing seven blocks.
Language in. Actions out.
Inside a sandbox.
It isn't answering questions. It works out what it refers to, plans a sequence of moves, changes the world — then explains why.
That's tool use: instruction in, actions inside a sandbox, result back. The same loop every AI agent runs in 2026. SHRDLU's sandbox held seven blocks — today's holds your filesystem.
Every fact in it was typed in by a person. You cannot hand-write the world.
Karen Spärck Jones works out which words actually matter.
Twenty years before there's a web to search.
The most common words tell you nothing.
Count the words in any document and the top of the list is the, of, and, a. Every document looks the same. The counts are useless until you discount the words that are everywhere.
Frequent here, rare everywhere else → informative. In every document → worth nothing.
1972 — two decades before there was a web to search. Every search engine you have ever used is built on top of it.
Speech recognition stops trying to understand anything.
And immediately starts working.
Don't ask what it means. Ask what's most likely.
You never see the words — only the noise they made. So guess the sequence of words most likely to have produced that sound, using the Markov chain from earlier plus a table of what each word sounds like.
No grammar. No parsing. No understanding. It beat every rule-based system, and it is why your phone can take dictation.
“Every time I fire a linguist, the performance of the speech recogniser goes up.”
attributed to Fred Jelinek, IBM
The counting finally has enough to count.
Not a new idea — a new pile of text.
The dead end comes back — and wins.
1966: “no immediate or predictable prospect of useful machine translation.” Twenty-five years later IBM tries again — and this time trains on the Canadian Hansard: millions of sentences already published in both English and French, by law.
Nothing in it is new. Markov's chains, Shannon's n-grams, Harris's counts, Spärck Jones's weighting — all of it already existed. What the nineties add is the pile of text: digitised newspapers, parliamentary records, then the web.
It never learns grammar. It counts which French words tend to appear opposite which English ones. It beats twenty years of hand-written rules.
The first time most people meet NLP without knowing it.
Somebody has to read the internet. Nobody can.
Counting words, pointed at feelings.
Same bag of words as before. Score it on one axis and you get sentiment — is this review positive? Cluster the bags instead and you get topics — what is this pile of documents about?
Movie reviews, 2002: bag-of-words plus a simple classifier gets you around 80% accuracy on thumbs up versus thumbs down. Suddenly every company wants this pointed at their customers.
It still can't read. “This film was not remotely as bad as I expected” is positive — and full of negative words. Sarcasm destroys it.
One number, from a pile of counts.
Yoshua Bengio stops treating words as symbols and starts treating them as numbers.
Nobody notices for ten years.
Give every word a list of numbers.
Until now every word is its own symbol. cat and kitten are exactly as unrelated as cat and Tuesday — the machine has no way to express that two words are similar.
So Bengio hands each word a row of numbers and lets the network learn the numbers while it learns to predict the next word. Words used the same way drift to similar numbers.
Which fixes the n-gram's worst problem. Never seen “the kitten sat”? Fine — kitten looks like cat, and you've seen plenty of those.
Words → a learned table of numbers → a prediction.
A team at Google works out how to put meaning on a map.
And the map does arithmetic.
Meaning, as a direction you can travel.
Every word gets a few hundred numbers — a point in space. Words used alike land near each other. But the surprise is what the directions between points turn out to mean.
Who got queen?
So does the machine. Nobody taught it what a queen is. It read a lot of text and the arithmetic came out.
The step from man to woman is the same step as king to queen.
A translation model is allowed to look back at any word it wants.
The context window stops being a window.
Let it look back at everything.
Translation models read a sentence, crushed it into one fixed list of numbers, then wrote the translation from that. Long sentence, same size box. Whatever didn't fit was gone.
Attention removes the box. For every word it writes, the model can look back at every word of the input and decide which ones matter right now.
Remember the n-gram's five-word window? Gone. “I grew up in Honduras… so I speak fluent ___” — it can reach back twelve words and find it.
Every output word gets to consult every input word.
Every word asks a question. The others answer.
You know it means the animal. Nothing in the model was told that. Here's what it computes instead.
A query — what am I looking for? A key — what do I offer? A value — what I contribute if picked. Each is the word's numbers times a learned matrix.
A dot product. Two vectors pointing the same way score high. That is the entire definition of “relevant”.
Softmax turns them into weights that add up to 1 — a budget of attention.
Illustrative weights. The new vector for it is now mostly “animal” — the word has been rewritten to carry what it refers to.
That's it. softmax(Q·Kᵀ) · V — score, normalise, average. Do it for every word at once, and you have attention.
Eight people at Google publish a paper with a very confident title.
Everything after this slide is that paper.
“Attention Is All You Need”
Every model before this read a sentence one word at a time, each step waiting on the one before it. The paper's claim is in the title: you can throw all of that away and keep only attention.
No order means no waiting. Every word is processed at the same time — so you can train on far more text, on far more hardware, than anyone could before.
Everything after this slide is this architecture. BERT, GPT, Claude, Gemini — all of it. The T in ChatGPT is this paper.
Attention is one ingredient. Here's the recipe.
Attention sees everything at once, so order is invisible to it. A number for position is added to each word first — the only reason dog bites man differs from man bites dog.
- 1Multi-head attention. Run that query-key-value machinery eight times at once. One head ends up tracking grammar, another what refers to what — nobody assigns those jobs.
- 2Add the input back. The block edits meaning rather than replacing it — which is what lets you stack a hundred without the signal falling apart.
- 3A small network per word. Where most parameters — and most knowledge — actually live.
Then stack it: six blocks in 2017, around a hundred today. Each layer feeds the next, refining meaning every pass.
Stop training a new model for every job. Train one, then adapt it.
BERT and GPT, six months apart.
One model, pre-trained. Then adapted.
Both cut the 2017 transformer in half. BERT keeps the encoder — reads a sentence both directions at once, built to understand. GPT keeps the decoder — left to right, built to write.
The shared idea outlives both: pre-train once on an enormous pile of ordinary text, then adapt cheaply. Language is learned once and reused.
BERT was in Google Search within a year. GPT's line just kept getting bigger.
Pre-training only mattered because the weights got shared. Hugging Face made trained models something you download in a line of code — and became where the field publishes. It's why this reached the rest of us.
Same architecture. Opposite halves.
What you hide decides what it becomes.
Mask about one word in seven and make it guess. It can look left and right, so it builds a rich sense of the sentence — and is hopeless at continuing one, because it was never asked to.
One line of code does this: block every word from attending to its future. Now the only thing it can learn is what comes next — so it can be trained on any text at all, unlabelled.
Look closely at the right-hand one. Predict the next word from the words before it — that is Shannon in 1948, and the n-gram counting table from the nineties. Identical task. The only difference is that the counting table became a hundred layers of attention, and the pile of text became the internet.
Nobody adds a new idea. They just make it enormous.
And it starts doing things it was never trained to do.
Bigger stopped being boring.
117 million parameters in 2018. 1.5 billion in 2019. 175 billion in 2020. Same architecture throughout — more text, more compute, more numbers.
And it started doing jobs nobody trained it for. Show it two examples in the prompt and it does the task — no retraining, no new model. Translation, summarising, code.
That's the birth of prompting. The interface to AI stopped being code and started being a sentence you write.
Same idea, four orders of magnitude.
You can change what a model does without retraining a single one of its billions of weights.
The slide that put big models in reach of small teams.
Change the behaviour. Keep the model.
Fine-tuning takes a finished model and trains it further on your examples. It works — but the classic version updates every weight, leaving you a private copy of a 175-billion parameter model per task. Nobody can afford that.
LoRA: freeze the original weights, and train a small pair of matrices alongside them. You're adjusting the model's behaviour through a side channel instead of rewriting it — orders of magnitude fewer numbers to train.
A data-centre job becomes a single-GPU job. The result is a few megabytes, not a few hundred gigabytes, and you can swap adapters like plugins on one shared base model.
Which is why your company can have a model that sounds like your company — without owning a data centre.
Fine-tuning changes the model. RAG only changes what you hand it.
Don't learn a new matrix. Learn two thin ones.
A model is stacks of weight matrices. Take one — 4096 × 4096, about 16.8 million numbers. Ordinary fine-tuning learns a change for every one of them, for every matrix, for every task.
Multiply a tall-thin by a short-wide and you get a full-size matrix — but one that can only vary in 8 directions. The bet: adapting to a task is a small nudge, not a rebuild.
W never moves. Only A and B get gradients — 65,536 numbers instead of 16.8 million, per matrix. That's the whole saving.
Fold W + BA into one matrix and it runs at exactly the original speed. Or keep them apart and swap A and B per customer.
The technology barely changes. The packaging does.
Five days to a million users.
Raw models are useless. This one had manners.
A model trained only to predict text will happily continue your question with more questions. It isn't trying to help you — helping was never the objective.
RLHF: have humans rank the model's answers, train a second model to predict those rankings, then tune the first one to score well. You are no longer teaching it facts — you're teaching it what a good answer looks like.
It works absurdly well. A 1.3B model tuned this way was preferred by human raters over the raw 175B one. Behaviour beat size by 100×.
Nothing new at the bottom. Everything new at the top.
A hundred million people discover it will confidently make things up.
Not a bug. The design.
It was never storing facts.
It predicts plausible next words. Fluent and true are separate axes, and it only optimises one of them. There is no little database inside to check against.
RAG — go and fetch the real documents first, put them in the prompt, answer from those. And the retrieval step is often still Spärck Jones's 1972 weighting, quietly doing the work.
This idea is forty years old. Case-based reasoning, 1982: don't reason from rules, retrieve the closest past case and adapt it. It mostly stalled — because a human had to hand-specify what “similar” meant, field by field.
Embeddings are what unstuck it. Similarity became something you measure, not something you write down — so retrieval finally works on anything. And remember: RAG changes what it knows, fine-tuning changes how it behaves.
Models stop answering immediately and start working it out first.
The second thing you can spend compute on.
Let it think for longer.
Someone noticed that adding four words to a prompt — “think step by step” — made models dramatically better at hard problems. Same model, same weights. It just spent more words before answering.
So train that in. The model now works through the problem privately, checks itself, and only then replies. There are two dials: how big you train it, and how long it thinks.
Nothing is free — thinking costs money and seconds per question. But for the first time, a model can spend more effort on a harder problem.
Two dials now, not one.
The model stops being the whole system and becomes the part that decides.
We have seen this loop before. 1970.
Language in. Actions out. Sound familiar?
A model that can only produce text is stuck in the box. Give it tools — search, a database, your code — and let it decide when to reach for one. It acts, gets a result back, and carries on.
MCP made that a standard plug. Before it, every tool needed a bespoke integration for every model. One protocol, any tool, any model. USB-C for AI.
That's SHRDLU's loop, exactly — and SHRDLU is from 1970. The difference: its sandbox held seven blocks that a person typed in. This one holds the real world.
One plug, many sockets.
You stop asking for answers and start assigning work.
Which is where we are standing tonight.
Run the loop without asking permission each time.
Plan. Act. Look at what happened. Adjust. Go again. An agent is not a smarter model — it's the same model, in a loop, with tools and no human in every turn.
What that buys is duration. Not one answer, but twenty minutes of work: read the codebase, make the change, run the tests, see the failure, fix it.
It also compounds mistakes. A wrong step at minute two is still wrong at minute twenty, only now with more built on top of it.
The same four steps, over and over, unattended.
It learned from us. All of us.
Every one of these models learned language from human text — which means it learned our biases with our grammar. Not as a flaw in the training. As a faithful summary of the data.
And it is confidently wrong in exactly the register of someone who is right. Fluency is not evidence. That was true of ELIZA in 1966 and it is true tonight.
Which is why the interesting question in 2026 isn't can it? — it's where does a human stay in the loop, and who answers when it's wrong.
The design decision that actually matters: where the gate goes.
Sixty years, same conversation.
One of these is find-and-replace in a trench coat. The other one read your codebase and changed it. Both of them felt like talking to something.
Turing's bar was fool a judge 30% of the time, over five minutes — and he thought it might happen by 2000. Nobody argues about that number any more. We are so far past it that we stopped keeping score.
Thank you.
We taught rocks to talk.
This talk was built with the thing it's about.
Primary sources chased down and cross-checked — the 1954 IBM press release, the ALPAC report, Turing's own wording. Dates that disagreed across sources were softened on the slide rather than guessed.
Every blueprint diagram generated to a written spec in one house style, then processed so the linework composites onto the deck's palette.
Photographs sourced and licence-checked, from the Georgetown punch card to the Huelga del 54 — every credit logged, attribution kept where the licence demands it.
The deck is plain HTML in version control, assembled by a script and screenshot-tested slide by slide so nothing runs off the edge.
Want to see how it was actually done — the prompts, the pipeline, the parts that failed? Come and ask me. flintsparklabs.com