NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED
NORMATIVE AGENTS
Baldoino F. dos S. Neto
Computer Science Department, PUC-Rio, Rio de Janeiro, Brazil
Viviane Torres da Silva
Computer Science Department, UFF, Rio de Janeiro, Brazil
Carlos J. P. de Lucena
Computer Science Department, PUC-Rio, Rio de Janeiro, Brazil
Keywords:
Autonomous Systems, Agent Platforms and Interoperability, Knowledge Representation and Reasoning.
Abstract:
Normative regulation is a mechanism of social control that regulates the behaviour of autonomous agents
indicating that such agents are permitted, obligated or prohibited to achieve something in the world, and
defining rewards by stating stimulus to their fulfilment and punishments by discouraging their violation. Since
goal-oriented agents‘ priority is the accomplishment of their own desires, they must evaluate the pros and
cons associated with the fulfilment or violation of the norms before choosing to comply or not with them. In
this context, we propose an extension to the BDI architecture by including norms related functions to check
the incoming perceptions (including norms), select the norms they intend to fulfil based on the benefits they
provide to the achievement of the agent‘s desires and intentions, and decide to cope or not with the norms while
dropping, retaining or adopting new intentions. We demonstrate the applicability of our approach through an
non-combatant evacuation scenario implemented by using the Normative Jason platform.
1 INTRODUCTION
Normative regulation is a mechanism that aims to
cope with the heterogeneity, autonomy and diversity
of interests among the different members of an open
multi-agent system establishing a set of norms that
ensures a desirable social order (Lopez-Lopez, 2003).
Such norms regulate the behaviour of the agents
by indicating that they are obligated to accomplish
something in the world (obligations) (Silva, 2008),
permitted to act in a particular way (permissions) and
prohibited from acting in a particular way (prohibi-
tions) (Silva, 2008). Moreover, norms may define re-
wards to their fulfilment and may state punishments
in order to discourage their violation(Silva, 2008).
In this paper we consider that agents are goal-
oriented entities that have the main purpose of achiev-
ing their desires while trying to fulfil the system
norms. In this context, the paper presents an ab-
stract architecture to build agents able to deal with
the norms of a society in an autonomous way.
The NBDI (Norm-Belief-Desire-Intention) architec-
ture extends the BDI (Belief-Desire-Intention) ar-
chitecture (Weiss, 1999) by including norms related
functions to support normative reasoning. The agents
built according to the proposed architecture have: (i)
a review function of norms and beliefs used to check
the incoming perceptions (including norms), (ii) a
norm selection function to select the norms they in-
tend to fulfil based on the benefits they provide to
the achievement of the agent’s desires and intentions,
and to identify and solve conflicts among the selected
norms, and (iii) a norm filter where the agents decide
to cope or not with the norms while dropping, retain-
ing or adopting new intentions.
We demonstrate the applicability of the NBDI ar-
chitecture through a non-combatant evacuation sce-
nario where the tasks related to review, select and fil-
ter norms are implemented by using the Normative
Jason platform (Neto et al., 2010) that already pro-
vides support to the implementation of BDI agents
and a set of normative functions able to check if the
agent should adopt or not a norm, evaluate the pros
and cons associated with the fulfilment or violation of
116
F. dos S. Neto B., Torres da Silva V. and J. P. de Lucena C..
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS.
DOI: 10.5220/0003179801160125
In Proceedings of the 3rd International Conference on Agents and Artificial Intelligence (ICAART-2011), pages 116-125
ISBN: 978-989-8425-40-9
Copyright
c
2011 SCITEPRESS (Science and Technology Publications, Lda.)
the norm, check and solve conflicts among norms, and
choose desires and plans according to their decisions
of fulfilling or not a norm.
The paper is structured as follows. In Section 2
we outline the background about norms that is nec-
essary to follow the paper. In Section 3 we present
the non-combatant evacuation scenario where norms
are defined to regulate the behaviour of rescue agents.
In 4 the proposed NBDI normative agent architecture
is explained and exemplified by using the proposed
scenario. Section 5 demonstrates the applicability of
the NBDI architecture. Section 6 summarizes rele-
vant related work and, finally, Section 7 concludes
and presents some future work.
2 NORMS
In this work, we follow the approaches presented in
(Kollingbaum, 2005), where norms can specify world
states that an agent is obligated to achieve or pro-
hibited from achieving. Moreover, we consider, as
discussed in (Silva, 2008), that norms always spec-
ify a set of addressee agents or roles that are di-
rectly responsible for the adoption and fulfilment of
the norms.
Norms are not applied all the time, but only in par-
ticular circumstances. Thus, norms must always spec-
ify the contexts in which the addressee must adopt
and fulfil them. In addition, to discourage personal
interests of preventing the fulfilment of norms, mech-
anisms either to promote the fulfilment of the norm
or to inhibit deviation from them are needed. Norms
may include rewards to be given when they are ful-
filled and punishments to be applied when they are vi-
olated (Silva, 2008). Rewards can give permission to
the agent to achieve a set of states while punishments
typically obligates or prohibits the agent to achieve a
set of states.
In face of presented, we adopt the representation
for norms described in (Neto et al., 2010), as shown
below:
norm (Addressee, Activation, Expiration,
Rewards,Punishments, DeonticConcept, State)
where Addressee is the agent or role responsible
for fulfilling the norm, Activation is the activation
condition for the norm to become active, Expiration
is the expiration condition for the norm to become
inactive, Rewards are the rewards to be given to the
agent for fulfilling a norm, Punishments are the pun-
ishments to be given to the agent for violating a norm,
DeonticConcept indicates if the norm states an obli-
gation or a prohibition, and State describes a set of
states being regulated.
3 SCENARIO: RESCUE
OPERATION
The applicability of the architecture proposed in this
paper is demonstrated by using the simplified non-
combatant evacuation scenario, presented in (Bur-
nett et al., 2008). In such scenario agents have the
goals to plan the evacuation of members of a Non-
Governmental Organisation (NGO) that are in haz-
ardous location and, to do so, they can use differ-
ent resources that help to evacuate the members, such
as: (i) helicopters, (ii) troops and (iii) land-based he-
licopters. Considering that such resources are lim-
ited, we have a Commander Agent that is responsible
to control the use of the resources regulating the be-
haviour of the agents according to the norms 1, 2 and
3:
Norm 1
Addressee: Rescue Entity
Activation: NGO workers are stranded in a haz-
ardous location
Expiration: NGO workers are stranded in a safe
location
DeonticConcept: Obligation
State: To evacuate NGO workers
Rewards: The Commander Agent gives more
troops to Rescue Entity.
Rewards: The Commander Agent gives land-
based helicopters to Rescue Entity.
Punishments: (obligation) Rescue Entity is obli-
gated to return to the Commander Agent part of their
troops.
Norm 2
Addressee: Rescue Entity
Activation: The weather is bad
Expiration: The weather is good
DeonticConcept: Prohibition
State: To evacuate NGO workers
Punishments: (obligation) Rescue Entity is obli-
gated to return to the Commander Agent part of their
helicopters or land-based helicopters.
Norm 3
Addressee: Rescue Entity
Activation: The weather is bad
Expiration: The weather is good
DeonticConcept: Prohibition
State: To use helicopters.
Rewards: The Commander Agent gives more
troops or land-based helicopters to Rescue Entity.
Punishments: (obligation) Rescue Entity is obli-
gated to return to the Commander Agent part of their
troops.
4 NBDI ARCHITECTURE
The NBDI (Norm-Belief-Desire-Intention) architec-
ture extends the BDI architecture to help agents on
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS
117
Figure 1: NBDI Architecture.
reasoning about the system norms. Norm is consid-
ered as a primary concept that influences the agent
while reasoning about its beliefs, desires and inten-
tions. The extensions we have made are represented
in the NBDI architecture by the following compo-
nents, as illustrated in Figure 1: Belief+Norm Review
Function, Norm Selection Function, Norm Filter and
Plans base
1
(that stores the plans of the agent).
In a nutshell, the NBDI architecture (Figure 1)
works as follows. The agent perceives information
about the world by using its sensors. The sensed
information is the input of the Belief+Norm Review
Function, an extension of Belief Review Function
(Weiss, 1999) defined in the BDI architecture that
is responsible for reviewing the Beliefs base taking
into account the current perception and ones already
stored in the base.
In this work, we consider that norms are also
stored in the Beliefs base, so, besides performing the
original functionality of the Belief Review Function,
the Belief+Norm Review Function is also responsible
for: (i) in case the current perception is a norm, re-
viewing the sets of adopted norms by comparing the
information loaded in the new norm with the norms
and beliefs already stored in the base; and (ii) updat-
ing the sets of adopted and activated norms, consider-
ing that some may become active and others inactive
due to the incoming perceptions.
Next, the Option Generation Function updates the
agent’s desires, and also their priorities. Such adapta-
tion must consider both agent’s current beliefs and in-
tentions, and must be opportunistic, i.e., it should rec-
ognize when environmental circumstances change ad-
vantageously to offer the agent new ways of achieving
intentions, or the possibility of achieving intentions
1
Plans are composed by actions and states that the agent
has the desire to achieve
that were otherwise unachievable (Weiss, 1999). Note
that this function works exactly as the original func-
tion described in the BDI architecture. This function
does not consider the norms stored in the Beliefs base
while updating the agent desires because the agent
must be able to generate new desires or adapt the ex-
isting ones without the influence of the norms. Our
architecture considers that the agent is an autonomous
goal-oriented entity that fulfils the system norms if it
decides to do so.
After reviewing the beliefs, desires, activated and
adopted norms, the Norm Selection Function is exe-
cuted in order to (i) evaluate the activated norms in
order to select the ones that the agent has the inten-
tion to fulfil; and (ii) identify and solve the conflicts
among these norms.
Next, the Norm Filter, an extension of Filter
(Weiss, 1999) defined in the BDI architecture, selects
the desires that will become intentions taking into ac-
count the norms the agent wants to fulfil. The plans
that will achieve the intentions are also selected by
following the norms the agent wants to fulfil.
Finally, the Action Selection Function is respon-
sible for performing the actions specified by the in-
tention. The next subsections detail the components
added to the original BDI architecture, the one that
was extended and a set of algorithms that demonstrate
how such components can be implemented. Note that
other algorithms to implement such components can
also be developed and plugged into the NBDI archi-
tecture.
4.1 Belief+Norm Review Function
Besides performing the original functionality of the
Belief Review Function, which is the revision of the
beliefs (represented by Reviewing Beliefs task), the
ICAART 2011 - 3rd International Conference on Agents and Artificial Intelligence
118
Figure 2: Belief+Norm Review Function.
Belief+Norm Review Function (Figure 2), helps the
agent on recognizing its responsibilities towards other
agents by adopting new norms that specify such re-
sponsibilities (represented by Adopting Norms task)
and updates the sets of activated and adopted norms
(represented by Updating Norms task).
4.1.1 Adopting Norms (AN)
This task recognizes from the set of receiving per-
ceptions the ones that describe norms. After recog-
nizing the norms, such function reviews the set of
adopted norms applying the following verifications:
(i) it checks if the new norm unifies with one of the
norms already adopted, i.e., if the incoming norm al-
ready exists in the agent Belief Base (Algorithm 1
from line 2 to 7), and (ii) it verifies if the agent is
the addressee of the norm, i.e., if the field Addressee
of the new norm unifies with the agent role or agent
name, also stored as a belief in the Belief Base (Algo-
rithm 1 line 8). Finally, such function updates the set
of adopted norms in the Belief Base if the new norm
does not already exist and the agent is the addressee
of the norm (Algorithm 1 line 9).
Algorithm 1 : Adopting Norms.
Require: Beliefs base N: norms stored in the beliefs base
Require: agent: informations about the agent, such as:
name and role
Require: Beliefs base NA: adopted norms stored in the be-
liefs base
Require: NN: new norms
1: for all newNorm in NN do
2: x = true
3: for all n in N do
4: if (n == newNorm) then
5: x = false
6: end if
7: end for
8: if x ((agent.Name == newNorm.Addresse)
((agent.Role == newNorm.Addresse)) then
9: NA.add(newNorm)
10: end if
11: end for
With the aim to exemplify the use of this task, let’s
consider the scenario presented in Section 3 where
two groups of agents are leaded by Agent A and Agent
B playing the role Rescue Entity. When these enti-
ties receive information about the three system norms,
the AN task is executed checking if the norms are not
stored yet in the agent’s belief base and comparing
the addressee information with the role being played
by the agents.
4.1.2 Updating Norms (UN)
UN task updates the set of activated and adopted
norms checking if the fields Activation and Expira-
tion of the norm unifies with the beliefs of the agent.
If the activation conditions unify with the beliefs, the
adopted norm is activated (Algorithm 2 from line 3 to
6). If the expiration conditions unify with the beliefs,
the norm is deactivated and stored as an adopted norm
(Algorithm 2 from line 7 to 10).
Algorithm 2 : Updating Norms.
Require: Beliefs base NAD: adopted norms stored in the
beliefs base
Require: Beliefs base NAC: activated norms stored in the
beliefs base
Require: P: new perceptions
1: for all n in (NAD NAC) do
2: for all p in P do
3: if (n.Activation.unify(p)) then
4: NAD.remove(n)
5: NAC.add(n)
6: else
7: if (n.Expiration.unify(p)) then
8: NAC.remove(n)
9: NAD.add(n)
10: end if
11: end if
12: end for
13: end for
Following the example above, if the weather of
the area operated by one of the two rescue entities
is bad, both norms 2 and 3 are activated, since the
activation condition of both norms is “The weather
is bad”. If the norms are activated, the rescue entity
must not rescue NGO members and must not use he-
licopters. Both norms are deactivated when the expi-
ration condition unifies with the information about a
good weather stored in the agent’s belief base.
4.2 Norm Selection Function
The main goal of the Norm Selection Function (Fig-
ure 3) is to select the norms that the agent has the
intention to fulfil. In order to do this, such function
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS
119
Figure 3: Norm Selection Function.
performs two tasks: 1) Evaluating Norms and 2) Iden-
tifying and Solving Conflicts. The first task helps the
agent on selecting, from the set of activated norms,
the norms that it has the intention to fulfil and the ones
it has the intention to violate. The function evaluates
the benefits of fulfilling or violating the norms, i.e., it
checks how close the agent gets of achieving its de-
sires if it decides to fulfil or if it decides to violate
the norms. The function groups the activated norms
in two sub-sets: norms to be fulfilled and norms to
be violated. Finally, the second task of this function
identifies and solves the conflicts among the norms
that the agent has the intention to fulfil and among the
ones that the agent has the intention to violate.
4.2.1 Evaluating the Norms (EN)
In order to evaluate the benefits of the fulfilment or
violation of a norm according to the agent’s desires
and intentions, the steps below should be followed:
Step-1. In case of obligations, it checks if the state
described in the norm is equal to one of
the states that the agent has desire (or in-
tention) to achieve. In affirmative cases,
the contribution is positive and the function
g(n.DeonticConcept, n.State) returns a value
indicating the level of norm’s contribution
that is calculated according to the priority of
the desire that is similar to the state described
by norm. The function receives as parame-
ters n.DeonticConcept representing the deon-
tic concept type, i. e., obligation or prohibi-
tion, and n.State representing the state that is
been regulated. In any other case, the con-
tribution is zero since it does not disturb the
achievement of the agent’s desires or inten-
tions. Such step is represented in Algorithm
3 from line 2 to 8.
Step-2. In case of prohibitions, it checks if the state
described in the norm is equal to one of the
states that the agent has desire ( or inten-
tion) to achieve. In affirmative cases, the
contribution is negative since it disturbs the
achievement of the agent’s desires or inten-
tions and the function g(n.DeonticConcept,
n.State) calculates the absolute value of the
contribution. In any other case, the prohibi-
tion will contribute neutrally. Such step is
represented in Algorithm 3 between lines 9
and 15.
Step-3. After analyzing the state being regulated, this
step considers the influence that the rewards
have to the achievement of the agent’s de-
sires. We consider that rewards can never in-
fluence the agent negatively but always pos-
itively or neutrally since they give permis-
sions to achieve a set of states. Such step is
represented in Algorithm 3 by line 16. Func-
tion r(n.Rewards) verifies the desires (or in-
tentions) that are equal to the rewards and re-
turns a value indicating the contribution that
is the sum of the priorities of the agent’s de-
sires benefited by the rewards.
Step-4. Finally, the punishments are evaluated in
order to check if they will influence the
achievement of the agent’s desires and inten-
tions negatively or positively.
Step-4.1. In case the punishment states a
prohibition and the state being pro-
hibited is one of the agent desires
or intentions, the punishment will
influence negatively since it will
disturb the agent of achieving one
of its desires. If it is not the case,
the punishment will not influence.
Such step is represented in Algo-
rithm 4 from line 2 to 8. Function
g(n.punishments.DeonticConcept)
returns a absolute value indicating
the contribution of the fulfilment
of the prohibition to the achieve-
ment of the agent’s desires and
intentions.
Step-4.2. In case the punishment states an
obligation and the state being
obliged is one of the agent desires
or intentions, the punishment will
influence positively (or neutrally)
since such state will already be
achieved by the agent. If it is
not the case, the punishment
will not influence. Such step
is represented in Algorithm 4
from line 9 to 15. Function
g(n.punishments.DeonticConcept)
returns a value indicating the con-
tribution of the fulfilment of the
ICAART 2011 - 3rd International Conference on Agents and Artificial Intelligence
120
obligation to the achievement of
the agent’s desires and intentions.
Algorithm 3 : Evaluating the fulfilment.
Require: Desires base D
Require: Intentions base I
Require: Beliefs base N: norms stored in the beliefs base
1: x = 0
2: if n.DeonticConcept == Obligation then
3: for all d in (D I) do
4: if n.State == d then
5: x = x + g (n.DeonticConcept, n.State)
6: end if
7: end for
8: end if
9: if n.DeonticConcept == Prohibition then
10: for all d in (D I) do
11: if n.State == d then
12: x = x - g (n.DeonticConcept, n.State)
13: end if
14: end for
15: end if
16: x = x + r (n.Rewards)
17: return x
Algorithm 4 : Evaluating the violation.
Require: Desires base D
Require: Intentions base I
Require: Beliefs base N: norms stored in the beliefs base
1: x = 0
2: if n.punishment == Prohibition then
3: for all d in (D I) do
4: if n.punishment.state == d then
5: x = x - g (n.punishments.DeonticConcept,
n.punishments.State)
6: end if
7: end for
8: end if
9: if n.punishment == Obligation then
10: for all d in (D I) do
11: if n.punishment.state == d then
12: x = x + g (n.punishments.DeonticConcept,
n.punishments.State)
13: end if
14: end for
15: end if
16: return x
Note that it is necessary to individually check the
contribution of the fulfilment and violation of each
norm to the achievement of the agent desires (or in-
tentions). Such step is represented in Algorithm 5 in
the lines 2 and 3.
After checking how each norm can contribute to
the achievement of the agent’s desires and intentions,
the function helps the agent on deciding which are
the norms that it should fulfil, i.e., the norms whose
contribution coming from its fulfilment is greater than
Algorithm 5 : Reasoning about norms (Main).
Require: fulfilSet NF: norms stored in the fulfil set
Require: vilateSet NV: norms stored in the violate set
Require: Norms base N
1: for all Norm n in N do
2: fulfil = Execute Algorithm 3 using n
3: violate = Execute Algorithm 4 using n
4: if fulfil >= violate then
5: NF.add(n)
6: else
7: NV.add(n)
8: end if
9: end for
Algorithm 6 : Detecting Conflicts.
Require: fulfilSet NF: norms stored in the fulfil set
Require: vilateSet NV: norms stored in the violate set
1: for all Norm n1 in NF do
2: for all Norm n2 in NF do
3: if n1.State == n2.State and (n1.DeonticConcept
== Obligation and n2.DeonticConcept == Prohi-
bition) or (n2.DeonticConcept == Obligation and
n1.DeonticConcept == Prohibition) then
4: Execute Algorithm 7 using n1 and n2
5: end if
6: end for
7: end for
8: for all Norm n1 in NV do
9: for all Norm n2 in NV do
10: if n1.State == n2.State and (n1.DeonticConcept
== Obligation and n2.DeonticConcept == Prohi-
bition) or (n2.DeonticConcept == Obligation and
n1.DeonticConcept == Prohibition) then
11: Execute Algorithm 7 using n1 and n2
12: end if
13: end for
14: end for
Algorithm 7 : Solving Conflicts.
Require: fulfilSet NF: norms stored in the fulfil set
Require: vilateSet NV: norms stored in the violate set
1: fulfiln1 = Execute Algorithm 3 using n1
2: violaten2 = Execute Algorithm 4 using n2
3: fulfiln2 = Execute Algorithm 3 using n2
4: violaten1 = Execute Algorithm 4 using n1
5: if fulfiln1 + violaten2 >= fulfiln2 + violaten1 then
6: NF.remove(n2)
7: NV.remove(n1)
8: else
9: NF.remove(n1)
10: NV.remove(n2)
11: end if
the contribution coming from its violation. Steps 1, 2
and 3 return the contribution of the norm if the agent
chooses to fulfil it (Algorithm 3 line 17) and 4.1 and
4.2 return its contribution if the agent chooses to vio-
late the norm (Algorithm 4 line 16). Therefore, Al-
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS
121
gorithm 3 should be used to evaluate the contribu-
tion of the fulfilment of the norm to the agents’ de-
sires/intentions and Algorithm 4 should be used to cal-
culate the contribution of the violation of the norm to
the agents’ desires/intentions.
If the contribution for fulfilling the norm is greater
than or equal to the contribution for violating the
norm, the norm is selected to be fulfilled and added
to the sub-set Fulfill of the activated norms. Such step
is represented in Algorithm 5 from line 4 to 6. Oth-
erwise, it is selected to be violated and added to the
sub-set Violate of the activated norms. Such step is
represented in Algorithm 5 from line 6 to 8.
In order to exemplify the applicability of the EN
task, let’s consider the rescue operation scenario. The
evaluation of the benefits of fulfilling and violating
the three norms are shown in Tables 1, 3 and 2 that
indicates the contribution of each norm element to the
achievement of the agent goals. We consider that any
norm element generates the same contribution that is
1.
After analysing the contribution of the norms
shown in Tables 1, 3 and 2, Norm 1 is included in the
set of norms to be fulfilled since the contribution for
fulfilling it is equal to “+3” and greater than the con-
tribution for violating it that is equal to “-1”. Norm
2 is also included in the fulfil set since the contribu-
tion for fulfilling it is equal to “-1” and greater than
the contribution for violating it that is equal to “-2”.
And, finally, Norm 3 is included in the fulfil set since
the contribution for fulfilling it is equal to “+1” and
greater than the contribution for violating it that is
equal to “-1”. It indicates that the agent has the in-
tention to fulfil the three norms.
4.2.2 Detecting and Solving Conflicts (DSC)
If two different norms (one being an obligation and
the other one a prohibition) specify the same state, it
is important to check their status, i.e., to check if they
are in the set of norms that will be violated or fulfilled
since they may be in conflict. As illustrated in Table
4, if the agent intends to fulfil the obligation but does
not intend to fulfil the prohibition, these norms are not
in conflict. The same can be said if the agent intends
to fulfil the prohibition and to violate the obligation.
On the other hand, if the agent intends to fulfil both
norms or to violate both norms, they are in conflict
and it must be solved. Such step is represented in
Algorithm 6.
For instance, in case of conflicts between two
norms that the agent intends to fulfil or violate, the
one with highest contribution to the achievement of
the agent’s desires (and intentions) can be selected.
If the contributions have equal values we can choose
Table 1: Evaluating norm 1.
Norm Contribution
positive neutral negative
Obligation 1 0 0
Reward 1 0 0
Reward 1 0 0
Punishments
Obligation 0 0 1
Table 2: Evaluating norm 3.
Norm Contribution
positive neutral negative
Prohibition 0 0 1
Reward 1 0 0
Reward 1 0 0
Punishments
Obligation 0 0 1
Table 3: Evaluating norm 2.
Norm Contribution
positive neutral negative
Prohibition 0 0 1
Punishments
Obligation 0 0 1
Obligation 0 0 1
Table 4: Detecting Conflicts. P represents the prohibition
and O the obligation that describe the same state.
Fulfil (O) Violate (O)
Fulfil (P) Conflict Fulfil (P)
Violate (P) Fulfil (O) Conflict
anyone. That is, if the contribution coming from the
fulfilment of the first norm (Steps 1, 2 and 3) plus the
contribution coming from the violation of the second
norm (Steps 4.1 and 4.2) is greater to or equal than the
contribution coming from the fulfilment of the second
norm plus the contribution coming from the violation
of the first norm, the first norm is selected to be ful-
filled and the second one to be violated. It is repre-
sented in Algorithm 7 from line 5 to 8. In case the
opposite happens, the second norm is selected to be
fulfilled and the first to be violated, as described in
Algorithm 7 from line 8 to 11.
Considering the norms evaluated in the EN func-
tion, a conflict between Norm 1 and 2 is detected and
should be solved. The conflict is solved by selecting
Norm 1 to be fulfilled and Norm 2 to be violated since
the contribution coming from the fulfilment of the first
norm (+3) plus the contribution coming from the vi-
olation of the second norm (-2) is greater than the
contribution coming from the fulfilment of the sec-
ond norm (-1) plus the contribution coming from the
violation of the first norm (-1).
ICAART 2011 - 3rd International Conference on Agents and Artificial Intelligence
122
Figure 4: Norm Filter.
4.3 Norm Filter
The Norm Filter (Figure 4) is executed in order to
drop any intention that does not bring benefits to the
agent, retains intentions that are still expected to have
a positive overall benefit and adopt new intentions, ei-
ther to achieve existing intentions, or exploit new op-
portunities. In order to accomplish theses tasks and
besides performing the original functionality of the
Filter function, such function performs two additional
steps.
4.3.1 Selecting Desires (SD)
In this step the filter selects the desires that will be-
come intentions taking into account the norms the
agent wants to fulfil. The desires are selected accord-
ing to their priorities and the norms may increase or
decrease such priorities. If the agent has a desire to
achieve a state and there is a norm that obliges the
agent of achieving such state, the desire priority is in-
creased according to the importance of the norm (rep-
resented in Algorithm 8 from line 3 to 5). If the agent
has a desire to achieve a state and there is a norm that
prohibits the agent of achieving such state, the desire
priority is decreased according to the importance of
the norm (represented in Algorithm 8 from line 5 to
9). If there is not any norm related to the desires, its
priority is not modified. Finally, the function getDe-
sireHighestPriority() (Algorithm 8 line 12) returns the
desire with highest priority.
By applying this function to our example, the goal
“Evacuating the members of a NGO to a safe loca-
tion” is selected because such goal has highest prior-
ity since it receives a positive influence of Norm 1.
4.3.2 Selecting Plans (SP)
After selecting the desires with highest priorities, i.e.,
after generating the agent intentions, the agent needs
to select the plans that will achieve such intentions.
Algorithm 8 : Selecting Desires.
Require: fulfilSet NF: norms stored in the fulfil set
Require: Desires base D
Require: Intentions base I
1: for all Norm n in NF do
2: for all d in (D I) do
3: if (n.State == d) (n.DeonticConcept ==
Obligation) then
4: d.annotatePriority(+1)
5: else
6: if (n.State == d) (n.DeonticConcept ==
Prohibition) then
7: d.annotatePriority(-1)
8: end if
9: end if
10: end for
11: end for
12: return getDesireHighestPriority()
Like in the selection of desires, the selection of plans
will also be influenced by the norms.
While selecting a plan it is important to make sure
that such plan will achieve the state described in the
obligation norm and that will not achieve an state be-
ing prohibited. Therefore, the plans that achieve a
given intention are ordered according to their priori-
ties. If the state described by an obligation norm is
equal to one of the states included in the plan, the
norm increases the priority of such plan (represented
in Algorithm 9 from line 4 to 6). Otherwise, if the
state described by an prohibition norm is equal to one
of the states included in the plan, the norm decreases
the priority of such plan (represented in Algorithm 9
from line 6 to 10).
Let’s consider that the desires of the agents in
our example with highest priority is “Evacuating the
members of a NGO to a safe location”, that the agent
has the intention to fulfil Norm 3, and that the priority
of plans that uses helicopters has decrease. When SP
step is executed it selects the plan with highest prior-
ity that tries to rescue the NGO workers and that will
not use helicopters to do so.
5 IMPLEMENTING THE NBDI
ARCHITECTURE
The NBDI architecture proposed in section 4 was im-
plemented by translating the functions related to re-
view, select and filter norms proposed in such archi-
tecture to the Normative Jason platform, described in
(Neto et al., 2010). The platform provides a set of
normative functions, as follows: (i) the Norm Re-
view function helps the agent on recognizing its re-
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS
123
Algorithm 9 : Selecting Plan.
Require: fulfilSet NF: norms stored in the fulfil set
Require: P: all plans that achieve the selected desire
1: for all Norm n in NF do
2: for all p in P do
3: for all state in p do
4: if (n.State == state) (n.DeonticConcept ==
Obligation) then
5: p.annotatePriority(+1)
6: else
7: if (n.State == state)
(n.DeonticConcept == Prohibition)
then
8: p.annotatePriority(-1)
9: end if
10: end if
11: end for
12: end for
13: end for
14: return getPlanHighestPriority()
sponsibilities towards other agents by incorporating
the norms that specify such responsibilities. Such
function implements the Algorithm 1 described in the
(AN) step; (ii) the main task of the Updating Norm
function is to update the set of activated and adopted
norms. It implements the algorithm Algorithm 2 de-
scribed in the (UN) step; (iii) the Evaluating Norm
function helps the agent on selecting the norms that it
has the intention to fulfil and the ones it has the inten-
tion to violate by executing the Algorithm 5 and, con-
sequently, Algorithms 3 and 4 described in the (EN)
step; (iv) the Detecting and Solving Conflicts func-
tion checks and solves the conflicts among the norms.
It executes Algorithms 6 and 7 described in the (ISC)
step; (v) the Selecting Desires function selects the de-
sires that will become intentions taking into account
their priorities and executes Algorithm 8 described in
the (SD) step; and, finally, (vi) the Selecting Plans
function chooses a single applicable plan from the set
of options based on their priorities and executes Algo-
rithm 9 described in the (SP) step. The applicability
of the NBDI architecture and its implementation was
demonstrated by the developing of the non-combatant
evacuation scenario, presented in section 3.
6 RELATED WORK
Our work was influenced by the architecture proposed
in (Castelfranchi et al., 1999). Such architecture to
build normative agents also contemplates functions to
deal with the adoption of norms and the influence of
norms on the selection of desires and plans. However,
our work presents details about the verifications that
must be satisfied in order to agents adopt norms, the
evaluations that must be made to select the norms the
agents intend to fulfil and violate and a guidelines to
help agents on selecting plans according to the norms
they want to fulfil and violate.
The BOID (Belief-Obligation-Intention-Desire)
architecture proposed in (Broersen et al., 2002) and
extended in (Beavers and Hexmoor, 2002) is an exten-
sion of the BDI architecture that considers the influ-
ence of beliefs, obligations, intentions and desires on
the generation of the agent desires. The BOID archi-
tecture applies the notion of agent types to help on the
generation of the desires. For instance, if the agents
beliefs override its obligations, intentions or desires,
then we say that this agent is realistic, if its desires
override its obligations, then the agent is called self-
ish and if its obligations override its desires, then the
agent is called social. Thus, their approach could have
been used in the (SD) function being proposed in our
paper since this function is the one responsible to se-
lect the desires. Instead of basing the selection of de-
sires on the agent type, we have used the norm contri-
bution and the priority of the desires (and intentions)
to provide a quantifiable solution to the selection of
the agent desire.
The approach described in (Kollingbaum, 2005)
proposes an architecture to build norm-driven agents
whose main purpose is the fulfilment of norms and not
the achievement of their goals. In contrast, our agents
are desire-driven that take into account the norms but
are not driven by them.
In (Meneguzzi and Luck, 2009) the authors pro-
vide a technique to extend BDI agent languages by
enabling them to enact behaviour modification at run-
time in response to newly accepted norms, i.e., it con-
sists of creating new plans to comply with obliga-
tions and suppressing the execution of existing plans
that violate prohibitions. However, they have not
considered the desires and plans priorities. In our
work we consider that obligations and prohibitions
may increase or decrease the priority of a desire or
a plan, and that the selection of desires and plans
are based on their priorities. The approach proposed
in (Meneguzzi and Luck, 2009) simply creates, se-
lects or suppresses plans in response to obligations
and prohibitions. As a consequence, it is possible that
desires and plans with high priorities are not selected.
The agents built according to the architecture pre-
sented in (Lopez-Lopez and Marquez, 2004) are able
to evaluate the effects of norms on their desires help-
ing then on deciding to comply or not with the norms.
This architecture is based on the BDI architecture
whose properties have been expanded to include nor-
mative reasoning. In the Norm Review process being
ICAART 2011 - 3rd International Conference on Agents and Artificial Intelligence
124
proposed, we extend some of the verifications defined
in (Lopez-Lopez and Marquez, 2004), such as: our
architecture checks (i) if the norm was not adopted
already and (ii) if the agent is the addressee of the
norm. Besides, in the Norm selection process, al-
though the approach proposed in (Lopez-Lopez and
Marquez, 2004) evaluates the positive and negative
effects of norms on the agent desires, it does not con-
sider the influence of rewards in such evaluation.
The authors in (Dignum, 1996) present concepts,
and their relations, that are used for modelling au-
tonomous agents in an environment that is governed
by some (social) norms. Although such approach
considers that the selection of desires and plans
should be based on their priorities and that such pri-
orities can be influenced by norms, it does not present
a complete strategy with a set of verification in the
norm review process, and strategies to evaluate, iden-
tify and solve conflicts between norms such as our
work does.
7 CONCLUSIONS
This paper proposes an extension to the BDI architec-
ture called NBDI to build goal-oriented agents able
to: (i) check if the agent should adopt or not a norm,
(ii) evaluate the pros and cons associated with the ful-
filment or violation of the norm, (iii) check and solve
conflicts among norms, and (iv) choose desires and
plans according to their decisions of fulfilling or not a
norm.
By implementing the algorithms from 1 to 9 and
using the Normative Jason platform, the applicability
of NBDI architecture could be verified in the example
presented in Section 3. Such agents are responsible
to plan the evacuation of people that are in hazardous
location, check the incoming perceptions (including
norms), select the norms they intend to fulfil based
on the benefits they provide to the achievement of the
agent’s desires and intentions, identify and solve con-
flicts among the selected norms, and decide to cope or
not with the norms while dropping, retaining or adopt-
ing new intentions. We are investigating the need for
extenting the AgentSpeak language with new predi-
cates that better represent the norms. We are also in
the process of defining an experimental study in order
compare our approach with other related ones.
ACKNOWLEDGEMENTS
The present work has been partially funded by the
Spanish project Agreement Technologies” (CON-
SOLIDER CSD2007-0022, INGENIO 2010) and by
the Brazilian research councils CNPq under grant
303531/2009-6, 557.128/2009-9 and FAPERJ under
grant E-26/110.959/2009, E- 26/170028/2008.
REFERENCES
Beavers, G. and Hexmoor, H. (2002). Obligations in a bdi
agent architecture. In In IC-AI.
Broersen, J., Dastani, M., Hulstijn, J., and van der Torre,
L. (2002). Goal generation in the boid architecture.
Cognitive Science Quarterly.
Burnett, C., Masato, D., McCallum, M., Norman, T., Gi-
ampapa, J., Kollingbaum, M., and Sycara, K. (2008).
Agent support for mission planning under policy con-
straints. In Proc. of 2nd Int. Technology Alliance.
Castelfranchi, C., Dignum, F., Jonker, C., and Treur, J.
(1999). Deliberative normative agents: Principles and
architecture. In In Proc. of the 6th Int. Workshop on
Agent Theories, Architectures, and Languages.
Dignum, F. (1996). Autonomous agents and social norms.
In Proc. of the Workshop on Norms, Obligations and
Conventions, pages 56–71.
Kollingbaum, M. (2005). Norm-Governed Practical Rea-
soning Agents. PhD thesis, University of Aberdeen.
Lopez-Lopez, F. (2003). Social Power and Norms: Im-
pact on agent behavior. PhD thesis, University of
Southampton.
Lopez-Lopez, F. and Marquez, A. (2004). An architecture
for autonomous normative agents. In Proc. of the 5th
Int. Conf. in Computer Science.
Meneguzzi, F. and Luck, M. (2009). Norm-based behaviour
modification in bdi agents. In Proc. of 8th Int. Conf.
on Autonomous Agents and Multiagent Systems.
Neto, B. F. S., da Silva, V. T., and de Lucena, C. J. P. (2010).
Using jason to develop normative agents. In In Proc.
of the XX Brazilian Symposium on Artificial Intelli-
gence.
Silva, V. (2008). From the specification to the implemen-
tation of norms: an automatic approach to generate
rules from norms to govern the behavior of agents.
Autonomous Agents and Multi-Agent Systems, pages
113–155.
Weiss, G. (1999). Multiagent Systems: A Modern Approach
to Distributed Modern Approach to Artificial Intelli-
gence. Massachusetts Institute of Technology.
NBDI: AN ARCHITECTURE FOR GOAL-ORIENTED NORMATIVE AGENTS
125