AgentSpeak(L): BDI Agents Speak Out in a Logical Computable Language

Reference: Rao, A. S. (1996). AgentSpeak(L): BDI Agents Speak Out in a Logical Computable Language. In Agents Breaking Away (MAAMAW ’96), LNCS 1038, pp. 42–55, Springer. (Companion implementation/textbook: Bordini, R. H., Hübner, J. F. & Wooldridge, M. (2007). Programming Multi-Agent Systems in AgentSpeak using Jason. Wiley.) Springer DOI · SciSpace mirror · Jason runtime (jason-lang.github.io)

Summary

Rao introduces AgentSpeak(L), a logic-based agent programming language giving the BDI architecture a clean operational semantics suitable for implementation. Where Rao & Georgeff 1991 gave an abstract BDI model in modal logic and Cohen & Levesque 1990 gave a logical theory of intention, AgentSpeak supplies the missing implementable bridge: a Prolog-flavoured language in which an agent is specified by (i) a belief base (Prolog facts), (ii) a set of plans (event-triggered procedures), and (iii) an intention stack of currently-executing plans. The interpreter cycles through perception (updating beliefs), event generation (changes in beliefs and goals trigger events), plan selection (the plan library is queried for an applicable plan whose triggering event and context match), intention selection (the chosen plan is added to the intention stack), and execution (the next step of the next intention is executed). The language is small — half-a-dozen syntactic forms — and the operational semantics fits on a page, but it covers the dynamics that abstract BDI papers leave implicit. AgentSpeak became practically dominant through Jason (Bordini, Hübner, Wooldridge 2007), a Java-based interpreter that extended AgentSpeak with internal actions, customisable selection functions, and integration with JaCaMo (CArtAgO artefacts + MOISE organisations). Jason is the most-deployed BDI agent platform in academic MAS research; the AgentSpeak language is the implementation lingua franca of the operational BDI tradition. The paper closes a substantial gap in the vault between the abstract BDI literature and the engineering reality of running BDI agents.

Key Ideas

Beliefs as a Prolog-style fact base: an agent’s beliefs are atomic literals (with negation as failure); belief updates are additions and removals of facts triggered by perception.
Plans as event-triggered procedures: a plan has the form triggering-event : context <- body. — when the triggering event occurs and the context (a conjunction of belief queries) holds, the body (a sequence of actions, sub-goal achievements, and belief assertions) becomes executable.
Triggering events: belief additions (+belief) and deletions (-belief), goal additions (+!goal for achievement, +?goal for test). Each event triggers plan-library lookup.
Intention as a stack of plans-in-execution: each top-level event spawns an intention (a stack); sub-goal achievement pushes a sub-plan onto the stack; completion pops the stack.
Three selection functions: S_E (which event to handle next), S_O (which applicable plan to use), S_I (which intention to advance) — left abstract in the language and provided as user-supplied policies in implementations.
Cycle-based interpreter: the agent runs an indefinite loop — perceive → update beliefs → generate events → select event → look up plan → select plan → push intention → select intention → execute one step. Each cycle is finite, so the agent is reactively responsive to environmental change.
Operational semantics in eight rules: the formal SOS-style semantics fits in a small table; this is what makes AgentSpeak implementable, and what previous abstract BDI work lacked.

Connections

Conceptual Contribution

Claim: The BDI architecture, until then specified abstractly in modal logic (Rao & Georgeff 1991, Cohen & Levesque 1990), can be given a clean operational semantics as a small Prolog-flavoured language in which an agent is a triple of belief base, plan library, and intention stack, with an interpreter cycling through perceive / event / plan-select / execute steps. This bridges abstract BDI theory and BDI implementation.
Mechanism: Belief base as Prolog facts; plans as triggering-event : context <- body clauses; intentions as stacks of plans-in-execution; eight-rule SOS-style operational semantics; three abstract selection functions (S_E, S_O, S_I) supplied as user policy.
Concepts introduced/used: AgentSpeak, Jason (BDI runtime), Plan Library, Triggering Event, Intention Stack, Selection Function.
Stance: foundational technical paper / language design.
Relates to: Operational counterpart of Rao & Georgeff 1991 (the abstract BDI model) and Cohen & Levesque 1990 (the formal-logic theory of intention) — AgentSpeak is the implementable bridge that makes these abstract theories deployable as running agents. Sister approach to Shoham’s AGENT-0 (1993): both are operational agent languages, but AGENT-0 emphasises commitment-based message passing while AgentSpeak emphasises BDI plan reasoning. Other operational BDI languages — 3APL, GOAL, 2APL, Jadex — share the same stance and many share AgentSpeak’s Prolog-flavoured syntax. Jason (Bordini, Hübner, Wooldridge 2007) is the dominant production AgentSpeak implementation, integrated with JaCaMo (CArtAgO artefacts + MOISE organisations) to provide a complete agent / environment / organisation stack — the most-deployed BDI platform in academic MAS research. Within this vault, AgentSpeak / Jason is the missing operational realisation of the BDI threads in BDI, BDI Architecture, BDI Agents, Multiagent Systems Sycara, and Intelligent Agents Theory and Practice — the answer to “yes, but how do you actually build a BDI agent?”

