The Dream of Thinking Machines

Sit someone at a keyboard, connect them to two hidden partners, one human and one machine, and give them five minutes of typed conversation to name the human. Cameron Jones and Benjamin Bergen of UC San Diego ran exactly that test in a preregistered study, meaning they filed their hypotheses and analysis before collecting any data; it appeared online in March 2025 and in PNAS in May 2026. One of their machines was GPT-4.5, a large language model from OpenAI, the kind of system behind ChatGPT. Given written instructions, called a prompt, to play a particular humanlike persona, GPT-4.5 was picked as the human in 73% of its games, more often than the real people it was up against.

Alan Turing had proposed the test in 1950 and attached a forecast with numbers in it. In about fifty years, he wrote, it would be possible to program a computer with a storage capacity of about 10⁹ binary digits, roughly 125 megabytes in today's units, to play his "imitation game" so well that an average interrogator would have no more than a 70 per cent chance of making the right identification after five minutes of questioning. The year 2000 passed without it. When the result came, the interrogators identified GPT-4.5 correctly 27% of the time: far under Turing's 70%, and a quarter of a century late.

The same study carries a warning. ELIZA, a program written at MIT in 1966 that mostly turns your sentences back into questions, was picked as the human 23% of the time, about as often as OpenAI's far more capable GPT-4o (21%), which was tested without the persona prompt. GPT-4.5 itself, told only to convince the interrogator that it was human, was picked 36% of the time; the persona instructions doubled its score. A test that a 1966 pattern matcher can nearly tie, and that a paragraph of instructions can double, measures something real, but not intelligence in any sense an engineer could build on.

Where did the question "can a machine think?" come from, and why is a behavioural test such a slippery way to answer it? The history is short on myths and long on engineering. Over three centuries people made reasoning precise enough to calculate, built machines that follow instructions, proved what any machine can and cannot compute, modelled neurons as logic gates, and in 1956 gave the whole enterprise a name. Each step made one thing executable and exposed a limit that still shapes AI systems in 2026. Along the way you will run a Turing machine by hand, build logic gates out of artificial neurons and reproduce ELIZA's trick with four rules. You will finish with a decision that every team deploying an AI agent, software that uses an AI model to choose and carry out actions such as running code, has to make: which behaviour you can check exhaustively, and which you can only sample.

Before you start

This is a Beginner chapter and the first in the handbook. You need no background in AI, no mathematics beyond school algebra (the two logarithms that appear are worked out with numbers), and no programming to follow it. The Python and Java programs in the Examples and Java tabs are optional: if you have written a loop and an if statement you will recognise the ideas in them, and if you have not, the text explains everything they do.

By the end you should be able to:

• trace a Turing machine's rule table on a tape and predict its output and step count;
• build AND, OR and NOT from threshold neurons, and explain why one neuron cannot compute XOR;
• turn a Turing-test "judged human" rate into the interrogators' accuracy, and say what the number does and does not show;
• explain why no tool can check an arbitrary program, or AI agent, for every harmful behaviour, and estimate how many failure-free test runs support a failure-rate claim.

How to read this volume

Volume 1 has fifteen chapters in three sections. Chapters 1 to 5 cover history and vocabulary: the origins you are about to read, a working definition of an AI system in Chapter 2, the types people argue about (narrow, general, agentic) and how to test a type claim in Chapter 3, the booms and busts in Chapter 4, and rules versus learning in Chapter 5. Chapters 6 to 10 explain how machines learn from data: supervised, unsupervised and reinforcement learning, and the deep-learning revolution. Chapters 11 to 15 cover modern AI: foundation models, large language models, generative and multimodal AI, and a review chapter that ends with a design decision you make with numbers.

Two conventions run through the whole handbook. Every fact about a real system, paper or product carries a source, and facts that change, such as prices, model line-ups and laws, carry an "as of" date. Every chapter also has Python and Java programs that print identical output, so you can check any computed number yourself.

