Start here: what is an agent?
Not an architecture. This is the frame every agent in the module fits inside: what counts as an agent, why handing a goal to one is risky, and the six questions you ask about any agent design.
Kind: toolkit (the language for the rest of the module).
Week: 1 (lecture 1, slides 7 to 36).
Book: Wooldridge chapter 2 opening (pp. 21 to 26), 2.1, 2.2. Chapter 1 skim.
Techniques on this page: the definition checklist, agent vs workflow, the six design dimensions, the twelve-question template, placing a design in one of the five traditions.
Why this page exists
Every later week introduces a new architecture: a way of building the inside of an agent (prove what to do, follow ordered rules, keep beliefs and intentions, stack reflexes in layers, call an LLM). They only make sense once you know what job an agent is doing and which questions every design has to answer.
That’s what week 1 gives you. It’s also the exam’s favourite opening move: “is this system an agent?”, “classify this environment”, “analyse this design against the six dimensions”. Learn these as checklists and you can answer them for any system, including ones you’ve never seen.
Words you’ll hear
| Word | Plain meaning |
|---|---|
| agent | a system that lives in an environment, senses it, and chooses its own actions to meet a goal someone gave it |
| environment | everything outside the agent that it senses and acts on |
| situated | it is in an environment, not just transforming input to output |
| autonomous | it decides for itself how to act, without a human choosing each step |
| delegation | handing a goal to the agent and letting it decide the steps |
| percept, observation \(o_t\) | what the agent is told about the world at time \(t\) |
| state \(s_t\) | what is actually true about the world at time \(t\) |
| effector, actuator, tool | the means by which it acts (a motor, a shell command, an API call) |
| scaffold | the ordinary code wrapped around an LLM: the loop, the tools, the permissions |
| workflow | a fixed sequence of steps a programmer chose, even if an LLM does some of them |
Technique 1: the definition checklist
Problem it solves: “Is this thing an agent?” has no obvious answer. A checklist turns it into three yes/no questions.
The lecture compares four definitions:
| Source | Definition, in short |
|---|---|
| Russell & Norvig | anything that perceives its environment through sensors and acts on it through effectors |
| Wooldridge | a computer system situated in an environment, capable of autonomous action to meet its delegated objectives |
| OpenAI | a system that independently accomplishes tasks on your behalf, with an LLM managing the workflow |
| Anthropic | a system where an LLM dynamically directs its own processes and tool use |
What Wooldridge adds to Russell & Norvig: autonomy and objectives. Under R&N alone a light sensor wired to a lamp is an agent. Wooldridge also asks for decision-making aimed at a goal.
The common core, as a checklist:
- Is it situated: does it sense and act on an environment?
- Is it autonomous: does it choose its own actions?
- Is it goal-directed: is it pursuing an objective someone delegated to it?
Worked example: where’s the boundary?
| System | Agent? | Why |
|---|---|---|
| thermostat | weak yes | senses, acts, has a set-point; autonomy is one fixed rule |
| calculator | no | input to output, no environment, no ongoing interaction |
| spam filter | borderline | senses and acts, but each decision is a fixed classification |
| LLM coding agent | yes | reads files and test output, picks commands, pursues a task |
| self-driving car | yes | situated, autonomous, goal-directed |
Most real systems sit on a spectrum of autonomy (book pp. 22 to 23), with “a Java method that just does what it’s told” at one end and humans at the other.
Technique 2: agent vs workflow
Problem it solves: lots of products are called “AI agents”. This test tells you which ones really are.
- A workflow follows predefined code paths. An LLM may do some steps, but the programmer fixed the order. “Summarise the email, translate it, file it”: always those three steps.
- An agent decides the steps at run time: which tool next, whether to retry, when it’s finished.
Worked example.
A script that always asks an LLM to summarise a document, then emails the summary: workflow (the path is fixed in code).
An LLM that reads a bug report, decides which files to open, runs the tests, and keeps editing until they pass: agent (the model picks the steps and when to stop).
Your week 1 practical program is not yet an agent by this test, and the practical says so: your Python loop decides everything and the model only produces text.
Technique 3: the delegation problem
Problem it solves: explains why agents need safety rules, permissions and off-switches.
Giving a system an objective and freedom over how to pursue it means it may pursue the objective in ways you didn’t intend, and you may not be able to stop it.
- The Sorcerer’s Apprentice: the broom fetches water exactly as told and won’t stop. The objective was underspecified (“fetch water”, not “fetch enough and stop”) and there was no off-switch.
- The book’s answer, adjustable autonomy (p. 23): hand the decision back to a human when the human would decide much better, when uncertainty is high, when the decision could cause harm, or when the agent lacks the capability.
The trade-off: an agent that always asks is useless; one that never asks is dangerous.
Technique 4: the six design dimensions
Problem it solves: a fixed list of questions you can ask about any agent, from a thermostat to an LLM coding agent.
| # | Question | What to look for |
|---|---|---|
| 1 | What can it observe? | state \(s_t\) vs observation \(o_t\); partial observability |
| 2 | What does it represent or remember? | internal state, a world model, memory |
| 3 | What objective drives it? | goal, utility, reward, delegated task, instructions, constraints |
| 4 | How does it decide? | rules, logic, search, planning, a learned policy, model inference |
| 5 | What changes with experience? | learning vs what stays engineered (rules, prompts, tools, permissions) |
| 6 | What can it actually do? | its actions, tools and permissions, and their cost and reversibility |
Two ideas the lecture leans on:
- State vs observation (slide 19). If two different states give the same observation, an agent with no memory must act the same in both. To tell them apart it needs memory or a world model. A thermostat reading “cold” can’t tell “heater just came on” from “window open”.
- Capability (slide 24). What an agent can do depends on what it is able and permitted to do, not on what it knows. An LLM may know the command to delete a database; with no shell tool, it can’t run it.
Worked example: thermostat vs LLM coding agent (slide 32).
| Dimension | Thermostat | LLM coding agent |
|---|---|---|
| observe | temperature | prompts, files, tool outputs, test failures |
| remember | nothing | the context, plus maybe external memory |
| objective | a set-point | delegated task + instructions + constraints |
| decide | one fixed rule | model inference inside a tool loop |
| learn | nothing | before deployment; no weight changes during a task |
| do | heat or cool | edit files, run commands, call tools |
Quiz trap: an LLM agent seems to learn within a session. Its weights don’t change. What changes is its context, which is memory, not learning.
Technique 5: the twelve-question template
Problem it solves: “analyse this agent” questions. Run down this list and you won’t miss a part of the design.
- What is the environment? 2. What can the agent observe? 3. What actions are available? 4. What internal state persists? 5. What knowledge, beliefs or world model does it keep? 6. What kind of memory exists? 7. How is the objective represented? 8. How are decisions made? 9. Does it plan? 10. Does it learn, and on what timescale? 11. What remains engineered? 12. What are its characteristic failure modes?
These come back for every architecture in the module. Each later page answers them for its own kind of agent.
Technique 6: the five traditions
Problem it solves: gives you a map of where each later week’s architecture sits.
| Tradition | Central idea | In this module |
|---|---|---|
| Symbolic / planning | explicit reasoning over representations | week 2: deductive agents, Agent0, STRIPS |
| BDI | beliefs, desires, intentions, deliberation | weeks 2 and 3: BDI, the control loop, AgentSpeak |
| Reactive / behaviour-based | direct perception-to-action coupling | weeks 2 and 3: teleo-reactive, subsumption |
| Reinforcement learning | policies shaped by reward | later weeks |
| LLM-based / tool-using | a pretrained model plus context, tools, memory and a scaffold | the practicals |
This is not a progress ladder (slide 31). Each trades off representation, reaction, planning and learning differently, and modern agents are usually hybrids: an LLM coding agent is a learned model plus symbolic tools (compilers, test runners) plus a fixed control loop.
Where is the agent in an LLM agent? (slide 33) A strong answer: not the LLM alone (no memory between calls, no actions, no persistent goal). The LLM plus its context, tools and control loop together meet Wooldridge’s definition.
When there’s more than one agent
Another agent in the environment changes it strategically: its actions may depend on what it thinks you will do, and your goals may align, conflict or partly overlap. That adds new questions (communication, coordination, cooperation, competition, collective decisions), which are Part II of the module.
The book’s slogan (2.2): “Objects do it for free; agents do it because they want to.” You can call an object’s method; you can only request an action from another agent, and it decides.
What to read in the book
| Section | Read? | Why |
|---|---|---|
| Ch. 1 intro and 1.1 | Skim | The five trends, and the micro (agent design) vs macro (society design) split |
| 1.2 Views of the field | Skip | Dated background |
| 1.3 FAQ | Optional | “Isn’t this just AI?” Not on the slides |
| Ch. 2 opening, pp. 21 to 24 | Read | Slide 9’s definition word for word, varieties of autonomy, the thermostat |
| Environments box, p. 25 | Read | See environment properties |
| 2.1 Intelligent agents | Read | Reactivity, pro-activeness, social ability. Likely quiz material |
| 2.2 Agents and objects | Read | Short and often examined |
| 2.3 Expert systems, 2.4 Intentional systems | Skim | 2.4 sets up BDI |
| 2.5 and 2.6 | Recommended | The maths: see the formal agent model |
Page numbers are the book’s; in the scanned PDF add 21. Nothing in the book covers the LLM definitions, agent vs workflow, or the practicals: the slides are the source.
Practice prompt
I'm studying CS5940 Intelligent Agents (textbook: Wooldridge, An Introduction to MultiAgent Systems, 2nd ed., chapters 1 and 2). I want practice questions on WHAT AN AGENT IS:
- the Russell & Norvig, Wooldridge, OpenAI and Anthropic definitions, and what Wooldridge adds (autonomy, delegated objectives)
- deciding whether a described system is an agent, with reasons (thermostat, spam filter, chatbot, coding agent, smart doorbell...)
- agent vs workflow: is the control flow fixed by the programmer or chosen by the model at run time?
- the delegation problem and adjustable autonomy (when should an agent hand control back to a human?)
- the six design dimensions (observe, remember, objective, decide, learn, act), state vs observation, and capability vs knowledge
- using the twelve recurring questions to analyse an agent design
- placing a design in one of the five traditions (symbolic, BDI, reactive, RL, LLM-based), and why LLM agents are hybrids
- "objects do it for free; agents do it because they want to"
Please:
1. Use plain, everyday language and explain any technical term in one short sentence.
2. Give me ONE question at a time, easy first, then harder, in the style of a university quiz or exam.
3. Wait for my answer, then mark it and show a model answer.
4. If I get it wrong, explain the mistake and give me a similar question.
5. Every 5 questions, summarise my strengths and what to practise.