Tags

#bdi #agentspeak #rao #operational-bdi #jason #multi-agent #foundations

Backlinks

Linked Pages

Intelligent Agents Theory and Practice

Intelligent Agents: Theory and Practice

Reference: Wooldridge, M., Jennings, N. R. (1995). Knowledge Engineering Review. Source file: woodridge_intelligent_agents.pdf. URL

Summary

A foundational survey that organizes the agent-based computing field into three tightly coupled concerns: agent theories (formal specifications of what an agent is, often via intentional notions such as belief, desire, intention, obligation), agent architectures (software/hardware designs satisfying those specifications, e.g., BDI, subsumption, layered), and agent languages (programming languages whose primitives embody the theorists’ concepts).

Wooldridge and Jennings distinguish a weak notion of agency (autonomy, social ability, reactivity, pro-activeness) from a stronger AI-centric notion involving mentalistic attributes (knowledge, belief, intention) and sometimes emotion or mobility. They review representational and reasoning formalisms (modal logics for knowledge and belief, intention logics), critique their computational tractability, and survey implementations (AGENT-0, PLACA, Concurrent METATEM). The paper sets the vocabulary used by much subsequent MAS research.

Key Ideas

Three-way division: theory, architecture, language.
Weak vs. strong notion of agency.
Intentional stance justifies mentalistic ascription (Dennett/McCarthy).
BDI and related mental-state architectures.
Survey of 1990s agent languages and applications.

Connections

Conceptual Contribution

Claim: The emerging field of agent-based computing should be structured around the interlocking triad of agent theories, architectures and languages, and tensions between weak (behavioural) and strong (mentalistic) notions of agency should be kept explicit rather than elided.
Mechanism: Wooldridge and Jennings synthesise early 1990s work by (i) defining weak agency (autonomy, social ability, reactivity, pro-activeness) and strong agency (adds belief, desire, intention, emotion, mobility); (ii) surveying modal-logic theories of knowledge/belief/intention and the intentional stance as justification; (iii) cataloguing BDI, subsumption and layered architectures; and (iv) reviewing implemented languages (AGENT-0, PLACA, Concurrent METATEM) and representative applications. Computational tractability of the richer logics is flagged as a central open problem.
Concepts introduced/used: Weak Agency, Strong Agency, Intentional Stance, BDI, Subsumption Architecture, Layered Architecture, Concurrent METATEM, PLACA, Agent Theory-Architecture-Language Triad
Stance: survey
Relates to: Canonises the vocabulary used by Agent-Oriented Programming, Agent Communication Languages - Rethinking the Principles and Trends in Agent Communication Language; its tractability critique anticipates the social-semantic move in An Interaction-oriented Agent Framework for Open Environments.

Tags

Multiagent Systems Sycara

Multiagent Systems

Reference: Katia P. Sycara (1998). AI Magazine, Summer 1998, Vol. 19, No. 2, pp. 79-92. Source file: Multiagent_Systems.pdf. URL

Summary

Sycara’s survey introduces multi-agent systems (MAS) as a paradigm for tackling problems too large, complex, or distributed for a single agent, presenting the key characteristics that distinguish MAS: each agent has incomplete information, there is no global control, data is decentralized, and computation is asynchronous. She motivates MAS via open systems like the Internet where heterogeneous agents from different designers must interoperate, and surveys the main research problems: coordination, communication, negotiation, coherence, conflict resolution, and reasoning about other agents.