Several threads start here and finish later in the volume:

Logic becomes calculation

Around 350 BCE Aristotle catalogued arguments that are valid because of their shape rather than their subject. "All mammals are animals; all whales are mammals; therefore all whales are animals" has the form all B are C, all A are B, so all A are C, and any argument with that form is valid whatever A, B and C stand for. You can check it without knowing what a whale is. That separation of form from content is the precondition for everything that follows: a procedure can check form, and a machine can carry out a procedure.

The machines came first as calculators. In 1642 Blaise Pascal designed an adding machine to help with his father's tax arithmetic. Each digit sat on its own toothed wheel, and when a wheel passed from 9 to 0 it pushed the next wheel on by one: the carry that every adder since has had to implement.

Gottfried Wilhelm Leibniz went further on two fronts. On 1 February 1673 he showed the Royal Society in London a wooden model of a machine meant to multiply as well as add. For decades he also chased a larger hope, a notation in which reasoning itself could be carried out by calculation, so that a dispute could be settled by working it out. He never built that notation, but in 1703 he published an account of arithmetic that uses only two digits, 0 and 1.

George Boole supplied the algebra. In An Investigation of the Laws of Thought (1854) he treated a statement as a quantity that is either 1 (true) or 0 (false) and showed that logic then obeys ordinary algebra with one extra law:

Only 0 and 1 satisfy it, since $0 \cdot 0 = 0$ and $1 \cdot 1 = 1$. With that restriction the logical operations become arithmetic:

Take x = "the invoice is approved" = 1 and y = "the supplier is on a sanctions list" = 0. Then x AND y is 1 · 0 = 0, x OR y is 1 + 0 − 0 = 1, and NOT y is 1 − 0 = 1. Boole's law also yields the principle of contradiction: rearranged, $x^2 = x$ says $x(1 - x) = 0$, so a statement and its negation are never both true.

Eighty-three years later, in a master's thesis submitted to MIT on 10 August 1937, Claude Shannon showed that Boole's algebra describes circuits of relays exactly. Two switches in series conduct only if both are closed, which is AND; two in parallel conduct if either is, which is OR. From then on, a switching circuit could be designed on paper and simplified with algebra instead of being built and tried, and every digital computer since is made of gates that compute Boole's three operations.

Instructions as data: Jacquard, Babbage and Lovelace

A calculator does one job. The idea that a machine could do different jobs depending on instructions fed to it came from weaving. In 1801 Joseph-Marie Jacquard demonstrated a loom controlled by a chain of punched cards: the holes in each card decided which threads lifted for one pass of the shuttle, so changing the cards changed the pattern without changing the loom.

Charles Babbage borrowed the cards. From 1834 he designed the Analytical Engine, a machine meant to evaluate any formula it was given. Its Store would hold 1,000 numbers of 50 decimal digits each, its Mill would do the arithmetic, and two kinds of card would drive it: Operation cards to choose the arithmetic and Variable cards to say which columns of the Store to use. Babbage never finished it. When he died in 1871, a trial model of part of the Mill, with its printing mechanism, was still under construction; it is now in the Science Museum in London.

Most of Babbage's design maps straight onto a modern machine: the Store is memory, the Mill is the arithmetic part of a processor, Operation cards are instruction codes and Variable cards are addresses. The missing piece, drawn in Figure 1.3, is where the program lives. Babbage's program stayed on cards outside the Store, so the machine could read its instructions but never compute a new one. John von Neumann's First Draft of a Report on the EDVAC, distributed on 30 June 1945, put instructions and data in the same memory, the stored-program design that most computers since have followed. A program held in memory can be loaded, altered and even written by another program, which is how an operating system starts your applications and how an AI agent can write a script and then run it.

