AgentSpeak(L) has the concepts of events, beliefs, and actions. Goals (and subgoals) are handled by treating the addition of a goal as an event, in line with practice in implemented BDI systems. The execution cycle is:
- Agent selects an event e (note that goals are an event type)
- Agent generates all plans with matching invocation conditions
- From these relevant plans the agent identifies those with satisfied preconditions
- If there are several plans, one is chosen nondeterministically
- AgentSpeak(L): BDI Agents speak out in a logical computable language,
Anand S. Rao, Australian Artificial Intelligence Institute, Technical Report 64.
Also appeared in Agents Breaking Away (LNAI 1038, p42-55). (postscript, PDF)
AOS: Shoham's Agent Oriented Software is used in Agent0, PLACA and AgentBuilder.
The concepts used are beliefs, obligation/commitment, decisions (modelled as a commitment to oneself), and performatives (inform, request, ...). Time, events, and actions are also present as basic concepts. The focus is on the useof mental attitudes to control agents. Mental attitudes are formed by performatives which create commitments/obligations. At each step the agent selects what actions to perform based on its commitments.
AgentBuilder adds behaviour rules (when-if-then) and intentions (commitment to achieve goal).
- Agent Oriented Programming, Y. Shoham, Journal of Artificial Intelligence , 60(1), pp. 51-92, 1993.
- AgentBuilder white paper
BDI: (Belief, Desire, Intention). The BDI model is one of the most popular agent architectures. It has its roots in philosophy and offers a logical theory which defines the mental attitudes of Belief, Desire, and Intention using a modal logic; a system architecture; a number of implementations of this architecture (e.g. PRS, JAM, JACK, and dMARS); and applications demonstrating the viability of the model.
The central concepts in the BDI model (see figure at right, click for full size) are:
- Beliefs: Information about the environment;
- Desires: Objectives to be accomplished, possibly with each objective's associated priority/payoff;
- Intentions: The currently chosen course of action;
- Plans: Means of achieving certain future world states. Intuitively, plans are an abstract specification of both the means for achieving certain desires and the options available to the agent. Each plan has (i) a body describing the primitive actions or sub-goals that have to be achieved for plan execution to be successful; (ii) an invocation condition which specifies the triggering event (Some events are considered as goal-events.), and (iii) a context condition which specifies the situation in which the plan is applicable.
The concepts described above correspond to the philosophical viewpoint. When implemented, the concepts differ somewhat: beliefs are treated as a relational database (i.e. a collection of predicates) or an arbitrary data structure; goals/desires are treated as an event type; and intentions are realised simply as an executing plan. A fourth concept, that of plans, is also added.
A plan typically has an invocation condition, context condition, fail/success actions, plan body, and maintenance condition.
The execution cycle is as for AgentSpeak(L) (above) - not surprising, since AgentSpeak(L) intends to extract
the essence of implemented BDI systems. This is also depicted in the figure below (click for full size).
BOID As the name might suggest, the BOID architecture extends the BDI model: the "O" stands for obligations. The BOID work identifies different types of conflict (e.g. between obligations and desires) and uses a default logic framework as an alternative to the traditional branching time modal logic presentations.
The architecture is depicted below. Each box represents a collection of default rules: a default rule of the form A -> B is read as "conclude B from A if it is sound to do so". By completing the observations with respect to the belief rules before considering, say, intention rules, beliefs are given priority over other mental attitudes.
- Broersen, J., Dastani, M., Huang, Z., Hulstijn, J. and Van der Torre, L. (2001) The BOID architecture: Conflicts between beliefs, obligations, intentions and desires. In: Proceedings of the Fifth International Conference on Autonomous Agents (AA2001), pages 9-16, ACM Press.
CASA is an agent language combining BDI and guarded Horn clauses (concurrent logic programming). It extends AgentSpeak(L) concepts using a syntax reminiscent of JAM. Concepts used are belief, action, message, and goal. The execution model is depicted below (click for full size).
Cougaar (Cognitive Agent Architecture) is a blackboard architecture based agent system written in Java. Its development was funded by the US government, and it is now open source. It uses the concepts of tasks and resources. Tasks can be decomposed, performed directly, or delegated to another agent. These three options are provided by plugins which extend Cougaar with domain specific functionality.
DECAF (Distributed Environment Centered Agent Framework) is a child of TÆMS and RETSINA. It simplifies the TÆMS model and adds some RETSINA features. DECAF provides a graphical plan editor which is used to construct high level plans. These are then linked to Java code which provides lower level functionality. Plans are Hierarchical Task Networks (HTNs). The execution cycle is depicted below (click for full size) and is notable (compared with BDI) for the use of a schedular to schedule actions for execution. Note that objectives correspond to BDI desires.
EXCALIBUR To be completed
Guardian
uses the concepts of
Objectives, resources, and decisions.
It is an older architecture which is based on a blackboard system using
a conceptual graph formalism.
A control plan is the intended course of behaviour.
HAC (Hierarchical Agent Control) is a component of the
Capture the flag project.
Most of its novelty and difference to other models relate to the specific domain.
In particular, the handling of actions as continuous processes that are guided by goals and that provide
feedback to their parents ("goals down, knowledge up") is novel.
Also, agents use an internal model to plan what to do: effectively this is done using game playing, the agent plays
out a hypothetical evolution of the current situation assuming that other agents would do what it would do in their place.
Latent goals are used to give reactivity and the system supports the notion of a task - a system goal, as opposed to a single
agent goal.
Similar to other agent models, plans are triggered by syntactic matching against goals and are human written.
IMPACT
(Interactive Maryland Platform for Agents Collaborating Together).
To be completed
JIAC: (Java Intelligent Agents Componentware)
Not a lot of information is available on this system. It seems to focus on inter-agent stuff (communications, KQML).
Reference is made to a planner which selects scripts based on priority and a knowledge base, however, no information
seems to be available.
ParADE (Parma Agent Development Environment) has two levels:
The architecture itself uses a planner, but
treats interaction protocols reactively (responds to arriving messages) for efficiency.
It seems to derive plans at runtime from action descriptions (pre and post conditions), however, not much information is available
on this aspect of the system. The architecture is depicted below.
RETSINA from CMU's agent group
uses a Hierarchical Task network Planner (HITaP) which interleaves planning and execution.
Concepts used are objectives (corresponding to goals in BDI) which are stored in a priority queue, and
tasks. The architecture (left) and an example plan (right) are depicted below. (click for full size)
Sensible Agents:
SIM_AGENT
is a toolkit for experimenting with different agent architectures. As such, it doesn't actually
provide an agent architecture: rather, it gives a high level symbolic programming languages with libraries
which aim to ease the task of implementing a given agent architecture.
TÆMS: (Task Analysis, Environmental Modelling and Simulation language)
uses a graphical plan representation which unifies tasks, actions, and resources. Execution consists
of modifying this graph.
A plan body is a collection of entities (see example below) with links indicating relationships (such as
enables, disables, hinders, facilitates, produces, etc.). A task corresponds loosely to a goal except that it is a system goal,
rather than a single agent's goal. A method is an action.
Methods are described with probabilistic distributions of expected quality, cost, and duration.
The use of probabilistic representation enables satisficing.
The results of children tasks are combined using
Quality Accumulation Functions (QAFs) such as min, max, sum, sequences min/max/sum, exactly one, etc.
In practice, it appears that some details of TÆMS are complex and hard to implement efficiently.
Surprisingly little detailed information seems to be available about the internal workings of this system.
The architectural diagram below shows various components, however, I have found it hard to obtain details on the internal
workings of these components. Through conversation with Anuj Goel I was able to learn that the process of deciding
what action to do next is done by a planner.
This planner uses model checking technology. It uses the PDDL notation to describe the domain.
Changes in the environment (or in the agent's goals) are handled by replanning.
Multiple goals are simply conjuncted together.
Efficiency was claimed to not be a problem.
"While the details associated with TÆMS can be daunting, there are in reality
just a few simple concepts behind its structure and function.
A TÆMS task structure is essentially an annotated task decomposition tree (actually a graph,
but we will refer to is as a tree
for simplicity here).
The highest level nodes in the tree, called task groups, represent goals
that an agent may try to achieve. Below a
task group there will be a sequence of tasks and methods which describe how
that task group may be performed. Tasks represent sub-goals,
which can be further decomposed in the same manner. Methods, on the other hand, are terminal,
and represent the primitive actions an
agent can perform."
From TÆMS white paper (emphasis added)