She organizes the field around issues (enabling communication, individual agent reasoning, adaptive coordination, protocols like Contract Net and KQML, reactive vs. deliberative architectures, emergent behavior) and applications (information gathering, e-commerce, manufacturing, health care, distributed planning). Throughout she emphasizes coherence — how locally-acting agents can achieve globally reasonable performance — as the defining challenge.

Key Ideas

Four MAS characteristics: incomplete info, no global control, decentralized data, async computation.
Coherence as the central research challenge.
Spectrum from reactive (stimulus-response) to deliberative (BDI) architectures.
Coordination requires reasoning about other agents’ expected behavior.
Organizations, markets, and scientific-community metaphors for MAS structure.

Connections

Conceptual Contribution

Claim: Multi-agent systems are the appropriate paradigm for open, distributed, heterogeneous problem-solving; they are characterised by four structural properties (incomplete info, no global control, decentralised data, async computation) and unified by the problem of achieving coherence through local decisions.
Mechanism: Survey-style synthesis organising the MAS field around: motivations (modularity, legacy interop, distributed data), core challenges (coherent coordination, negotiation, planning, conflict resolution), architectures (reactive, deliberative/BDI, hybrid), organisational metaphors (hierarchy, market, community, scientific), protocols (Contract Net, KQML), and application domains (info gathering, e-commerce, manufacturing, aircraft maintenance).
Concepts introduced/used: Multi-Agent Systems, Coherence, Problem-Solving Coherence, Contract Net Protocol, BDI Architecture, Reactive vs Deliberative Agents, Negotiation, Joint Intentions, Organizational Metaphors
Stance: survey / foundational
Relates to: Canonical MAS reference informing nearly every other note; defines the field that ACL Rethinking Principles and Verifiable Semantics for ACLs critique; organisational metaphors dovetail with How Do Committees Invent; negotiation/coordination theme continued in Toward Automated Evolution of ACLs and Coordinating Agents Using ACL Conversations.

Tags

BDI Agents

Agents whose architecture is structured around explicit Beliefs (information about the world), Desires (goals), and Intentions (committed plans). The BDI model provides a practical reasoning cycle — deliberation over desires yields intentions, means-ends reasoning selects plans — and is the basis of AgentSpeak, Jason, JACK and similar platforms.

In this vault

BDI Architecture

The Belief-Desire-Intention model of practical reasoning: an agent maintains beliefs about the world, desires (goals) it would like to achieve, and intentions (committed plans) that drive its behaviour, typically executed via a sense-deliberate-act loop over a plan library.

In this vault

BDI

Belief-Desire-Intention

Dominant agent-architecture paradigm: agents maintain beliefs, desires, and intentions and deliberate over them.

In this vault

Agents and Artifacts

Agents and Artifacts (A&A)

Meta-model treating the agent environment as first-class artefacts agents interact with, implemented in JaCaMo / CArtAgO.

In this vault

Agent-Oriented Programming

Reference: Shoham, Y. (1993). Artificial Intelligence 60, Elsevier. Source file: shoam-aop.pdf. URL

Summary

Shoham introduces Agent-Oriented Programming (AOP) as a specialization of object-oriented programming in which the state of each module — now called an agent — is a mental state composed of beliefs, capabilities, decisions/choices, commitments, and obligations. Interpretation of these components is formally grounded in an extension of standard epistemic logics that adds temporality, obligation, decision, and capability operators.

Agents communicate via speech-act-inspired primitives (inform, request, offer, promise, decline, etc.), constrained by rules such as honesty and consistency. The paper defines a class of agent interpreters and presents AGENT-0, a concrete implemented language whose semantics is tied to the mental-state logic. Shoham also discusses “agentification” — converting arbitrary devices into AOP-programmable agents — and situates AOP against BDI architectures, speech act theory, and McCarthy’s Elephant2000.

Key Ideas

AOP as OOP specialization with mental-state components.
Agents constrained by honesty/consistency on communicative acts.
Speech-act-typed primitives as message types.
AGENT-0 language and interpreter.
“Agentification” of arbitrary devices.

Connections

Conceptual Contribution