Ada Lovelace saw how far the idea reached. In her 1843 notes on Luigi Menabrea's description of the Engine, she wrote that it "weaves algebraical patterns just as the Jacquard-loom weaves flowers and leaves", argued that it could manipulate any symbols whose relationships could be expressed, musical notes included, and set out in her Note G a table of operations for computing the Bernoulli numbers. Historians still argue over how to divide the credit for that table between her and Babbage; the insight that a calculating machine is a symbol-manipulating machine is hers. She also drew a line that Turing would answer a century later: the Engine "has no pretensions whatever to originate any thing. It can do whatever we know how to order it to perform."

What any machine can compute: Turing's 1936 paper

In 1928 David Hilbert and Wilhelm Ackermann posed the Entscheidungsproblem, German for "decision problem": is there a mechanical procedure that takes any statement of formal logic and decides, in a finite number of steps, whether it can be proved? Answering required something nobody had, a precise definition of "mechanical procedure". Alan Turing, then 23, supplied one in "On Computable Numbers, with an Application to the Entscheidungsproblem" (1936).

His definition starts from a person computing with pencil and paper and strips away everything inessential. What is left is a machine with:

• a tape divided into cells, each holding one symbol or a blank, as long as the computation needs;
• a head that reads and writes one cell at a time and moves one cell left or right;
• a finite set of states, the machine's only memory apart from the tape;
• a rule table that says, for each combination of state and symbol read, what to write, which way to move and which state to enter next.

Nothing else. The machine below has two working states and six rules, and it adds one to a binary number. In binary each position is worth twice the one to its right, so 1011 means 8 + 0 + 2 + 1, which is eleven. Step through the machine on 1011 and watch where the head goes.

[1] 0  1  1
state: right

The division of labour is the point. In state right the machine only moves; in state carry it turns every 1 into 0 until a 0 or a blank absorbs the carry. Everything a computer does can be broken down into steps this small, and Turing's argument was that nothing a person does when calculating by rule needs more than this: a finite table, a readable and writable tape, and time.

Two results from the 1936 paper matter for everything later. The first is the universal machine. A rule table is just a list of symbols, so it can be written on a tape. Turing described a single machine that reads another machine's table from its tape and imitates it step by step, so one fixed machine can do what any machine can do, given the right description as input. That is the idea of software, and it is why the same phone runs a calculator and a chess program.

The second is a limit. Turing proved that no machine can take an arbitrary machine description and decide whether that machine will ever halt (in his own formulation, whether it will ever print a given symbol); textbooks now call this the halting problem. From it he showed that the answer to Hilbert and Ackermann's question is no. Alonzo Church reached the same answer independently in 1936 with a different formalism. In 1953 Henry Gordon Rice generalised the limit: every non-trivial question about what a program does, as opposed to how its text looks, is undecidable for programs in general. The last section turns that result into a decision about AI agents.

Neurons, feedback and information, 1943 to 1958

Turing's machine describes computation by rules. A second line of work, begun during the war, asked how a brain could compute at all, and modern AI descends from it.

In 1943 the neurophysiologist Warren McCulloch and the logician Walter Pitts modelled a neuron as a threshold unit: it receives signals that are either on or off, and it fires if enough of its excitatory inputs are on and no inhibitory input is. They showed that networks of such units can compute any expression in Boole's logic. In the modern notation, a unit with inputs $x_1, x_2 \in \lbrace 0, 1 \rbrace$, weights $w_1, w_2$ and threshold $\theta$ outputs

With both weights 1 and a threshold of 2 it computes AND: only $1 + 1 = 2$ reaches the threshold. Lower the threshold to 1 and it computes OR. A single weight of −1 with a threshold of −0.5 computes NOT. Load those presets below, then try to make the unit fire for exactly one of its two inputs, the function called XOR.

