Mythology, automata and the origin of the question: the early history of AI, from Turing to the first winter

Long before anyone could write a program, people were already telling stories about artificial beings that moved, guarded, served and seemed to think. That is not a curiosity of the prehistory of computing; it is the origin of the question that artificial intelligence still tries to answer. This article follows the question from the myths and automata of antiquity to the moment it became a science — Turing's reformulation in 1950, the Dartmouth conference of 1956, the perceptron and the rule-based systems of the 1960s — and to the first time the field promised more than it could deliver.^[10]

1. Mythology, automata and the origin of the question

The idea of building artificial entities capable of acting on their own is much older than digital computing. In antiquity, and especially in Greek mythology, there were already narratives about artificial beings created by humans or gods, with autonomous behaviour and the appearance of intelligence.^[8] Talos, the bronze giant said to circle the island of Crete three times a day and hurl rocks at approaching ships, is a guardian with a patrol routine and a trigger; the golden attendants that Homer places in the workshop of Hephaestus are described as having sense and voice and the ability to learn their craft. Later, engineers built the first physical versions: Hero of Alexandria described automated theatres and temple doors driven by water and weights in the first century, and eighteenth-century clockmakers produced automata that wrote sentences with a quill or played an organ.

This matters because AI is not born only as a technical problem: it is born as a persistent question about simulating human capabilities in artifacts. The myths ask what it would mean for a made thing to guard, serve or judge; the automata show how much of a behaviour can be reproduced by mechanism alone. The computer did not create the question. It gave it a new medium.

2. Why the history matters for today's AI

Understanding the origin of AI helps to interpret the ethical, economic and professional conflicts that reappear with each new technological wave. The discussion about work, machine autonomy and the limits of simulation did not begin with recent generative models; it accompanies the field since its earliest formulations. The eighteenth-century automaton that wrote letters already raised the question of what happens to the scribe; the 1960s program that held a conversation already made people confide in it more than its author expected.^[9]

That historical context avoids treating generative AI as an isolated phenomenon and shows that each advance answers old questions with new tools. It also explains a pattern that repeats: a promising idea appears early, the infrastructure of the time cannot sustain it, a more limited but viable approach takes the stage, expectations outrun results, and interest collapses until the infrastructure catches up. The first cycle of that pattern is the subject of this article.

3. Alan Turing and the central question

In 1950, Alan Turing shifts the debate to a decisive formulation: can machines think?^[1] The force of the question lies in moving the focus from mechanical automation to the simulation of cognitive processes, bringing computation and intelligence together as objects of the same problem. From then on, AI comes to be thought of less as a mechanism that executes movements and more as a system that reproduces aspects of human reasoning. Turing also knew that "think" resists definition, so he replaced the question with an experiment.

The Turing test — the imitation game of the 1950 paper — is a thought experiment that evaluates whether a machine can sustain an interaction indistinguishable from a human's. An interrogator exchanges typed messages with two hidden participants, one human and one machine, and has to tell which is which; if the interrogator fails often enough, the machine has passed. The test does not measure consciousness and does not prove intelligence in the philosophical sense; it measures the ability to imitate linguistic or conversational behaviour convincingly. Its historical importance lies in offering an operational criterion for discussing intelligence without depending on a closed definition of "thinking".

Practise: open in the Lab: Exercise 1, What the test measures

4. From mechanical simulation to cognitive simulation

The change proposed by Turing reorganises the technical objective of the field. Instead of only building machines that execute automatic actions, the focus becomes building systems that simulate cognitive processes by means of algorithms. The automaton that wrote with a quill reproduced the movement of writing; the programs that followed tried to reproduce the choice of what to write. That turn prepares the ground for the later approaches that try to represent decision, learning and adaptation, each with its own limitations.

Table 1 — Turing's reformulation moves the objective from the left column to the right one. The rest of the article is about the two ways that objective was pursued.

5. The Dartmouth conference

The Dartmouth conference of 1956 marks the consolidation of AI as an identifiable research field. There, names such as John McCarthy, Marvin Minsky and Herbert Simon help turn an intellectual provocation into a scientific agenda, with the hypothesis that aspects of human intelligence could be simulated computationally.^[2] The 1955 proposal that convened the summer workshop was written by McCarthy, Minsky, Nathaniel Rochester and Claude Shannon, and it is the document in which the term artificial intelligence was chosen. Its central conjecture is that every aspect of learning or any other feature of intelligence can, in principle, be described precisely enough for a machine to simulate it.

The event matters less for its size and more for establishing a programme of work that guided research in the following decades: language, neural networks, the theory of computation, abstraction and creativity were all on the list. Allen Newell and Herbert Simon brought the Logic Theorist, a program that proved theorems of symbolic logic, and it became the model of what a working AI system looked like: knowledge and reasoning written down explicitly.

Practise: open in the Lab: Exercise 2, The year of Dartmouth

6. Perceptrons: learning from examples

Resuming the search for machines that did not depend only on explicit rules, the perceptrons introduce the idea of learning from examples. Inspired, in a simplified way, by biological neurons — the abstraction proposed by McCulloch and Pitts in 1943^[4] — they represent one of the first attempts to build neural networks capable of adjusting their behaviour on the basis of observed data. Frank Rosenblatt's perceptron of 1958 computes a weighted sum of its inputs and fires when the sum crosses a threshold:^[3]

