There is a tempting story to tell about the history of intelligent machines. It begins with clockwork figures, moves through mechanical calculators and early computers, arrives at artificial intelligence, and ends—at least for now—with autonomous software agents. It is tempting because it looks like a straight line, but it isn’t. The engineers who built mechanical automata centuries ago were not secretly building artificial intelligence. A clockwork writer did not understand the words it produced, and a mechanical figure playing an instrument did not know it was making music. Yet automata and today's autonomous systems share something much more compelling: they belong to a long human effort to answer the same fundamental question—how do we make a machine behave?
The answers have evolved enormously. First came gears, cams, and levers; then punched cards, relays, and electronic circuits; then software. Today, we are beginning to give machines something earlier automata could never possess: the ability to examine a situation, choose between possible actions, and determine what to do next. That shift takes us directly from the world of the automaton towards the world of the autonomous.
The Age of the Automaton
Long before electronic computers existed, craftspeople built machines that appeared to move by themselves. Some were practical, while others were built purely for entertainment. The most elaborate could write, draw, play musical instruments, or imitate human movement by combining clockmaking, mechanical engineering, sculpture, and extraordinary precision. To an audience unfamiliar with the hidden mechanism inside, the result appeared almost alive. Beneath the performance, however, lay pure determinism. The machine followed a path its maker had designed: a cam turned, a follower moved, a lever transferred that movement, an arm lifted, and a pen touched paper. The apparent behaviour emerged entirely from the physical arrangement of its components. However elaborate the performance became, the machine remained bound to those instructions. It could perform, but it could not decide.
This reveals one of the most interesting connections between historical automata and modern software: behaviour encoded directly into a machine. In something such as Henri Maillardet's writing automaton, the information required to reproduce drawings and poetry is represented physically in the contours of large brass cams, translated through mechanical linkages into the movements of the writing hand. The machine contained both a mechanism capable of movement and a representation of the behaviour it should perform. Modern computers separate those ideas dramatically. Hardware provides the general-purpose machine, while software provides the instructions. Instead of altering the physical geometry of a cam to change behaviour, we alter information stored electronically. A mechanical automaton could perform only a few carefully designed routines; a programmable computer can perform an unlimited number of different routines without changing the machine itself. Behaviour escaped the mechanism and became software.
From Mechanism to Program
The development of programmable machines fundamentally changed the relationship between people and technology. Instead of asking how to build a physical mechanism that performs a task, engineers could increasingly ask how to describe that task as a set of instructions. Once behaviour is represented as information, it can be copied, modified, stored, and transmitted independently of the physical machine executing it. The same computer can serve as a calculator, a word processor, a communications node, or an environment for software development. Nothing comparable was possible for the classical automaton.
Yet traditional software retained one crucial characteristic of its mechanical ancestors: it still strictly followed instructions. A conventional program may contain millions of lines of code and an enormous number of potential paths, but ultimately those paths were deliberately constructed by developers. If a specific condition occurs, do that; if another is true, do something else; repeat, wait, or stop. The physical mechanism had disappeared, but deterministic, rule-based execution remained at the centre.
Automation Gets Bigger
Once software could control hardware and business processes, automation expanded dramatically. Factories adopted industrial robotics, businesses automated workflows, systems exchanged data without human intervention, and APIs allowed one platform to instruct another. The word automation came to describe a vast range of technologies, but most still depended on a simple relationship: humans define the process, and machines execute it. Consider a traditional business workflow: a customer submits information, the system validates it, a database lookup occurs, a decision table is checked, a document is generated, and an email is sent. The process might be sophisticated, but the route through it is designed entirely in advance. The software isn't deciding how to solve the problem; it is merely executing the process it was given. In that sense, the cams had simply become code.
Some problems, however, do not fit comfortably into explicit rules. Recognising an object in an image is difficult to express as a decision tree, and understanding natural language is even harder. Traditional software engineering approaches these challenges by trying to write exhaustive rules, but machine learning takes a different route. Instead of explicitly defining every decision, systems are trained using data, allowing the resulting model to identify patterns and produce outputs that were never individually programmed by a developer. While a language or classification model can generate text or categorise data, producing an answer is not the same as being autonomous. Something far more interesting happens when we allow those models to interact with the world around them.
The Arrival of the Agent
The current surge in AI agents comes from combining language models with functional tools—giving a model the ability to search for information, query a database, call an API, read a document, or execute code. The model can then use those capabilities while working towards a broader goal, creating a very different relationship between instructions and execution. Where traditional software requires explicit step-by-step instructions (call API A, extract field B, pass it to system C), an agent can be given a higher-level objective: "Find the information required to answer this question." The agent determines which tools are useful and in what order they should be called.
An automaton receives explicit behaviour; an agent can receive an objective. With conventional automation, developers specify the path, but with an autonomous agent, developers specify the boundaries, capabilities, and desired outcome, leaving the system to determine part of the path itself. That does not mean the machine possesses unlimited freedom. On the contrary, useful autonomous systems require strict constraints, permission structures, reliable tools, and oversight. Autonomy is not the absence of engineering; it requires a different kind of engineering. Instead of defining every step, we design the environment within which actions are chosen.
Bounded Intelligence
A language model on its own exists largely inside a conversation. Give it tools, and the situation changes. If an AI system is tasked with helping answer an insurance policy query, a standalone model can only explain terminology or general guidance. Connected to an authorised policy system, database, and workflow tool, it can retrieve real documents, verify details, and prepare a response. The intelligence of the model matters, but the software architecture around it matters just as much. Questions about access permissions, tool reliability, error handling, and human confirmation are software engineering challenges as much as AI ones.
The word autonomous can create the wrong impression, suggesting a machine operating entirely independently. In practice, useful autonomy is strictly bounded—whether it is a warehouse robot operating within physical safety constraints or a software agent constrained by user permissions. Too little freedom creates another rigid automation workflow; too much creates unpredictable, untrustworthy systems. The real engineering challenge lies between those extremes: building systems capable of making adaptive, useful decisions while remaining securely inside boundaries that humans control.
From Deterministic to Adaptive
Every major wave of automation produces predictions that people will be removed from the process entirely, but history is rarely that tidy. Machines tend to change what people do rather than eliminate human involvement. Mechanical automation reduced manual labour while creating engineering disciplines; computers automated calculation while giving rise to the software industry. AI agents will likely follow a similar pattern. Some tasks will disappear, others will speed up, and new roles will emerge. The developer's role is shifting from writing every procedural step toward designing the tools, constraints, integrations, and environments in which intelligent systems operate.
The difference between the automaton and the autonomous machine can be reduced to a single concept: an automaton performs the exact behaviour we put into it, whereas an autonomous system possesses the ability to determine behaviour from the situation it encounters. Stand an 18th-century writing automaton beside a modern AI agent and technologically they have almost nothing in common. One is brass and steel; the other is software running on distributed cloud infrastructure. One follows a mechanical sequence; the other interprets language, calls tools, and adapts its next action based on context.
Yet the underlying ambition is identical. Both exist because someone asked a machine to perform a task that previously required a person, forcing us to confront the exact same questions: What behaviour should we give machines? How much control should they have? How do we ensure they do what we intended, and which decisions must remain ours? The history of machines is not a straight line to AI, but a messy, fascinating evolution of how we represent behaviour—from mechanical geometry and punched cards to software, data, models, and agents. The automaton performed the instructions built into it. The autonomous machine begins to decide what instruction comes next. That small difference changes almost everything.