No setting works, and a two-line argument shows why. To stay silent on (0, 0) the threshold must be positive. To fire on (0, 1) and on (1, 0), each weight must reach the threshold on its own, so together the two weights reach at least twice the threshold, and the unit fires on (1, 1) as well. The chapter's program checks 1,323 settings of the weights and threshold and confirms it: one unit can compute 14 of the 16 possible functions of two inputs, but never XOR or its negation. Two layers fix it: one unit computes OR, a second computes NAND, and a third takes the AND of their outputs. Chapter 4 tells how this limit, analysed by Marvin Minsky and Seymour Papert in their 1969 book Perceptrons, fed the first collapse of neural-network research, and Chapter 10 how multi-layer networks and a way to train them brought the field back.

Three more ideas arrived within a decade. In 1948 Norbert Wiener's Cybernetics described animals and machines alike as feedback loops that measure the gap between goal and outcome and act to close it, the loop at the centre of reinforcement learning in Chapter 9. In 1949 the psychologist Donald Hebb proposed that a connection between two neurons strengthens when they are active together, the first learning rule for a network. And in 1948 Claude Shannon's "A Mathematical Theory of Communication" measured the information in an event of probability p as

A fair coin flip carries $-\log_2 0.5 = 1$ bit. If a model gives the word that actually comes next a probability of 0.25, it is charged $-\log_2 0.25 = 2$ bits; had it given that word 0.5, it would be charged 1 bit. Training a large language model means adjusting its weights to lower that charge, averaged over trillions of words of text. The average is called cross-entropy, and Chapter 12 builds on it.

In 1958 Frank Rosenblatt's perceptron took the next step: threshold units whose weights were learned from labelled examples, nudged after every mistake, instead of being set by hand. The weights you just moved by hand are what a perceptron learns.

Can a machine think? The imitation game

In "Computing Machinery and Intelligence" (1950), Turing declined to define thinking and proposed a game instead. Three people play: a man (A), a woman (B) and an interrogator (C) of either sex in a separate room. C asks questions and must decide which of the other two is the woman; A tries to mislead, and B tries to help. The answers are typewritten, ideally over a teleprinter, so that voices give nothing away. Then Turing asked: "What will happen when a machine takes the part of A in this game?"

Turing swapped a question nobody can settle (does it think?) for one that can be measured (can people tell it apart from a person under stated conditions?). Turing stated the conditions and made the forecast you met at the start: five minutes of questioning, an average interrogator, a machine of about 10⁹ binary digits, and a right-identification rate of no more than 70% within about fifty years. In the same paper he answered Lovelace, under the heading "Lady Lovelace's Objection": machines surprised him often, he wrote, and a machine that learns could end up doing things nobody explicitly ordered it to do.

Jones and Bergen's study ran Turing's three-party version in two randomised, preregistered experiments on separate groups of participants, with five-minute conversations. The machine witnesses were ELIZA, OpenAI's GPT-4o and GPT-4.5, and Meta's LLaMa-3.1-405B, another large language model. GPT-4.5 and LLaMa each played twice, once with the persona prompt and once with minimal instructions: only that this was a Turing test and that they should convince the interrogator they were human. Because every game pits one human against one machine, the interrogators were right about a witness exactly as often as they did not pick it as the human:

By Turing's own criterion the question is settled for five-minute text conversations: the persona-prompted GPT-4.5 was chosen over a real person more often than chance would allow. Read down the table, though, and the prompt matters as much as the model. The same GPT-4.5 falls from 73% to 36% when the persona instructions are taken away, and with minimal instructions neither large model consistently beat ELIZA's handful of rules across the two experiments. A behavioural test answers exactly the question its conditions define, and nothing wider.

Dartmouth, 1956: a field gets its name

On 31 August 1955 John McCarthy, Marvin Minsky, Nathaniel Rochester and Claude Shannon signed a funding proposal to the Rockefeller Foundation. "We propose," it began, "that a 2 month, 10 man study of artificial intelligence be carried out during the summer of 1956 at Dartmouth College in Hanover, New Hampshire." The proposal is generally credited with the first use of the phrase "artificial intelligence", and its premise still frames the field: "The study is to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it."