Equation (2) is the whole novelty. Nobody writes the weights: after each example, the difference between the expected answer t and the produced answer y nudges the weights in the direction that would have reduced the error, by a step η. Repeat over the examples and, when a straight line can separate the two classes, the procedure is guaranteed to find it. Figure 3 shows the unit and Table 2 the exact trace of the learning of the AND function, produced by the code below.

# a single perceptron learning the AND function from its four examples
EXAMPLES = [((0, 0), 0), ((0, 1), 0), ((1, 0), 0), ((1, 1), 1)]

def predict(w, b, x):
    # equation (1): weighted sum, then the threshold
    s = w[0] * x[0] + w[1] * x[1] + b
    return 1 if s > 0 else 0

def train(examples, eta=1, max_epochs=50):
    w, b = [0, 0], 0                          # nobody chooses the weights: they start at zero
    for epoch in range(1, max_epochs + 1):
        errors = 0
        for x, t in examples:
            y = predict(w, b, x)
            e = t - y                             # +1: fired too little, -1: fired too much, 0: right
            if e != 0:
                errors += 1
                w[0] += eta * e * x[0]              # equation (2): each weight moves in proportion to its input
                w[1] += eta * e * x[1]
                b += eta * e
        if errors == 0:                          # a whole pass without mistakes: converged
            return w, b, epoch
    return w, b, None

w, b, epoch = train(EXAMPLES)
print(w, b, epoch)                            # [2, 1] -2 6: correct on all four examples from epoch 6 on
print([predict(w, b, x) for x, _ in EXAMPLES])   # [0, 0, 0, 1]

Table 2 — Exact trace of the code above with η = 1. The first three examples of epoch 1 produce no error because the sum is 0 and the threshold is strict; the fourth fires the first correction. From epoch 6 the perceptron is right on all four examples: 2x₁ + x₂ − 2 > 0 only when both inputs are 1.

The first neural models ran into severe restrictions of hardware, processing capacity and data availability. Rosenblatt's Mark I perceptron was a cabinet of potentiometers adjusted by motors, learning from a 20 by 20 grid of photocells. That was not an operational detail but a structural limiter: without computational scale and without a sufficient volume of examples, learning stayed rudimentary and hard to extend. The consequence was that promising ideas appeared early but could not mature technically at that historical moment. The theoretical blow came in 1969, when Minsky and Papert proved what a single-layer perceptron cannot learn.^[5]

Practise: open in the Lab: Exercise 3, One learning step

7. Rule-based AI and decision trees

In the 1960s, rule-based AI gains strength, structured as "if… then" logic and often organised as decision trees. This approach works well when the domain can be made explicit by specialists: DENDRAL, started in 1965, inferred the structure of an organic molecule from its mass spectrum using rules written with chemists, and the systems that followed it encoded the judgement of experts in fields from geology to computer configuration.^[7] The mechanism is transparent: a chain of tests over known attributes leads to a conclusion, and every conclusion can be explained by listing the rules that fired.

# the tree of Figure 4 as code: the knowledge is in the conditions, written by a person
def decide(humidity, temperature):
    if humidity < 40:                       # rule 1: dry soil comes first
        return "water for 10 minutes"
    if temperature > 30:                    # rule 2: only checked when the soil is fine
        return "open the vent"
    return "no action"                     # everything not foreseen ends here, right or wrong

print(decide(35, 24))    # water for 10 minutes
print(decide(55, 33))    # open the vent
print(decide(60, -4))    # no action: a frost is not in the tree, so the tree does nothing

The problem is that the approach depends on manual codification of knowledge, which limits the system's adaptation to situations that were not foreseen. The last line above is the whole limitation in one example: a frost is not in the tree, so the tree does nothing, and it does so with complete confidence. Adding the case means finding a specialist, writing the rule, and checking that it does not contradict the others — for every new case, forever.

Practise: open in the Lab: Exercise 4, Why rules won the 1960s

8. Codify or learn: the conflict, and the road to the winter

The central tension of this period lies between two strategies: programming reasoning explicitly or letting the machine learn from examples. Rule-based systems were more viable with the infrastructure of the time, which is why they gained notoriety, but they carried the limit of only operating within what had been previously specified. The line of neural networks pointed to a less rigid AI, yet one still blocked by technical restrictions that would only be faced much later.

Table 3 — The two strategies as they stood at the end of the 1960s. Neither could deliver what had been promised: one because it was too rigid, the other because it was too early.

This beginning of the story produces a classic cycle of enthusiasm followed by frustration. The belief that human intelligence would be quickly simulated generated expectations larger than the technology could sustain — machine translation that would be solved in a few years, programs that would soon match a chess champion — especially when the most promising methods were still immature and the most viable methods were too rigid. In 1973 the Lighthill report, commissioned by the British research council, concluded that the field had not delivered on its central promises outside toy problems, and funding was cut in Britain and, for similar reasons, in the United States.^[6] That mismatch prepares directly the scenario of the AI winter, when the advance of the field begins to slow down.

Practise: open in the Lab: Exercise 5, Preparing the winter

9. Conclusion

The question came first and the machine came later. Myths and automata asked what it would take for a made thing to act on its own; Turing turned the question into an experiment about behaviour; Dartmouth turned the experiment into a research programme. The programme then split into two ways of answering: write the knowledge down, or let the machine learn it. The first produced the working systems of the 1960s and their rigidity; the second produced the perceptron and stalled on hardware, data and a theorem. What ended the first period was not a failure of ideas but a gap between what was promised and what could be built. Keep that gap in mind: it is the recurring shape of the field, and the reason its history is useful every time a new wave promises to close it for good.