The knowledge level is a concept introduced by Allen Newell at the end of the 1980s [Newell 1982], at the root of research on cognitive architectures, and it deeply affected the scientific understanding and engineering of agents and MAS. Its key idea: “intelligent systems” — natural or artificial — need a proper level of description/explanation that cannot be reduced to pure low-level mechanisms: they need proper abstractions.
The starting point: any computer system can be described as a hierarchy of descriptions, all based on the computer as a behaving system — types of machines. In each case there is some kind of medium that is processed: working up from the bottom, the media are electrons, current, bits, bit vectors, and data structures. At any moment, the “state” of the system consists of some configuration of its medium.
There are behaviour laws that can be used to predict the behaviour of the system at each level:
In each case, if we know the state of the system and the laws of its behaviour, we can obtain the state of the system at some point in the future. Each description provides a different way to make predictions about system behaviour — where “prediction” is shorthand for all the uses of descriptions: explaining behaviour, controlling behaviour, or constructing something that behaves to specification.
Knowledge systems are just another level within the same hierarchy: a way to describe the behaviour of (intelligent) systems with wide-ranging capabilities in terms of their having “knowledge” and behaving in light of it. This level:
The knowledge level is what can be used to select actions to attain goals, abstracted from representation and processing.
Knowledge-level systems are agents that have knowledge-level (KL) and goals, such that their behaviour is successfully predicted by the law: all the agent’s knowledge is always used to attain the goals of the agent. The claim need not be for completely successful prediction, but only to some approximation.
The intentional stance, introduced by the philosopher Daniel Dennett, is strongly related to the knowledge level concept. It is about describing/specifying/predicting the behaviour of (complex) dynamic systems using high-level conceptual frameworks based on “mentalistic terms” — such as belief, desire, intention, expectation — as opposed to the design stance, which explains behaviour through the physical/functional design of the system. Agents are intentional systems: their behaviour is best explained and predicted by ascribing mental states to them.
Cognitive architectures are architectures defining the behaviour of intelligent agents as knowledge-level systems. They are close cousins to computer architectures: they have memories, processing and control components, representations of data, and input/output devices — but instead of needing to support general computation, they must support the representation, acquisition, and use of knowledge to pursue goals.
An important distinction:
A cognitive architecture is designed to be the basis for creating general, autonomous agents that can solve (and learn from) a wide variety of problems, using a wide variety of knowledge. From an operational point of view, it provides the fixed processes, memories and associated algorithms and data structures to acquire, represent and process knowledge about the environment and tasks for moment-to-moment reasoning, problem solving, and goal-oriented behaviour. This leads to a simple equation:
Knowledge is the information a system uses to make decisions and produce behaviour, even if the information is incorrect. It includes general knowledge (supporting general capabilities such as language processing, planning, retrospective reasoning) and task knowledge (specific to problems and domains).
Cognitive architectures are one part of one level in a computational processing hierarchy (Newell 1990): the physical level is the lowest (providing the physical implementation of computation for the cognitive level); the cognitive level supports the knowledge level (cognitive architectures sit at the interface between the physical and cognitive levels, providing the structures for encoding knowledge); the top is the knowledge level, which abstracts away from the processing of the cognitive level — an agent is described using the content of the knowledge and the principle of rationality, not data structures or algorithms.
As one progresses up the hierarchy, behaviour is studied at progressively longer time scales: the physical level ranges from nanoseconds to microseconds, the cognitive level from milliseconds to tens of seconds, and the knowledge level from minutes to hours.
Achieving the knowledge level requires perfect rationality, which is computationally infeasible except for simple goals or limited bodies of knowledge. The challenge for a cognitive architecture is to provide structures to approximate the knowledge level under the constraint of being physically realized with limited computational resources. A hypothesis underlying cognitive-architecture research: approximations to rational behaviour, and thus intelligence, arise from the combination of large bodies of knowledge and the underlying set of fixed processes that manipulate it.
A prototypical abstract architecture captures the commonalities among different concrete cases — examples: Soar, ACT-R, Icarus, LIDA, and CLARION.
Applying cognitive architectures to language agents produces cognitive language agents [Sumers, Yao, Narasimhan and Griffiths, TMLR 02/2024]: the LLM-based agents of Chapter 13 are re-read through the lens of the cognitive architecture tradition — fixed processes and memories, plus knowledge, yielding behaviour. The module’s slide deck explicitly connects the agentic wave to the knowledge level and to BDI as an effective baseline, a thread that Chapter 15’s hybrid-architectures discussion takes up.
This is the bridge chapter: Chapter 13 ended with language agents; the knowledge level and cognitive architectures give those agents their theoretical footing; and the BDI model, developed next, is the classic architecture that reconciles reactive and goal-directed behaviour — the same reconciliation the hybrid architectures of Chapter 13 attempted structurally.
Practical reasoning is a reasoning model of decision-making directed towards actions — the process of figuring out what to do. As Bratman puts it: “Practical reasoning is a matter of weighing conflicting considerations for and against competing options, where the relevant considerations are provided by what the agent desires/values/cares about and what the agent believes” [Bratman, 1990, p. 17].
Human practical reasoning appears to consist of at least two distinct activities:
An architecture for a rational agent must allow for both, for their interaction, and must address resource boundedness [Bratman, Israel and Pollack 1988]: in this architecture, a major role of the agent’s plans is to constrain the amount of further practical reasoning the agent must perform — plans commit the agent, and commitment is what makes deliberation affordable.
The BDI model (Belief-Desire-Intention) organizes the agent’s mental state into three components:
Events play a fundamental role too: they are triggers for reactive activity by the agent. They may be external (received by sensors or integrated systems) or internal (triggering decoupled updates or plans of activity).
The BDI family includes the PRS architecture (Georgeff & Lansky), the IRMA architecture (Bratman, Israel, Pollack), dMARS (Kinny), BDI logics and agent architecture (Rao & Georgeff), and more. PRS — the Procedural Reasoning System — is the canonical implemented ancestor: a reactive planning system organized around a belief base, a plan library (knowledge areas), events, and intentions, with a reasoning cycle that processes events by selecting applicable plans and executing them as intentions.
The abstract BDI reasoning cycle [Wooldridge 2009] is a sense-plan-act cycle whose key feature is preserving reactivity while acting:
B ← brf(B, perception()) — belief revision: update beliefs from perception;D ← options(B, I) — generate the options (desires) available given beliefs and intentions;I ← filter(B, D, I) — filter the options to a new intention set;π ← plan(B, I, A) — select a plan for the chosen intention;π ≠ ∅ and not succeeded(I, B) and not impossible(I, B): execute head(π), then π ← tail(π);B ← brf(B, perception()); if reconsider(I, B) then recompute options and filter; if the plan is no longer sound, re-plan.The agent reconsiders its intentions — but not always: reconsideration is itself a decision, because it costs time.
From a programming viewpoint, BDI gives the benefits expected of a domain-specific language where the “domain” is autonomous agents, MAS, intelligent systems:
From an execution viewpoint:
On explainability, transparency and verifiability: intention-driven behaviour makes it easier for the end user to understand why an agent is doing what it is doing (“why” questions and debugging), easier to predict what it will do next (the knowledge level), eases “Ethics by Design” (agent reasoning about ethical aspects), and eases formal verification of complex decision making — key to engineering trustworthy AI systems.
Limitations:
The course reads BDI as an effective level of abstraction: Dennett’s intentional stance + Bratman’s practical reasoning = intention-driven practical reasoning systems. BDI is also the baseline for the cognitive era: “injecting AI in the reasoning cycle” (sense stage: richer knowledge representation; plan stage: plan selection and generation; act stage: supporting deliberation about intention progress). The 1995 Rao & Georgeff paper bridges theory (BDI logics) and practice (the OASIS air-traffic management system at Sydney airport).
The knowledge level is a level of description for (intelligent) systems introduced by Newell (1982), part of a hierarchy of descriptions whose media go from electrons, current, bits, data structures up to knowledge. At the knowledge level a system is described in terms of having knowledge and behaving in light of it, abstracting completely from internal processing and representation. Medium: knowledge. Law of behaviour: if the system wants to attain goal G and knows that doing act A will attain G, then it will do A — a simple form of rationality.
A knowledge-level system is an agent that has knowledge-level and goals, such that its behaviour is successfully predicted by the law that all its knowledge is always used to attain its goals (to some approximation). The intentional stance (Dennett) is describing/specifying/predicting the behaviour of complex dynamic systems using high-level “mentalistic” frameworks (belief, desire, intention, expectation), as opposed to the design stance (physical/functional design); agents are intentional systems.
Cognitive architectures are architectures defining the behaviour of intelligent agents as knowledge-level systems: fixed, task-independent structures (memories, processing and control components, representations, I/O) supporting the representation, acquisition and use of knowledge to pursue goals, designed to be the basis for general autonomous agents. Equation: architecture + knowledge = behavior; knowledge (even if incorrect) is the information used to make decisions, including general knowledge (language, planning, retrospective reasoning) and task knowledge (domain specific).
Achieving the knowledge level requires perfect rationality, computationally infeasible except for simple goals or limited knowledge. Cognitive architectures approximate it under the constraint of limited computational resources, hypothesizing that intelligence arises from large bodies of knowledge plus fixed processes. Time scales (Newell 1990): physical level nanoseconds–microseconds; cognitive level milliseconds–tens of seconds (cognitive architectures sit at the physical/cognitive interface); knowledge level minutes–hours.
Soar, ACT-R, Icarus, LIDA, and CLARION — a prototypical abstract architecture captures the commonalities among concrete cases. Soar (e.g. version 9) illustrates the blueprint style: symbolic long-term memories (procedural, semantic, episodic) with associated learning mechanisms, short-term memory, perception and action.
Practical reasoning is the reasoning model of decision-making directed towards actions — figuring out what to do: weighing conflicting considerations for and against competing options, where the considerations come from what the agent desires/values/cares about and what it believes [Bratman]. Two activities: deliberation (deciding what states of affairs to achieve) and means–ends reasoning (deciding how to achieve them). Under resource boundedness, plans constrain the amount of further practical reasoning needed [Bratman, Israel & Pollack 1988].
Beliefs: the informational state — beliefs about the world, itself, other agents. Desires: the motivational state — objectives the agent would like to bring about; goals are desires adopted for active pursuit, with the restriction that active desires must be consistent. Intentions: the deliberative state — desires the agent has committed to; in implemented systems, executing a plan (a sequence of actions/recipes, initially partial). Events (external or internal) are triggers for reactive activity.
B ← brf(B, perception()) (belief revision); D ← options(B, I) (generate desires/options); I ← filter(B, D, I) (commit to intentions); π ← plan(B, I, A) (select a plan); while the plan is non-empty and not succeeded and not impossible: execute head(π) and advance to tail. Then perceive again, and if reconsider(I, B) recompute options and filter; if the plan is no longer sound, re-plan. Reconsideration is not always done — it costs time. This preserves reactivity while acting.
Programming: understandability via mentalistic terms, separation of symbolic vs sub-symbolic concerns, faster development with fewer errors. Execution: interleaving of plan selection and action execution (context-sensitive, robust, graceful recovery), expanded behaviour space for lower effort, intelligibility (explainable AI), easier “why” debugging, ethics-by-design, formal verification. Limitations: developer effort to define complex strategies as plans, effort to adapt the default cycle for advanced applications and non-functional requirements, and no support for generating plans at runtime.
Because BDI is a programming-based approach with an abstraction level (beliefs, goals, plans, intentions) suitable for understanding and integrating learning-based and model-based approaches: plans for a goal can be entirely programmed or learnt, offline or online (planning), using different approaches per plan — “injecting AI in the reasoning cycle” at the sense, plan and act stages. The 1995 Rao & Georgeff paper shows the same bridging from the theory side (BDI logics) to practice (OASIS at Sydney airport).