Claim: Programming can be fruitfully specialised to an “agent” paradigm in which module state is a formally specified mental state and inter-module communication is a speech act constrained by rational/ethical rules.
Mechanism: Shoham extends standard modal-epistemic logic with temporal, obligation, decision and capability operators, defines the mental-state components of an agent (belief, capability, commitment, choice, obligation), then specifies a generic agent interpreter cycle (update mental state, execute commitments, handle incoming messages) and instantiates it in AGENT-0, whose programs are condition-action rules over mental state and whose messages are typed INFORM/REQUEST/UNREQUEST primitives.
Concepts introduced/used: Agent-Oriented Programming, Mental State, Commitment, AGENT-0, Speech Act Theory, Agentification, BDI, Honesty Constraint
Stance: foundational
Relates to: Establishes the mentalistic ACL stance later criticised by Agent Communication Languages - Rethinking the Principles and surveyed by Intelligent Agents Theory and Practice; AGENT-0’s speech-act primitives anticipate KQML as an Agent Communication Language and FIPA-ACL; the mental-state architecture is reused in An Interaction-oriented Agent Framework for Open Environments.

Tags

Intention Is Choice with Commitment

Reference: Cohen, P.R. & Levesque, H.J. (1990). Artificial Intelligence 42(3): 213–261. Source file: cohen-levesque-intention-is-choice-with-commitment.pdf. URL

Summary

Cohen and Levesque formalise the “rational balance” that holds between an autonomous agent’s beliefs, goals, actions, and intentions. They define intention as a composite mental attitude: a persistent goal that the agent is committed to pursuing until it is achieved, known to be impossible, or no longer relevant. This yields a modal logic whose axioms capture Bratman’s three functional roles for intention — posing problems for means-end reasoning, acting as a screen of admissibility for future intentions, and prompting the agent to track (and re-try) the success of its actions.

The paper opens with the now-classic “Willie the robot” vignette (uncommitted, overcommitted, then homicidally committed), framing intention as what an agent must reason about to be both reliable and responsive. By relativising intentions to beliefs about another agent’s intentions the authors also sketch a theory of interpersonal commitment that anticipates speech-act and multi-agent communication semantics.

Key Ideas

Persistent goal (P-GOAL): a goal an agent will not drop until it is believed achieved, believed impossible, or its relevance condition fails.
Intention defined as a P-GOAL to have done an action while believing one is about to do it — closing Bratman’s gap between intending and acting intentionally.
Avoids the “side-effect problem”: agents don’t intend foreseen side-effects of their actions.
Mutual/relativised intentions as a foundation for interpersonal commitments and speech acts.
Desiderata list (beliefs, feasibility, non-futility, tracking) becomes a standard benchmark for intention logics.

Connections

Agent-Oriented Programming
Belief-Desire-Intention
BDI Logic
BDI Architecture
Joint Intentions
Commitment
Mental State
Rational Action Semantics
Speech Act Theory
Intentional Stance
Flexible Protocol Specification and Execution
A Commitment-Based Approach to Agent Communication
Communicative Actions for Artificial Agents - Cohen Levesque — the 1995 ICMAS sequel that turns the 1990 framework into an explicit speech-act / ACL semantics; direct ancestor of FIPA-ACL.
FIPA-ACL Specifications
Mentalistic Semantics
ACL Rethinking Principles — Singh’s critique of the BDI-based ACL semantics built on this foundation.

Conceptual Contribution

Claim: Intention is not a primitive mental state but a choice with commitment — a goal plus a meta-policy for when to drop it.
Mechanism: Modal logic over beliefs and goals plus a temporal operator for persistence; intention defined compositionally so its functional roles (planning, filtering, tracking) are theorems rather than axioms.
Concepts introduced/used: Persistent Goal, Commitment, Rational Balance, Mental State, Nested Beliefs, Joint Intentions.
Stance: foundational/formal.
Relates to: Shoham’s Agent-Oriented Programming cites this paper as the prime candidate for grounding AOP’s mental-state semantics; Shoham deliberately chooses a simpler obligation/commitment primitive for AGENT-0 but frames C&L as the rigorous theory AOP languages should eventually implement. The paper also underwrites FIPA-style Mentalistic Semantics and Rational Action Semantics for ACLs.

Tags

Modeling Rational Agents within a BDI-Architecture