It was also a forecast, and a poor one: "We think that a significant advance can be made in one or more of these problems if a carefully selected group of scientists work on it together for a summer." The problems included making machines use language, form abstractions and concepts, and improve themselves. The proposers asked for $13,500 and the foundation granted $7,500. Language and self-improvement were still research problems seventy years later, and the distance between one summer and seventy years is the subject of Chapter 4.

One program discussed that summer already worked. Allen Newell and Herbert Simon, with Cliff Shaw, had built the Logic Theorist, which searched for proofs in propositional logic. It proved 38 of the first 52 theorems in Chapter 2 of Whitehead and Russell's Principia Mathematica, and for theorem 2.85 it found a shorter proof than the authors'. It was symbolic AI in its purest form: knowledge written as rules, and intelligence as search through their consequences. Rosenblatt's perceptron, two years later, took the other road, behaviour learned from examples. Chapter 5 sets the two side by side; most AI systems in 2026 combine them.

ELIZA's failure: fluent, and understanding nothing

In January 1966 Joseph Weizenbaum of MIT published ELIZA, a program that conversed in typed English. Its best-known script, DOCTOR, imitated a psychotherapist of the kind who answers questions with questions. The paper's sample conversation opens like this (ELIZA's replies are in capitals):

Men are all alike.
IN WHAT WAY
They're always bugging us about something or other.
CAN YOU THINK OF A SPECIFIC EXAMPLE
Well, my boyfriend made me come here.
YOUR BOYFRIEND MADE YOU COME HERE
He says I'm depressed much of the time.
I AM SORRY TO HEAR YOU ARE DEPRESSED

ELIZA knows nothing about men, boyfriends or depression. Each rule has a keyword with a rank, a decomposition pattern that splits the sentence around the keyword, and a reassembly template that builds a reply from the pieces, with pronouns swapped (my becomes your, me becomes you). "Well, my boyfriend made me come here" matches the pattern "anything, my, anything"; the second piece, "boyfriend made me come here", has its pronouns swapped and is placed after "YOUR". Part 3 of the chapter's program reproduces those four replies with four such rules, and then shows what the same rules do with input nobody planned for:

My gloop made me frimble.
YOUR GLOOP MADE YOU FRIMBLE
I am deeply sick of purple arithmetic.
I AM SORRY TO HEAR YOU ARE SICK

The program worked as designed. The failure was in what people concluded from it.

Symptom. Users confided in ELIZA as if it understood them. Weizenbaum later recalled that his own secretary, who had watched him build the program over many months, asked him to leave the room after a few exchanges so that she could talk to it in private.

Diagnosis. Fluent, well-formed replies in a short, cooperative conversation are cheap to produce, and people readily read understanding into them. Nothing in those conversations tested whether the program knew anything, because the user was helping it along.

Fix. Decide what capability you actually need, then test for it with inputs the system was not tuned on, including hostile and nonsensical ones, and count results over many trials instead of being persuaded by one good transcript. Weizenbaum spent much of his later career, notably in Computer Power and Human Reason (1976), arguing against handing human judgement to machines on the strength of such impressions.

Sixty years later the trap has a new form. A language model's fluent, confident answer can be false, the failure called hallucination that Chapter 12 explains, and the defence is the same: test what the system knows, not how it sounds. The 2025 test measured how convincingly models chat, which is why ELIZA still collected almost a quarter of the votes.

What you can prove about an AI agent in production

Suppose your team deploys an AI agent that writes and runs small scripts against your systems, and a reviewer asks for proof that it can never delete production data. Rice's theorem says that no tool can deliver that proof for arbitrary scripts: "never deletes production data" is a property of what a program does, and no algorithm decides such properties for every program. Real static analysers, tools that inspect code without running it, cope by accepting only a restricted class of programs or by answering "don't know" on some of them.

That leaves three moves, and production systems use all three:

