When our ancestors moved beads up and down grooves in a surface, and later rods in a frame, little did they know that they were witnessing the earliest form of artificial intelligence. Hear me out, for these were the very beginnings of computing, and the foundation today’s vast expanse of GPUs ultimately rest upon.

The abacus does not look like much. It might just be a toy ladder for beads, the sort of thing a child might improve by adding wheels. But that unassuming device represents the first attempt to move a calculation out of our heads, which had the neat effect of making part of thought physical.

These are the humble origins of AI: not with a glowing data centre or a self-important robot, but with humanity’s long habit of pushing cognition into the world around us. We have spent thousands of years building objects that remember, calculate, symbolize, classify, and eventually decide. Artificial intelligence is not a disruption of that tendency. It is the point at which the tools we made to support thought begin to acquire some of the properties of thought themselves.

The abacus established the basic trick. Arithmetic could be made external, stable, and repeatable. A person no longer had to hold the whole operation in memory; the state of the problem could sit there in wood and bead, waiting to be inspected. It did not think, obviously. But it changed the boundary of thinking. Part of the work had moved from mind to mechanism, which had an immediately recognisable effect: one person’s calculation capacity could be effectively scaled. Until then, human tools had provided extensions and replacements for the capabilities of our muscles. This time, the tool was extending the capabilities of the brain.

Mechanical calculators took the next step by automating procedures that once required human attention. Pascal and Leibniz built machines that could perform arithmetic operations directly. Babbage imagined something more ambitious: a programmable machine, capable of following different sequences of instructions rather than being built for only one task. In one of history’s more frustrating acts of project management, the Analytical Engine was never completed. But the idea lingered: if rules could be encoded mechanically, then reasoning-like procedures could be executed outside a human mind.

The nineteenth and twentieth centuries supplied the intellectual machinery. Boolean algebra showed that logic could be treated formally. Information theory made information itself measurable. Turing’s model of computation gave us a precise account of what it means for a procedure to be mechanically executable. These were not merely mathematical curiosities; they established that reasoning could be represented as operations on symbols, and that machines could, in principle, perform those operations.

Electronic computers turned the principle into infrastructure. With transistors and integrated circuits, machines gained speed, memory, and flexibility. Programming languages gave humans a way to describe increasingly complex procedures without wiring each one into the hardware by hand. Computers became more than calculators. They became general-purpose engines for manipulating information, capable of simulating processes, representing abstractions, and supporting the first serious attempts at artificial intelligence.

Those early AI systems tried to build intelligence from rules. Expert systems captured human knowledge in explicit form. Symbolic programs solved puzzles, planned actions, and diagnosed problems within narrow domains. They were impressive in the way a very elaborate filing cabinet can be impressive: orderly, useful, and brittle the moment reality failed to respect the categories. The lesson was not that intelligence could never be mechanized. It was that intelligence could not be fully hand-written.

Learning systems changed the direction of travel. Neural networks, probabilistic models, and later deep learning architectures allowed machines to extract patterns from data instead of waiting for humans to specify every rule. These systems were still narrow, but they showed that flexible behaviour could emerge from exposure rather than instruction. The machine was no longer only executing a procedure. It was being shaped by experience, however thin and statistical that experience was.

Large-scale foundation models brought this lineage to the threshold of generality. Trained on vast corpora of text, images, and code, they developed broad competence across tasks that used to require separate systems. They can translate, summarize, generate, classify, explain, and adapt with unsettling fluency. They lack autonomy, stable memory, and durable goals, but they have already made one thing difficult to deny: general-purpose ability can emerge from scale, structure, and self-supervision.

The transition from powerful model to proto-AGI begins when those abilities stop being isolated tricks and start being organised across time. Memory, planning, self-correction, tool use, and evaluation loops make a system behave less like a calculator and more like an agent. It can integrate information, pursue goals, revise its strategy, and adapt to situations that were not explicitly anticipated by its designers. That does not make it a mind. But it does move it further along the same old line: more of the work of thought leaving us and taking up residence elsewhere.

AGI, if it arrives, will not be an inexplicable meteor. It will be the point at which these accumulated capabilities coalesce into a system able to learn continuously, form internal models of the world, generalize across domains, and modify its own cognitive processes. At that point, the machine is no longer merely executing instructions or optimizing patterns. It is thinking in a general, open-ended way.

AGI is not the opposite of human ingenuity. On the contrary, it is one of our oldest habits reaching its natural conclusion. We began by sliding beads across a frame to spare ourselves a little arithmetic. We will soon be asking the beads what they think about all this.