Reference: Rao, A. S., & Georgeff, M. P. (1991). In J. Allen, R. Fikes, & E. Sandewall (Eds.), Proceedings of the Second International Conference on Principles of Knowledge Representation and Reasoning (KR’91), 473–484. Morgan Kaufmann. Also AAII Technical Note 14. Source file: rao_georgeff_bdi_architecture.pdf. URL

Summary

Rao and Georgeff give the canonical formalization of the Belief–Desire–Intention architecture as a modal/temporal logic over a branching-time possible-worlds model (a first-order extension of CTL*). Beliefs, goals (chosen, consistent, believed-achievable desires), and intentions are each modelled as accessibility relations over time trees, with the crucial innovation that belief-, goal-, and intention-accessible worlds are themselves time trees rather than static worlds — so an agent’s mental state simultaneously ranges over uncertainty about the world (branches across belief-worlds) and choice among options (branches within each world).

The paper realises the central tenets of Bratman’s philosophical theory (intentions as partial plans, irreducible to belief+desire) in a tractable semantic framework and introduces the distinction between choice (what the agent picks) and possibility (what the environment affords). A key technical contribution is the family of commitment strategies — blind, single-minded, and open-minded — which parametrically define how intentions persist under changing beliefs, yielding a taxonomy of rational agent types from fanatically committed to fully reconsidering. The formalism relates intentions to actions via sub-world inclusion (goals ⊆ beliefs; intentions ⊆ goals), avoiding classical side-effect problems of earlier intention logics.

Key Ideas

First-order CTL*-based modal logic with Bel, Goal, Intend accessibility.
Belief-, goal-, intention-accessible worlds are themselves branching time trees.
Optional vs. inevitable path modalities; distinguishes choice from possibility.
Strong realism constraint: goal-worlds are sub-worlds of belief-worlds.
Commitment strategies: blind, single-minded, open-minded.
Intentions treated as first-class, non-reducible to beliefs and desires.
Comparison with Cohen–Levesque’s reductive intention formalism.

Connections

Conceptual Contribution

Claim: Rational agent behaviour is best modelled by treating beliefs, goals and intentions as equally fundamental modal attitudes over branching time, with agent types differentiated by commitment strategy rather than by reduction of intention to other attitudes.
Mechanism: (i) Adopt CTL*-style branching time where each situation is a time point in a time tree, with path modalities optional and inevitable; (ii) associate each situation with sets of belief-, goal-, and intention-accessible worlds, each itself a time tree, imposing sub-world containment (strong realism); (iii) define rationality postulates relating the three attitudes; (iv) axiomatise commitment policies (blind = drop intention only on achievement, single-minded = also drop when no longer believed achievable, open-minded = also drop when no longer desired), yielding distinct agent classes.
Concepts introduced/used: BDI Logic, Commitment Strategies, Strong Realism, Branching Time, Intention, Practical Reasoning
Stance: formal framework
Relates to: Formalises the philosophical picture of Two Faces of Intention and operationalises the stance of Intentional Stance; provides the semantic bedrock for BDI Architecture, Agent-Oriented Programming and the theory side of Intelligent Agents Theory and Practice; differs from and complements Intention Is Choice with Commitment (Cohen & Levesque) by treating intention as primitive rather than derived.

Tags

Plan Library

In AgentSpeak and successor BDI languages, the agent’s stored set of plans — each plan is a clause of the form triggering-event : context <- body. When an event (belief update or goal addition) occurs, the interpreter queries the plan library for plans whose triggering event matches and whose context is satisfied by the current belief base; the applicable plans are candidates for the chosen plan to execute. The plan library is the agent’s procedural-knowledge repository — the BDI counterpart of a procedure / function library in conventional programming.

In this vault

Jason (BDI runtime)

Bordini, Hübner & Wooldridge’s (2007) Java-based interpreter for an extended AgentSpeak language — the most-deployed BDI agent platform in academic MAS research. Adds internal actions, customisable selection functions, plan annotation, and integration with JaCaMo (CArtAgO artefacts + MOISE organisations). Used as the standard testbed in many MAS research papers and as the implementation substrate of several agent-coordination projects.

In this vault

AgentSpeak

