Chapter 2 produced a definition of autonomy that works for living systems. This chapter does something different and, for an engineer, more useful: it goes through eight different disciplines, collects what each of them means by autonomy, and only at the end picks the one that will define agents. The order is the deck’s own, and it runs from the vaguest lens to the sharpest.
Start with the etymology, which already contains the whole story. Autonomy is an early seventeenth-century word, from Greek autonomia, from autonomos, “having its own laws”, from autos (self) + nomos (law). Self-law. Not self-sufficiency, not independence: giving oneself one’s own law.
The Oxford Dictionary of English then lists four senses: the right or condition of self-government; a self-governing country or region; freedom from external control or influence, independence; and, in Kantian moral philosophy, the capacity of an agent to act in accordance with objective morality rather than under the influence of desires. The thesaurus adds the neighbourhood: self-government, independence, self-rule, home rule, sovereignty, self-determination, freedom, autarchy, self-sufficiency, individualism.
Merriam-Webster is worth reading for its antonyms as much as for its definitions. Autonomy is the quality or state of being self-governing (especially the right of self-government), self-directing freedom and especially moral independence, and a self-governing state. Its synonyms are accord, free will, choice, self-determination, volition, will. Its antonyms: dependence, heteronomy, subjection, unfreedom.
The dictionary has already handed us the pair Chapter 2 spent its length constructing: autonomy against heteronomy. Note also what the thesaurus quietly gets wrong for our purposes: it lists autarchy as a synonym, and Chapter 2 was explicit that autonomy is not autarchy. Ordinary language blurs precisely the distinction the course needs.
The Internet Encyclopedia of Philosophy distinguishes five acceptations, which are not competing definitions but different scopes of the same idea:
| Acceptation | Meaning |
|---|---|
| General | An individual’s capacity for self-determination or self-governance |
| Folk | Inchoate desire for freedom in some area of one’s life |
| Personal | The capacity to decide for oneself and pursue a course of action in one’s life |
| Moral | The capacity to deliberate and to give oneself the moral law, rather than merely heeding the injunctions of others |
| Political | The property of having one’s decisions respected, honoured and heeded within a political context |
After Kant, autonomy is an essential trait of the individual, strictly related to its morality — represented by some high-level ethical principles — and then to the relation between its inner self and its individual actions; that is, between mind and behaviour.
The philosophically most demanding notion in the deck, and the one that will echo loudest in the agent chapters. A more demanding notion of autonomy requires not only self-determination, but also independence from oneself. This conception is connected with notions of freedom and choice, and possibly non-determinism, and it requires the ability of reasoning on — and possibly changing — not just one’s own course of actions, but one’s own goals.
Keep “independence from oneself” in the same drawer as the executive vs motivational autonomy distinction of section 5. They are the same cut made twice, once by philosophy and once by social science: reasoning about how to do what you were given is a weaker thing than reasoning about what to want.
The US Unmanned Systems Integrated Roadmap FY 2011–2036 supplies the single most quotable distinction of the whole chapter, and one that any engineer can apply on the spot.
Automatic systems are fully pre-programmed and act repeatedly and independently of external influence or control. An automatic system can be described as self-steering or self-regulating and is able to follow an externally given path while compensating for small deviations caused by external disturbances. However, the automatic system is not able to define the path according to some given goal, or to choose the goal dictating its path.
Autonomous systems are self-directed toward a goal in that they do not require outside control, but rather are governed by laws and strategies that direct their behaviour. Initially, these control algorithms are created and tested by teams of human operators and software developers. However, if machine learning is utilised, autonomous systems can develop modified strategies for themselves by which they select their behaviour. An autonomous system is self-directed by choosing the behaviour it follows to reach a human-directed goal.
Read the two definitions against each other and the criterion falls out: an automatic system compensates along a path someone else drew; an autonomous system chooses the path, given a goal someone else set. Note carefully where the human remains in the autonomous case — the goal is still human-directed. Autonomy here is autonomy of means, which is precisely what section 5 will call executive autonomy.
The roadmap then grades the human–machine relation. Various levels of autonomy in any system guide how much and how often humans need to interact or intervene with the autonomous system:
| Level | Name | Description |
|---|---|---|
| 1 | Human Operated | A human operator makes all decisions. The system has no autonomous control of its environment, although it may have information-only responses to sensed data. |
| 2 | Human Delegated | The vehicle can perform many functions independently of human control when delegated to do so. This level encompasses automatic controls, engine controls and other low-level automation that must be activated or deactivated by human input and must act in mutual exclusion of human operation. |
| 3 | Human Supervised | The system can perform a wide variety of activities when given top-level permissions or direction by a human. Both the human and the system can initiate behaviours based on sensed data, but the system can do so only if within the scope of its currently directed tasks. |
| 4 | Fully Autonomous | The system receives goals from humans and translates them into tasks to be performed without human interaction. A human could still enter the loop in an emergency or change the goals, although in practice there may be significant time delays before human intervention occurs. |
The roadmap closes with the reason all this matters operationally: the special feature of an autonomous system is its ability to be goal-directed in unpredictable situations. This is a significant improvement in capability compared with automatic systems: an autonomous system is able to make a decision based on a set of rules and/or limitations, is able to determine what information is important in making a decision, and is capable of a higher level of performance compared with a system operating in a predetermined manner.
Automatic vs autonomous is the distinction most likely to be asked in an offhand way and most easily fumbled. The one-line answer: an automatic system follows an externally given path and compensates for disturbances but cannot define the path from a goal; an autonomous system is self-directed towards a goal, choosing the behaviour that reaches it. The discriminating capability is goal-directedness in unpredictable situations.
Autonomous cars come with a lot of hype — “this is probably the biggest thing to hit the auto industry since the first car came off the assembly line” — and with the sober prediction that it will probably take more time than the hopeful expect and less time than the sceptical think. Most technologies will be implemented gradually, leading to a slowly yet steadily growing level of autonomy: from automatic to autonomous, one step at a time.
The relevant document is an international standard, SAE J3016 [SAE International, 2021], which provides a taxonomy describing the full range of levels of driving automation in on-road motor vehicles, including functional definitions for the advanced levels. Its six levels:
| Level | Name | Content |
|---|---|---|
| 0 | No automation | Every aspect of driving is in the hands of the human driver |
| 1 | Driver assistance | The car assists the human driver in some tasks — cruise control, lane-keeping |
| 2 | Partial automation | Advanced driver assistance system (ADAS): some automated functions work together to transfer some control from the human driver — who remains in charge of the monitoring — to the car; e.g. Tesla Autopilot |
| 3 | Conditional automation | Automated driving systems (ADS): under some circumstances the car can perform all aspects of the driving task; e.g. Audi AI traffic jam pilot |
| 4 | High automation | Under certain conditions the car can perform all driving functions, with no need for a human driver; e.g. Google self-driving car |
| 5 | Full automation | Under any condition the car can perform all driving tasks; humans are just passengers |
The standard also fixes a vocabulary worth knowing, since it shows how precisely the scope of autonomy has to be pinned down before the word means anything: ADS automated driving system, DDT dynamic driving task, ODD operational design domain, OEDR object and event detection and response.
Level numbers are seductive and treacherous. The military scale grades how often a human must intervene; the SAE scale grades how much of one fixed task the machine covers, and under which conditions. Neither grades what Chapter 2 called constitutive autonomy, and neither says anything about whether the system has its own goals. A system can sit at SAE level 5 and still be, in Castelfranchi’s terms of the next section, merely executively autonomous.
Castelfranchi supplies the lens that will matter most for multi-agent systems, and it starts by relocating the whole notion [Castelfranchi, 1995].
Autonomy is a relational concept. An agent is autonomous mostly in relation to other agents: autonomy has no meaning for an agent in isolation. This single sentence does a lot of work later — it is why Chapter 4 can say that multi-agent systems are the only legitimate containers of autonomous agents, and why a sequential program is not an agent.
As for autonomy from the environment, the deck calls it the Descartes problem: behaviour (human or agent) is affected by the environment, but is not depending on the environment. Hence the corollary that saves agent theory from a cheap objection: situatedness, reactiveness and adaptiveness do not imply lack of autonomy.
Agents are teleonomic, goal-driven entities — entities whose behaviour is not casual under any acceptation of the term. And agents in a society can be conceived as either goal-governed or goal-oriented [Conte and Castelfranchi, 1995]:
| Kind | Notion of agency | Goals |
|---|---|---|
| Goal-governed | Strong notion of agency: agents with some form of cognitive capability | Goals are explicitly represented, and drive the selection of agent actions |
| Goal-oriented | Weak notion of agency | Behaviour is directly designed and programmed to achieve some goal, which is not explicitly represented |
And the clause that must not be dropped: in both cases, agent goals are internal. The difference is representation, not ownership.
Now the distinction that this chapter exists for:
From which: autonomy requires autonomous goals, and executive autonomy is not enough for real autonomy. A goal-autonomous agent is an agent endowed with its own goals.
Given a goal, the agent is autonomous in achieving it by itself. This is the autonomy the military roadmap describes: the system is self-directed by choosing the behaviour it follows to reach a human-directed goal. The deck is blunt about its limits: executive autonomy is not enough for real autonomy.
The agent’s goals are somehow self-generated, not externally imposed. This is where the philosophical notion of “independence from oneself” reappears: the ability to reason about, and possibly change, not merely one’s course of action but one’s goals. Autonomy requires autonomous goals.
A goal-autonomous agent is an agent endowed with its own goals. The definition is deliberately minimal — it says nothing about how sophisticated the reasoning is, only about whose goals are being pursued.
An agent is fully socially autonomous if: it has its own goals, endogenous and not derived from other agents’ will; it is able to make decisions concerning multiple conflicting goals, whether its own or adopted from outside; it adopts goals from outside, from other agents, and is liable to influencing; it adopts other agents’ goals as a consequence of a choice among them and other goals; and it adopts other agents’ goals only if it sees the adoption as a way of enabling itself to achieve some of its own goals — that is, the autonomous agent is a self-interested agent.
The last part of the full-social-autonomy definition is the sharpest, and it is the one to quote when someone asks how an autonomous agent can be influenced at all. It is not possible to directly modify the agent’s goals from outside: any modification of its goals must be achieved by modifying its beliefs. Thus the control over beliefs becomes a filter, an additional control over the adoption of goals.
And one level up again: it is impossible to change automatically the beliefs of an agent. The adoption of a belief is a special “decision” that the agent takes on the basis of many criteria. This protects its cognitive autonomy.
Two nested filters, and they explain the entire shape of agent communication. You cannot set another agent’s goal, so you must go through its beliefs; you cannot set its beliefs either, so you can only tell it something and let it decide. This is why Chapter 12 will find that agent platforms send messages with a performative rather than calling methods: the message format is the direct consequence of the fact that neither goals nor beliefs can be written from outside.
Odell’s reading of the history of programming languages [Odell, 2002] is the moment where the chapter stops surveying and starts arguing. The historical evolution — monolithic programming, modular programming, object-oriented programming, agent programming — is read along a single dimension: the degree of modularity and encapsulation applied to three things, namely unit behaviour, unit state and unit invocation.
| Era | Basic unit | What is encapsulated | What is not |
|---|---|---|---|
| Monolithic | The whole program | Nothing reusable: behaviour cannot be invoked as a reusable unit under different circumstances | Behaviour; state is the programmer’s responsibility; invocation is determined by the system’s operator |
| Modular | Structured loops, subroutines, procedures | Behaviour: small units of code can be reused in a variety of situations | State, determined by externally supplied parameters; invocation, determined by CALL statements |
| Object-oriented | Objects and classes | Behaviour and state: objects have local control over the variables manipulated by their own methods, and the state persists across invocations | Invocation: objects are passive, methods are invoked by external entities, so the object’s control is not encapsulated |
| Agent-oriented | Agents | Everything, in principle: agents have control over their own state, they are active, they cannot be invoked by external calls, so the agent’s control is encapsulated | — |
The deck is careful about what it is claiming for agents at this point: whatever an agent is, we do not need to define them now, just to understand their desired features — obtained by simply following the pattern of the evolution. Agents could in principle be reused in a variety of situations; they have control over their own state; they are active; they cannot be invoked by external calls; their control is encapsulated. Therefore: agents are autonomous entities.
Here the survey ends and the course commits. The commitment is made under an explicit methodological principle, lex parsimoniae: take autonomy as the only fundamental and defining feature of agents, and then check whether the other typical agent features follow from it. The rest of the section is that check, and it succeeds.
The definition, which you should be able to recite:
Agents are autonomous as they encapsulate (the thread of) control. Control does not pass through agent boundaries: only data (knowledge, information) crosses agent boundaries. Agents have no interface, cannot be controlled, nor can they be invoked. Looking at agents, multi-agent systems (MAS) can be conceived as an aggregation of multiple distinct loci of control interacting with each other by exchanging information.
Now the derivations, each of which the deck presents as a consequence rather than an extra axiom.
Agents act, and pro-act. The etymology of the word agent is the Latin agens, so agent means “the one who acts”; any coherent notion of agency should therefore come equipped with a model for agent actions. And since autonomous agents encapsulate control and the rule to govern it, they are pro-active by definition — where pro-activity means making something happen rather than waiting for something to happen.
Agents change the world. Any model for action brings along the notion of change: an agent acts to change something. There are exactly two admissible targets:
| Target | Kind of action | Why |
|---|---|---|
| Another agent | Communication actions | Agents are autonomous, so the only way to change their state is by feeding them new information |
| The environment | Pragmatic actions | Either physical or virtual, depending on the nature of the agent and of the environment |
Agents are social. The notion of autonomy does not make sense for an individual in isolation. This also straightforwardly explains why any program in any sequential programming language is not an autonomous agent per se [Graesser, 1996; Odell, 2002]. Autonomous agents live and interact within agent societies and MAS — roughly speaking, MAS are the only legitimate containers of autonomous agents.
A subtle and easily-missed point. Along with control, agents should also encapsulate the criterion for regulating their own thread of control, so as to make computation effective. Which sort of criterion? A goal, as a state of the world to achieve? A task, as an activity to bring about? A finite-state machine, as a precise definition of an interactive computation to perform? The deck’s answer is honest and important: all of them work fine, as far as computational autonomy is concerned. So when in the end we pick up goals, it does not come from the requirements for computational agents — it comes from elsewhere, namely from the intentional stance of Chapter 7.
Three things from this section, in order of likelihood of being asked. (1) The genus/differentia definition: agents are computational entities (genus) that are autonomous, in that they encapsulate control along with a criterion to govern it (differentia). (2) Why an object is not an agent: the object encapsulates state but not control, and it is invoked. (3) Why goals are not forced on us by computational autonomy: a task or a finite-state machine would serve equally well as the governing criterion.
The last lens is the newest, and the deck takes it from Gullí’s Agentic Design Patterns [Gullí, 2025]. Its definition of an AI agent:
“In simple terms, an AI agent is a system designed to perceive its environment and take actions to achieve a specific goal. It is an evolution from a standard large language model (LLM), enhanced with the abilities to plan, use tools, and interact with its surroundings.”
And its five-step loop, described as a smart assistant that learns on the job:
Gullí also charts how the field arrived here: “In just 2 years, the AI paradigm has shifted dramatically, moving from simple automation to sophisticated, autonomous systems”. (1) Initially, workflows relied on basic prompts and triggers to process data with LLMs. (2) This evolved with retrieval-augmented generation (RAG), which enhanced reliability by grounding models on factual information. (3) Then came individual AI agents capable of using various tools. (4) Today we are entering the era of agentic AI, where a team of specialised agents works in concert to achieve complex goals.
The deck then draws the two definitions it actually wants. An AI agent has a goal to achieve, deliberates its own course of action, autonomously executes, observes the outcome and adapts, and interacts with other agents within a multi-agent system. An agentic MAS has a complex goal to achieve — based on the individual agent goals, through individual agent action and social agent interaction — and is an autonomous system built out of autonomous components.
“An autonomous system built out of autonomous components” is the phrase that makes agentic AI a legitimate object for this course rather than a marketing term. It restates, at the system level, exactly the part–whole interdependence that point 4 of the biological definition demanded in Chapter 2.
The deck closes with a table that is effectively the chapter’s abstract, and is worth having memorised as a checklist of what “autonomy” can mean when someone else says it.
| Lens | What autonomy means there |
|---|---|
| Dictionaries | Autonomy as independence with respect to something |
| Philosophy | Individual autonomy as a moral trait — up to independence from oneself |
| Military | Different levels of autonomy, with respect to human intervention and delegation to the system |
| Automotive | Industry-standard levels of autonomy around the driving task |
| Social sciences | Autonomy as a relational concept, with respect to both society and environment; the agent goal is internal, with explicit or non-explicit representation; executive vs motivational autonomy |
| Programming languages | Computational autonomy |
| Software engineering | Autonomy defines agents |
| Agentic AI | Agentic AI systems as autonomous MAS with a complex goal, whose components are autonomous AI agents |
Notice the shape of the argument across the eight rows. The first four lenses grade autonomy from the outside — how much freedom is granted, how often a human intervenes. The last four define it from the inside — whose goals, whose control, whose criterion. The course adopts an inside definition, and that choice is what allows the rest of Module 1 to be an engineering discipline rather than a governance discussion.
From Greek autonomia, from autonomos “having its own laws”, from autos (self) + nomos (law). The etymology says self-law, not self-sufficiency: the core is giving oneself one’s own rule, which is exactly the biological point of Chapter 2 (specifying their own rules of behaviour) and the computational point of section 7 (encapsulating control along with the criterion governing it).
Automatic: fully pre-programmed, acting repeatedly and independently of external influence; self-steering or self-regulating, able to follow an externally given path while compensating for small deviations; not able to define the path according to a given goal, nor to choose the goal. Autonomous: self-directed toward a goal, not requiring outside control, governed by laws and strategies that direct behaviour; self-directed by choosing the behaviour it follows to reach a human-directed goal; with machine learning it can even develop modified strategies for itself. The discriminating capability is goal-directedness in unpredictable situations.
Human Operated (a human makes all decisions; the system may have information-only responses to sensed data); Human Delegated (the vehicle performs many functions independently when delegated, acting in mutual exclusion of human operation); Human Supervised (a wide variety of activities given top-level permissions; both human and system can initiate behaviours, the system only within its currently directed tasks); Fully Autonomous (the system receives goals and translates them into tasks without human interaction, though a human could enter in an emergency or change the goals).
0 no automation; 1 driver assistance (cruise control, lane-keeping); 2 partial automation, ADAS, with the human still monitoring; 3 conditional automation, ADS, all aspects under some circumstances; 4 high automation, all driving functions under certain conditions with no need for a human driver; 5 full automation, all driving tasks under any condition, humans as passengers.
Because the two scales measure different things. The military scale grades how much and how often humans need to interact or intervene; the SAE scale grades how much of the driving task the system covers, and under which conditions, within a specified operational design domain. Neither of them, incidentally, addresses whose goals are being pursued — which is the distinction the social-science lens introduces.
An agent is autonomous mostly in relation to other agents: autonomy has no meaning for an agent in isolation [Castelfranchi, 1995]. As for the environment, the “Descartes problem” states that behaviour is affected by the environment but does not depend on it — hence situatedness, reactiveness and adaptiveness do not imply lack of autonomy. The relational reading is also why MAS are said to be the only legitimate containers of autonomous agents.
Goal-governed entities refer to the strong notion of agency: agents with cognitive capabilities that make it possible to represent their goals explicitly, driving the selection of actions. Goal-oriented entities refer to the weak notion: agents whose behaviour is directly designed and programmed to achieve some goal which is not explicitly represented. What stays the same, and must not be dropped: in both cases agent goals are internal.
Executive: given a goal, the agent is autonomous in achieving it by itself. Motivational: the agent’s goals are somehow self-generated, not externally imposed. It matters because the deck concludes that autonomy requires autonomous goals and that executive autonomy is not enough for real autonomy. Most industrial “autonomous systems”, including the fully-autonomous military level and the agentic-AI five-step loop, deliver executive autonomy only.
It has its own endogenous goals, not derived from other agents’ will; it can decide among multiple conflicting goals, its own or adopted; it does adopt goals from outside and is liable to influencing; it adopts them as a consequence of a choice among them and its other goals; and it adopts them only if it sees the adoption as a way of enabling itself to achieve some of its own goals — that is, it is a self-interested agent.
First filter: it is not possible to directly modify the agent’s goals from outside; any modification of goals must be achieved by modifying its beliefs, so control over beliefs becomes a filter over the adoption of goals. Second filter: it is impossible to change automatically the beliefs of an agent, because adopting a belief is a special decision the agent takes on the basis of many criteria — which protects its cognitive autonomy.
Agents are autonomous as they encapsulate the thread of control: control does not pass through agent boundaries, only data (knowledge, information) does. Agents have no interface, cannot be controlled and cannot be invoked. A MAS is consequently an aggregation of multiple distinct loci of control interacting by exchanging information.
Because the evolution of programming languages is graded by what gets encapsulated: monolithic programs encapsulate nothing reusable, modular programming encapsulates behaviour, object orientation adds state (local control over variables, persistent across invocations) — but objects are passive: methods are invoked by external entities, so modularity does not apply to unit invocation and the object’s control is not encapsulated. Agents close that gap: they are active, cannot be invoked by external calls, and their control is encapsulated.
Because there are exactly two admissible targets for change. Acting on another agent can only be done by feeding it new information, since agents are autonomous — hence communication actions. Acting on the environment changes its state directly — hence pragmatic actions, either physical or virtual depending on the nature of the agent and the environment.
No, and the deck is explicit about it. Agents must encapsulate control together with a criterion for regulating it, but that criterion could be a goal (a state of the world to achieve), a task (an activity to bring about), or a finite-state machine (a precise definition of an interactive computation). All of them work fine as far as computational autonomy is concerned; the eventual choice of goals does not come from the requirements for computational agents.