Autonomous systems are a type of system that can operate and make decisions independently without direct human intervention. They are designed to perform tasks or execute processes without constant external control, relying on their ability to sense, analyze, and respond to their environment autonomously.
Four key characteristics recur across the family (the first three form a sensing–decision–acting loop):
Examples of autonomous systems span transportation, robotics, software and networking:
The development and deployment of autonomous systems raise various technological, ethical, and regulatory challenges — including issues related to safety, accountability, and the impact on employment. These are important research lines with many open research issues, both from a scientific and an engineering point of view.
The rest of this part of the course concentrates on agents and multi-agent systems (MAS) as the architectural paradigm for autonomous software systems. The module situates them historically:
The literature on agents is large and spans many viewpoints; this module navigates it through the lens of architectures for autonomous systems, keeping the AI, AOSE and programming perspectives connected.
Three research/programming communities revolve around the same core abstraction, at different levels:
Chapter 12 introduces the agent abstraction and its environment; Chapter 13 walks through agent programs and architectures from simple reflex to learning and LLM agents; Chapter 14 climbs to the knowledge level, cognitive architectures, and the BDI model; Chapter 15 lands on agent programming — AgentSpeak/Jason, the A&A environment meta-model, organisations, and JaCaMo — closing with the cognitive-era and DDD connections.
The canonical definitions, from Wooldridge & Jennings and Russell & Norvig:
Autonomy is the key concept: an entity to which we can delegate goals in some high-level way, and which decides for itself how best to accomplish them. It is a broad spectrum, with different degrees and characterisations depending on the context.
Intelligent agents [Wooldridge and Jennings 1995] add three capabilities to plain autonomy:
An agent must respond to its environment and pursue its own goals. Chapter 13 shows how the different agent architectures weigh these two demands, and Chapter 14 how the BDI model reconciles them through plans and intentions — the same tension that Chapter 11’s reactive architecture addressed at the level of modules.
Key features of the agent abstraction:
The agent-environment interface has two halves [Wooldridge 2009]:
Environments are classified along four orthogonal dimensions:
Moving from a single agent to many, what comes into evidence is locality: each agent has its own sphere of visibility (what it can perceive) and sphere of influence (what it can affect). When these spheres overlap, the agents interact — interaction is the defining phenomenon of a multi-agent system [Jennings 2001].
Agentic AI is about agent systems based on generative AI techniques, especially LLMs:
The autonomy property as defined in Agentic AI: performing tasks without constant human oversight, maintaining long-term goals, managing multistep problem-solving tasks, and tracking progress over time.
The module explicitly roots AI agents in the long tradition of agents and MAS: the same autonomy, goals, environment and perception vocabulary returns in Chapters 13–15, where “AI agents” appear as the newest kind of agent program, and where emerging standards (MCP, A2A) are compared with the artifacts and agent communication languages of the MAS literature.
Conceptually, an agent’s behaviour can be described by the agent function, which maps any given percept sequence to an action [RN]:
At the abstract/conceptual level: agent = architecture + program. The agent program implements the agent function (the mapping from percepts to actions); the agent architecture is the computational machine/device enabling sensing and actuation, executing the agent program according to some execution cycle and control architecture.
see maps the environment to percepts, next updates the internal state from percepts, and action selects an action from the internal state.In AI, a rational agent is one that “does the right thing”. To make that precise we need a performance measure: when an agent is plunked down in an environment, it generates a sequence of actions according to the percepts it receives; this sequence causes the environment to go through a sequence of states. If the sequence is desirable, the agent has performed well — the notion of desirability is captured by a performance measure that evaluates any given sequence of environment states.
What is rational at any given time depends on four things:
Definition: for each possible percept sequence, a rational agent should select an action that is expected to maximize its performance measure, given the evidence provided by the percept sequence and whatever built-in knowledge the agent has.
When dealing with real-world domains, agents typically have bounded time and bounded resources to make decisions and take action [Bratman, 1988]. The ideal rational agent is computationally infeasible; architectures approximate rationality under resource constraints — this is exactly the problem that the BDI model of Chapter 14 attacks with plans and intentions.
The basic kinds of agent programs that embody the principles underlying almost all intelligent systems from an AI perspective:
Chapter 13 develops this ladder in full, from the subsumption architecture to reinforcement-learning agents and LLM-based “language agents”.
Autonomous systems are systems that can operate and make decisions independently without direct human intervention, designed to perform tasks without constant external control, relying on their ability to sense, analyze and respond to their environment. Key characteristics: sensing and perception (gathering information), decision-making (analyzing information and choosing actions, often via ML/AI), actuation (taking physical or digital actions), and adaptability (adjusting behaviour to changing conditions).
Examples: autonomous vehicles (self-driving cars, drones, UAVs), robotic systems (vacuum cleaners, warehouse robots), autonomous agents and multi-agent systems (chatbots, virtual assistants, decision-making systems), autonomous networks (self-managing, self-optimizing). Challenges: technological, ethical and regulatory issues — safety, accountability, impact on employment; many open research issues from a scientific and engineering point of view.
Wooldridge (2009) / Wooldridge & Jennings (1995): “an agent is a computer system that is situated in some environment and that is capable of autonomous action in this environment in order to meet its design objective”. Russell & Norvig: “an agent is anything that can be viewed as perceiving its environment through sensors and acting upon the environment through effectors”. Autonomy is key because it means we can delegate goals to the entity and it decides for itself how best to accomplish them; autonomy is a broad spectrum with different degrees and characterisations.
Reactivity: perceive the environment and respond in a timely fashion to changes, to satisfy design objectives. Pro-activeness: exhibit goal-directed behaviour by taking the initiative; goals are states of affairs of the environment to bring about. Social ability: interact with other agents to satisfy design objectives, including mediated interaction.
The interface: actions are the means to affect (change or inspect) the environment via effectors/actuators; perception is the internal process of attaining awareness of sensory information, creating percepts (perceived form of external stimuli or their absence). Classification axes: accessible vs inaccessible (complete state available or not), deterministic vs nondeterministic (state change uniquely determined or not), static vs dynamic (can the environment change while the agent deliberates), discrete vs continuous (limited number of percepts/actions or not).
Each agent has its own sphere of visibility (what it perceives) and sphere of influence (what it can affect) — locality. When these spheres overlap, agents interact [Jennings 2001]; interaction is the defining phenomenon that turns a collection of agents into a multi-agent system.
Agentic AI is about agent systems based on generative AI, especially LLMs: AI systems that can accomplish a specific goal with limited supervision, using LLMs to function in dynamic environments; agentic AI systems are workflows coordinating multiple AI agents to achieve broader objectives. Autonomy here means: performing tasks without constant human oversight, maintaining long-term goals, managing multistep problem-solving tasks and tracking progress over time.
The agent function maps any percept sequence to an action — an external, abstract mathematical description of the agent. The agent program is the concrete implementation of that function, running within some physical system. The agent architecture is the computational machine/device enabling sensing and actuation and executing the agent program according to some execution cycle and control architecture; abstractly, agent = architecture + program, with functions see: E → Per, next: I × Per → I, and action: I → Ac.
A rational agent is one that “does the right thing”: for each possible percept sequence, it selects an action expected to maximize its performance measure given the evidence of the percept sequence and its built-in knowledge. Rationality depends on: (1) the performance measure defining success, (2) the agent’s prior knowledge of the environment, (3) the actions the agent can perform, (4) the percept sequence to date. The main challenge is bounded resources (time, memory) [Bratman 1988].
Simple reflex agents (current percept, no state), model-based reflex agents (internal state updated via world model and sensor model), goal-based agents (explicit goal; search and planning), utility-based agents (utility function for decision making under uncertainty), and learning agents (improving from experience).