Rao’s (1996) operational BDI agent programming language: an agent is a triple of belief base (Prolog facts), plan library (event-triggered procedures), and intention stack (plans-in-execution). The interpreter cycles through perceive → event-generate → plan-select → execute. Eight-rule SOS-style operational semantics fits on a page. Made practically dominant through Jason (Bordini-Hübner-Wooldridge 2007), the most-deployed BDI platform in academic MAS research.

In this vault

An Interaction-oriented Agent Framework for Open Environments

An Interaction-oriented Agent Framework for Open Environments (Mercurio)

Reference: Baldoni, Baroglio, Bergenti, Marengo, Mascardi, Patti, Ricci, Santi (2011). AIIA 2011 (Italian AI Association)*. Source file: cbcl-ref/AI_IA2011.pdf. URL

Summary

The authors propose Mercurio, an agent-programming framework for open multi-agent systems that unifies direct (speech-act) and indirect (environment-mediated) communication under a single social/observational semantics based on commitments. Mercurio has three levels — specification (constitutive and regulative rules over a domain model), programming abstractions (Agents and Artifacts in the A&A meta-model), and infrastructure (built on JaCaMo integrating Jason, CArtAgO, and MOISE).

Commitment-based protocols give a public, verifiable meaning to actions (replacing mentalistic ACL semantics); constitutive rules define what counts as what, while regulative rules impose temporal constraints on the social state. Artifacts reify interaction patterns and the social state itself, enabling the environment to monitor and detect violations. The framework thus conjugates MAS flexibility with software-engineering modularity and compositionality, targeting e-government, cross-business, and service-oriented applications.

Key Ideas

Commitment-based social semantics replaces mentalistic ACL semantics.
Three levels: specification, programming abstractions, infrastructure.
Separation of constitutive and regulative rules.
Artifacts (A&A / CArtAgO) as first-class environment entities.
JaCaMo stack (Jason + CArtAgO + MOISE) as reference infrastructure.

Connections

Conceptual Contribution

Claim: Open multi-agent systems need a single, publicly verifiable interaction semantics that unifies direct (speech-act) and indirect (environment-mediated) communication; commitments plus Agents-and-Artifacts supply it and can be layered onto an existing AOP stack.
Mechanism: Mercurio stratifies into three levels. (1) Specification: a domain model plus constitutive rules (“what counts as what”) and regulative rules (temporal constraints on the social state). (2) Programming abstractions: the A&A meta-model (agents + artifacts) where artifacts reify interaction patterns and the social state itself. (3) Infrastructure: the JaCaMo stack (Jason + CArtAgO + MOISE) runs the above so violations are environment-detectable and the social state is inspectable.
Concepts introduced/used: Mercurio Framework, Commitment-Based Protocol, Constitutive Rules, Regulative Rules, Agents and Artifacts, JaCaMo, Jason, CArtAgO, MOISE, Social State
Stance: engineering
Relates to: Concretely instantiates the social-semantic programme of Agent Communication Languages - Rethinking the Principles and the open-issue agenda of Trends in Agent Communication Language and The State of the Art in Agent Communication Languages; its environment-reified interaction complements the self-organisation of A Composite Self-organisation Mechanism in an Agent Network.

Tags

CArtAgO

Common Artifacts for Agents Open framework — a Java infrastructure implementing the Agents & Artifacts meta-model in which agents perceive and act on first-class environmental artifacts governed by observable properties and operations.

In this vault

Cohen and Levesque

Philip R. Cohen and Hector J. Levesque, whose joint and individual work in the 1980s–1990s formalised intention, joint intention, and the rational-balance constraints on BDI-style agents. Their 1990 paper Intention Is Choice with Commitment (AIJ 42) is the canonical formal model of intention as a persistent goal — a commitment to maintain a goal until it is believed achieved, believed unachievable, or its motivating reason dissolves. Cohen & Levesque (1991) Teamwork extends the analysis to joint action and joint intentions in multi-agent settings.

In this vault

BDI Logic

A family of multimodal logics (Rao & Georgeff, Cohen & Levesque) that formalise the attitudes of Belief, Desire and Intention, giving axioms for their interaction over branching time. BDI logic underpins mentalistic semantics for agent communication languages.

In this vault

Belief-Desire-Intention

Alternative spelling of the BDI agent architecture; see BDI for the canonical entry.