1. Restrict the component, so the question becomes decidable or moot. A workflow engine with a fixed set of states and transitions can be checked exhaustively, and an agent whose credentials lack delete permission on production cannot delete production data, however its scripts are written.
2. Enumerate when the inputs are few enough to check every case.
3. Sample when they are not, and report a statistical bound instead of a guarantee.

The number of possible inputs decides between the last two, and it grows fast. (A token, used in the last row, is a word or a piece of a word; Chapter 12 explains them.)

When you must sample, zero failures does not mean a zero failure rate. If a system fails independently with probability p on each run, the chance of n clean runs in a row is $(1 - p)^n$. Suppose the agent really failed 1% of the time. Then 299 clean runs in a row would happen with probability $0.99^{299} \approx 0.05$, one time in twenty. So when you do see 299 clean runs, a 1% failure rate has become hard to believe, and you can rule it out at 95% confidence, 95% being one minus that one-in-twenty chance. In general, n clean runs rule out a failure rate p at confidence c once $(1 - p)^n \le 1 - c$. Taking logarithms of both sides (ln is the natural logarithm, the ln key on a calculator) and solving for n gives

The approximation is the medical statisticians' rule of three (Hanley and Lippman-Hand, 1983): $\ln 0.05 \approx -3$, and for a small p, $\ln(1 - p) \approx -p$. To claim a failure rate under 1% at 95% confidence you need 299 consecutive clean runs; under 0.1%, you need 2,995. Every tenfold tightening of the claim costs ten times as many runs, which is why the target failure rate belongs in the design review, next to the security and cost budgets, not in a footnote to the test report. Public benchmarks rarely get you there. The retail test set of τ-bench has 115 simulated customer-service conversations for an online shop, and SWE-bench Verified has 500 real GitHub issues for an agent to fix. An agent that passed every task in the first would bound its failure rate only below 2.6%, and one that passed every task in the second, below 0.6%.

The decision rests on whether the component can express arbitrary behaviour. Where it cannot, as with a rule over a few facts, a finite workflow or a parser for fixed-size input, enumerate or verify, and you get certainty. The answer flips at about the size of your test budget: a few billion cases can be checked outright, and beyond that you are sampling whether you admit it or not. Where the component can express arbitrary behaviour, as an agent writing code or a model reading free text can, certainty is off the table, and your evidence is the permissions you withheld plus a failure-rate bound that shrinks only as 3/n. That is why agent platforms lean on sandboxes (isolated environments where a script can touch nothing real), allow-lists of permitted commands and credentials scoped to a single task, and why Chapter 2 treats what a system is allowed to do as a separate design axis from what it can do.

Summary

The idea of a thinking machine became engineering when its parts became precise. Aristotle separated an argument's form from its content, Boole turned that form into algebra over 0 and 1, and Shannon wired the algebra into relays. Jacquard and Babbage made instructions into data a machine could follow, and Lovelace saw that such a machine manipulates symbols, not only numbers. Turing defined computation with a tape, a head and a rule table, showed that one universal machine can imitate every other, and proved that no machine can decide every question about what programs do. McCulloch and Pitts built logic from threshold neurons, and Rosenblatt made those neurons learn.

Turing's 1950 paper replaced "can machines think?" with a measurable test, and in 2025 a persona-prompted GPT-4.5 passed it, chosen as the human in 73% of five-minute conversations. ELIZA, a handful of pattern rules from 1966, was chosen 23% of the time in the same study, and GPT-4.5 without its persona prompt 36%. Behavioural evidence answers the question its test conditions define and nothing wider.

For systems you deploy, Turing's limit becomes a working rule: restrict what a component can do, enumerate where the inputs are few, and sample where they are not, remembering that n clean runs bound a failure rate only to about 3/n.

Chapter 2 turns from history to definition. It asks what makes a system an AI system at all under research, standards and legal definitions, and describes any system on six axes; the last of them, authority, is where the permissions you just met become an explicit design choice.