Semantics and Pragmatics for Agent Communication - Semantic Scholar

Semantics and Pragmatics for Agent Communication Rodrigo Agerri and Eduardo Alonso Dept. of Computing, City University, EC1V 0HB London, UK {rag, eduardo}@soi.city.ac.uk

Abstract. For the successful management of interactions in open multiagent systems, a social framework is needed to complement a standard semantics and interaction protocols for agent communication. In this paper a rights-based framework in which interaction protocols and conversation policies acquire their meaning is presented. Rights improve interaction and facilitate social action in multi-agent domains. Rights allow agents enough freedom, and at the same time constrain them (prohibiting specific actions). A general framework for agent communication languages (ACLs) is proposed, defining a set of performatives (semantics) and showing why a set of conversation policies to guide agent’s interactions (pragmatics) is needed. Finally, we show how it is possible to model interaction protocols within a rights-based normative open MAS.

1

Introduction

One of the distinguishing properties of Multi-Agent Systems (MAS) is the ability of their members to interact with one other. Communication is a kind of interaction that should not affect the autonomy or heterogeneity of the agents, in the sense that agents are not forced to send or receive messages; in theory, agents are free to reject requests or not to answer any received messages. This is particularly true in open environments, such as the electronic commerce applications based on the Internet, where agents are designed by different constructors and work for their individual interests. The adoption of a standard Agent Communication Language (ACL) is crucial for artificial agents to interact in open environments. Following the main tradition in this research area, the specification of a standard ACL is based on speech act theory [18]. Organizations like FIPA (Foundation for Intelligent Physical Agents [9]), define an ACL from a mentalistic point of view: The meaning of the performatives are defined in terms of the mental states of the agents, namely, beliefs, intentions and desires. It has been argued that the mentalistic approach can be useful for cooperative agents. However, in open environments, in which agents are heterogeneous and competitive, it is not sensible for agents to trust their opponents in a negotiation process, or to make assumptions about their current beliefs or intentions ([19,10]). We believe that these criticisms are partially motivated by not distinguishing between the C. Bento, A. Cardoso, and G. Dias (Eds.): EPIA 2005, LNAI 3808, pp. 524–535, 2005. c Springer-Verlag Berlin Heidelberg 2005

Semantics and Pragmatics for Agent Communication

525

semantics and the pragmatics of the ACLs. Traditionally, the pragmatic level consist only of the definition of Interaction Protocols (IPs) to be applied in particular scenarios (e.g., auctions). These protocols merely dictate the order in which performatives are to be used, but they do not take into account the social consequences that the use of a particular performative may cause. We understand agent communication as an activity in which agents’ actions entail social consequences. However, unlike other social approaches ([19,10]) in which the semantics of the communicative actions are defined in terms of commitments, we understand that the social aspect of agent communication is a constituent of the pragmatics of the language. In our approach, the social consequences of sending a message are regulated by conversation policies (CPs) which help agents to both interpret and send an appropriate answer upon the reception of a message. For example, CPs may give the right to an agent to send a query, or obliging it to refuse a particular proposal. It is argued here that the concept of commitment is not sufficient to express all the social aspects involved in communicative interaction, but a more general framework of coordination is needed. Unlike other approaches based on the idea of institution ([11]), our right-based approach, while maintaining agents’ autonomy, can establish a mechanism of sanction. Besides, given its social nature, a rights-based ACL is public, so it is possible to determine whether an agent is acting according to the pragmatics of the language (conversation policies). In this paper we provide a set of normative notions such as right, permission, obligation, which are used to model agents’ social and communicative interactions within a normative framework. This enable us to define interaction protocols based on a meaningful set of messages. ACLs based on a semantics approach take only into account the isolated action of the utterance. They do not consider the sequences of interactions which are established in a conversation. Interaction protocols represent the conventions adopted by agents when exchanging messages. In particular, these conventions represent the legal sequence of messages that agents have to follow. It has been argued ([19]) that focusing only on the specification of protocols (e.g.,[12,4]) limit agents’ autonomy. It also transforms communication in a meaningless exchange of ordered tokens since agent’s behaviour is reduced to follow a predetermined conversational template. Conversely, we believe that interaction protocols should rely on a standard set of communicative actions which guarantees that the communication is meaningful. Besides, it should be possible to determine whether agents are behaving according to the specified protocol. Other approaches [8] take into account the meaning of the performatives, but they are not based on a standard ACL but on a set of ad hoc defined messages. In our approach, interaction protocols are defined on the basis of a previously defined set of communicative actions. The remainder of the paper is structured as follows: In the next section, we define the main components needed to define a complete standard ACL. In Section 3, a set of communicative actions (semantics) and their STRIPS-based semantics are provided. Section 4 formally specifies, using CTL with deontic operators, the normative notions (rights) needed to define a set of conversa-

526

R. Agerri and E. Alonso

tion policies (pragmatics). Besides, it shows, upon the social and communicative framework previously defined, how conversation policies and interaction protocols regulate the use of the semantics. Section 5 discusses other related work, and some conclusions are drawn.

2

ACL Framework

Agent Communication consists of agents exchanging messages which are wellformed formulae of a communication language Lc . By sending messages, agents perform speech acts or communicative actions. An illocution is the central component of a communicative action and it corresponds to what the action is intended to achieve. This goal should be distinguished from the effect that the communicative action is meant to produce on the receiver (perlocution), as well as from how the actual communication is physically carried out (locution). The perlocutionary effects of the communicative actions are difficult to specify. Since we deal with autonomous agents, it is not possible to guarantee the satisfaction of the perlocutionary action. ACL performatives can be classified in terms of their illocutionary point [18]. A well defined semantics is a central component of the ACL specification. However, most of the ACLs proposed so far lack of a pragmatic level in which properly regulate the use of the semantics. Traditionally, ACL specifications would just consist of a set of communicative actions, and several interactions protocols would then separately define conversational templates for specific scenarios (e.g., auctions). The commitment-based protocols include the social component in order to facilitate verification [22], but they fail to capture the general intuition about communication, namely, that agents perform speech acts in order to achieve a certain goal(s). Conversely, our approach places the social aspect of communication at the pragmatic level, maintaining the illocutionary aspect as a central feature of the semantics (communicative actions). The pragmatics of an ACL can be represented by conversation policies, which take into account the social effects of performing a communicative action and thereby facilitate the achievement of perlocutionary effects. In other words, CPs guide and constrain the use of the performatives. The concept of right plays a central role in the definition of CPs, allowing us to express the social consequences of performing a particular communicative action. Other approaches (notably [17]), simply consider the perlocutionary component of communication which is embedded in the semantics of the language (they do not consider a separate pragmatic component). We believe that this consequentialist approach does not allow to decide whether or not the satisfaction of the perlocutionary action is intentional, which means that it is not possible to assign responsibility, sanctions, etc., in a normative system. In our view, an ACL should include both social and mental aspects of communication. Thus, a complete ACL will be composed by the set of communicative actions, that is, the language Lc expressing the semantic meaning of the primitives; a set CPs restricting its use, Lr , and the semantic languages Ls and Lp


527

for Lc and Lr respectively (our framework builds on [22]). Note that IPs would also be defined using Lr . In short, the set of communicative actions defined by Lc represent the semantics of the ACL, whereas the set of policies defined by Lr represent the pragmatics. The semantics encode the illocutionary character of communication between autonomous agents. The pragmatic level takes into account the use of the semantics and the social consequences its use entail. Thus, an ACL is the tuple: ACL = Lc , Ls , Lr , Lp The communication language Lc is based on a STRIPS-like language with preconditions and effects. The preconditions establish the conditions to be true for the agent to send a message (including the goal the sender intends to achieve by sending that message). On the other hand, the effects state the sender wants to cause by performing the communicative action. As it has been already discussed, autonomous agents, by definition, cannot be forced to guarantee the effects. The semantics of Lc are given by a function −c : wff (Lc ) → wff (Ls ) The language Ls is based on Computation Tree Logic (CTL) extended with operators for Beliefs, Goals and Intentions. Using a type of temporal logic would facilitate to relate the language Ls to a computational model and, as a consequence, its verification [22]. The aim of this paper is not to discuss the specifics of the computational model, although it could be based on the work by Manna and Pnueli [14]. Besides, by introducing operators to express mental states it is possible to capture the goal-based character of communication. Mental states are not understood in this paper as private mental states of the agents; as in theory of planning, goals represent states of the world which are desirable for the agents. Regarding intentions, when an agent expresses the intention to execute an action, it is expressing publicly its willingness to perform such an action. Intentions refer to the actions that the agent is committed to perform in order to achieve one or more goals. Besides, holding an intention to execute an action presupposes the ability to perform it. This approach differs from others (e.g. Cohen and Levesque [3]) that use both concepts interchangeably. CTL extended with deontic operators for Rights and Obligations is used to define the language Lp . Using CTL as the core of both semantic languages will facilitate the verification of the ACL. The semantics of the pragmatic language Lr are given by a function: −r : wff (Lr ) → wff (Lp ) The definition of a pragmatic language is beyond the scope of this paper, but we believe that the role can be filled by a declarative language like prolog. An interesting lead would be to investigate whether these CPs could be imported as reasoning rules in an programming environment for cognitive agents like 3APL [5]. In the following section we will present the logic that will be used to specify the communicative actions of the ACL.

528

3


Communicative Actions

CTL is a type of branching temporal logic which describes properties of a computation tree [7]. Temporal model checking using CTL is one of the most used techniques for verifying properties of state-transition systems. Although it is not the purpose of this paper to develop a verification method for ACLs, by using an extension of CTL to define the semantics of the ACL we are indirectly choosing the computational model for the verification. The language presented here, Ls , extends CTL by adding modal operators for beliefs, goals and intentions. The main difference with other extensions (e.g. [16] [19]) is the use of a Goal operator which cannot conflict with beliefs, that is, we distinguish between goals and desires. Besides, we consider that the objects of goals are states (φ) whereas the objects of intentions are actions (α). Definition 1. (Syntax) Language L consists of two classes, state and path formulae. Consider n agents. C1 C2 C3 C4 P0

If If If If If

φ is an atomic proposition of AP then φ is a state formula. φ and ψ are state formulae, then so are ¬φ and φ ∧ ψ. ϕ is a path formula and then Eϕ and Aϕ are state formulae. φ is a state formula then Bi (φ), Gi (φ), Ii (φ) are also state formulae. φ and ψ are state formulae, then Xφ and φU ψ are path formulae.

The boolean operators are standard; E and A are quantifiers over paths, meaning “there exists an execution” and “for all executions” respectively; φ U ψ means that ψ does eventually hold and that φ will hold everywhere until ψ holds. The rest of the formulae can be introduced as abbreviations: EF φ for E true U φ; AF φ for A true U φ; EGφ for ¬(A true U ¬φ); finally, AGφ abbreviates for ¬(E true U ¬φ). Beliefs are represented by a KD45 axiomatization relative to each agent. For goals and intentions, we assume a minimal KD axiomatization to ensure consistency. Definition 2. (Kripke Structure) A structure is a tuple M = S, R, L, T, A, B, G, I, where – S is a set of states, – R is a total binary relation ⊆ S × S, ∀s ∈ Ss.t.(s, t, ) ∈ R, – L : S → P owerSet(Φ) is an interpretation L : S → 2Φ where Φ is a set of atomic propositions, – T : S → P gives the real path conveyed by a state, where P is the set of paths derived from L; P P gives the powerset of P . – A is a set of agents, – B : S × A → S gives the accessibility relation for beliefs, – and G : S × A → P P and I : S × A → P P an interpretation for goals and intentions respectively. For a Kripke structure M and a state s0 , we write M, s0 |= φ, for a state formula φ. For a structure M and a full path χ, we say that M, χ |= φ for a path formula φ.


529

Definition 3. (Semantics) C1 M, s0 |= φ iff φ ∈ L(s0 ), for φ ∈ AP C2 M, s0 |= φ ∧ ψ iff M, s0 |= φ and M, s0 |= ψ M, s0 |= ¬φ iff it is not the case that M, s0 |= φ C3 M, s0 |= Eφ iff ∃ a full path χ = (s0 , s1 , s2 , . . .) in M and M, χ |= φ M, s0 |= Aφ iff ∀ full paths χ = (s0 , s1 , s2 , . . .) in M , and M, χ |= φ C4 M, s0 |= Bi (φ) iff ∀s1 : s1 ∈ B(i, s0 ) ⇒ M, s1 |= φ M, s0 |= Gi (φ) iff ∀χ : χ ∈ G(i, s0 ) ⇒ M, χ |= φ M, s0 |= Ii (φ) iff ∀χ : χ ∈ I(i, s0 ) ⇒ M, χ |= φ P0 M, χ |= φU ψ iff ∃i, M, si |= ψ and ∀j < i, M, sj |= φ M, χ |= Xφ iff M, s1 |= φ We can use now the semantic language Ls to express the meaning of the relevant classes of communicative actions. Following Searle’s taxonomy [18], we classify actions into assertives, commissives, directives, declarations and expressives. The last category is not relevant for the purposes of this paper, so it will not be included. The syntax of Lc is based on the FIPA ACL. Table 1 presents a performative for each of the remaining four types of categories, plus two more (agree and refuse) which will be used later to characterized the request interaction protocol. The two performatives at the top, inform and request, represent the assertives and directives respectively. Agree and refuse are included as possible exchanges after the reception of a request. Declare is an action of the declarative class and promise is a commissive. Table 1. A complete set of performatives i, inf orm(j, φ) F P : Bi (φ) ∧ Gi (Bj (φ)) RE : Bj φ i, agree(j, α) i, inf orm(j, Ii F α) F P : Ii F α RE : Bj (Ii F α) i, promise(j, α) F P : Ii F α RE : F α

i, request(j, α) F P : Gi (Ij (F α)) RE : EF α i, ref use(j, α) i, inf orm(j, ¬Ii F α) F P : ¬Ii F α RE : Bj (¬Ii F α) i, declare(j, φ) F P : Gi (φ) RE : φ

When sending an inform message, the sender expresses its belief that some proposition is true. The first part of the FPs requires the sender to believe φ which means that we want the sender to be sincere. This is a good assumption by default, but if we want agents to be able to negotiate in competitive scenarios they may need to deceive. We believe that a feasible solution is to specify another speech act convince that could be used when an agent just aims that other agent believes a proposition φ, irrespective of the beliefs of the sender.

530


The are two classes of directives: Questions and requests. Both types share the basic feature of the sender holding a goal which can be achieved by the receiver performing a specific action. The goal of questions is to elicit some proposition from the receiver, which involves the receiver performing an answer. Requests have the goal of getting the receiver to perform some action. If the receiver accepts the request, it will expresses the intention to execute the action requested. Having the intention of executing an action means that the agent will execute that action in order to achieve a specific goal. Note that by agreeing, the agent actually informs the receiver that it intends to perform a requested action. Conversely, if the receiver rejects the request, it will inform about its intention not to comply with it. The use of precommitments [10] to analyze requests fails, in our view, to express that the sender explicitly states its interest of having the receiver executing a particular action. Commissives commit the sender to perform the action uttered by the message. That is, once sent, the sender states its intention to perform the action. Declarations have immediate effects in an extra-linguistic institution. Declaratives are the original performative verbs [2]. Declarations are particularly useful for institutional actions. For example, performatives to start or terminate an interaction are declaratives. In that kind of situations, it is necessary to identify which agents are allowed to perform a specific declaration. Usually, agents has a right or a permission to perform a communicative action depending on its role in the particular scenario. In an auction, for instance, the auctioneer has the right to exercise an action: declaring the beginning of an auction. An agent wishing to participate should be given the permission (by the auctioneer) to do so. An agent may perform an action for which it has not the right to. In the next section, we introduce the language Lp which define the notions of rights and permissions in which the conversation policies (pragmatics) are based.

4

Pragmatics

Interaction protocols (IPs) define the sequences in which communicative actions can be performed, so agents can engage in a meaningful conversation. We believe that IPs can be modelled as the right agents have to use a performative based on the previous speech acts performed. Thus, IPs provide the set of performatives that can be used at a given time. IPs are in turn constrained by the pragmatics of the language specified as a set of CPs. In open environments, agents work on behalf of the particular interest of their designers. Because agents are designed by different vendors, they present different internal structures. Therefore, to guarantee that interactions between agents are successful, agents need to behave according to their role within a normative system. This does not mean that we adopt an institutional approach in which agents must follow the rules imposed by a set of norms defined by the institution. In general, if an agent has the right to execute a set of actions, then: (i) it is permitted to perform it (under certain obligations); (ii) the rest of the agents


531

are not allowed to perform any action that inhibits the right-holder’s action, and (iii), the rest of agents, the group, has the obligation to prevent or sanction any inhibitory action. The function of rights for agent communication is to stabilize social interactions, by making the behaviour of agents predictable to the other agents of the system. Permissions are usually defined as the dual of obligation, meaning that an agent that is not obliged not to do α is permitted to do α. Rights are not simply the absence of obligations. For an agent to have the right to execute α, is must be given permission to do so. Not being obliged not do to α it does not mean that the agent has the right to do α. The formal specification of the normative language, Lp , which defines rights, obligations and permissions, is based on the semantic language Ls presented in the previous section. Thus, for the language Lp , we extend CTL using normative notions, and we add a deontic accessibility relation. The syntax is given the following BNF expression: ϕ := φ|¬ϕ|ϕ1 ∧ ϕ2 |Gi ϕ|Oi ϕ|Eϕ|Aϕ|Xϕ|ϕ1 U ϕ2 Where Oi φ means that agent i has the obligation to bring about φ. The rest of the notions, such as permissions, are defined as abbreviations. The axiomatization of obligation is given by the system KD. We add a deontic accessibility relation O, O : 2A → 2S×S . Thus, the semantics of Lp are inherited from Ls except C4 which is substituted by: M, s0 |= Oi φ iff ∀s1 such that s0 Os1 we have M, s1 |= φ In order to define the notion of right, we need to introduce first the concept of violation. Rights are considered here exceptions of obligations [20], that is, rights are different from permissions. An agent has right to do α under some condition φ if, when the agent that gives the right believes that φ holds, it has the goal not to believe α as a violation (¬V (α)). From each literal built from a variable α, V ∈ N , V (α) means that agent N determines that α is a violation. Definition 4. (Right) Let N S be a set of norms {n1 , . . . , nm }, and let the variables of agent N contain a set of violation variables V = {V (α) such that α ∈ AP } Agent i believes that it has the right given by agent N to do α, under situation φ, φ ∈ S iff for some n ∈ NS 1. φ ∧ α → ¬V (α) ∈ GN IPs aim to constrain the interaction to facilitate the desired outcomes; for example, that the highest bidder is found in an auction. Besides, CPs make coordination easier since they assign permissions and obligations on the participants, and specify which communicative actions are appropriate at certain states. The agent playing the role of auctioneer establishes the rights and permissions of the participants. The conformity of the participants to the protocol is based on the meaning of the performatives used.

532


The language Lp provides the set of normative notions needed to specify CPs for agent communication (Lr ). Using a declarative language to express the CPs is inspired by work related to 3APL [5], and within the Semantic Web framework [13]. A policy consists of the following components: communicative actions, domain actions, normative rules and facilitator actions. The first component is given by Lc and the second is defined by Lp ; the kind of domain actions agents can perform will depend on the abilities agents have; like the communicative actions, domain actions are expressed in terms of goals, preconditions and effects. action(Agent, Goal, P recondition, Ef f ect) Facilitator actions depend on the platform in which agents run. That is, facilitator actions are defined by the programming language in which agents are built. For example, in Java built platform like JADE, sending messages is simply a case of creating an ACLMessage, setting the parameters (sender, receiver, reply-to, performative, etc.) and then sending it using the send() method in the agent object. Normative rules consist of a deontic operator (obligations, rights) and a condition that has to be true so the rule is applicable: right(X, request(X, Y, Condition) Agents hold the right to do α as long as α does not constitute a violation. An obligation rule states that an agent must perform an action before its applicability condition becomes false; a permission rule establishes that the agent can perform an action α if its condition(s) is true. We can now use the language Lr whose semantics are specified by Lp to model IPs of FIPA ACL in terms of the rights of the agents to use the performatives. In the request interaction protocol, an agent X request agent Y to perform an action A. The receiver has the right to either agree or refuse the request. In the case that agent Y agrees, then it has obligation to send a notification which can be: (i) a failure message, i.e., the action A could not be executed, (ii) an inform stating that the action has been performed, and (iii) informing of the result of executing A. right(X, request(X, Y, A), _). right(Y, agree(Y, X, A)); right(Y, refuse(Y,X,A)) :receive(request(X,Y,A). obligation(Y, inform (Y, X, A)); obligation(Y, failure(Y, X, A)) :send(agree(Y, X, A), _). Policies can then be defined to constrain the agents’ use of the performatives in virtue of their content. For example, agent Y , acting on behalf of a airline


533

company serving flights to European countries, could have a CP that state that it should agree to every request regarding flight tickets to Europe (i.e., searching a suitable ticket and providing the best offer for a potential buyer) and another one specifying that it has the obligation to refuse every request about flights to non European countries. obligation(Y, agree(Y, X, A) :receive(request(X, Y, A)), europeanFlight(A)). obligation(Y, refuse(Y, X, A) :receive(request(X, Y, A), nonEuropeanFlight(A)). Other CPs can be defined to state that an agent can deceive, or that it has the right to do so in particular circumstances. It can be specified that an agent X will always answer to every message it receives, for example. There are two interesting leads of our proposal: first, we need to work on its application in a development platform for cognitive agents such as 3APL [6]. In this programming environment, prolog programs can be part of the belief base, which contain general rules to be applied for some problem domain. The second lead is to extend our current formalism with other organizational concepts such as roles and group, and a formal definition of sanction. Agents playing roles in specific scenarios will allow the specification of more accurate CPs, since the role an agent is playing will add further conditions to its behaviour. Thus, the previous example can be enriched by adding that agent Y is seller and X is a customer.

5

Concluding Remarks

Our proposal presents two semantic languages based on CTL that give the semantics for the communicative actions and conversational policies of the ACL. We believe that using a temporal logic traditionally used for model-checking verification would facilitate the compliance testing of our ACL. Although trying to overcome some of its problems, the ACL specification proposed here intends to be as close as possible to the FIPA ACL specification. Thus, we propose new communicative actions with the aim of improving the current FIPA Communicative Actions Library (CAL). With this purpose, we provide definitions for the actions absent in the FIPA CAL: commissives and declaratives. We understand that, in the FIPA CAL some of the definitions are unnecessarily complex. This is partially due to the multimodal language used as semantic language. Besides, it is not a language that can be grounded in a computational model as CTL does. Besides, our approach analyzes agent communication in terms of the social consequences of executing an action. In this sense, our ACL is public, since it is possible to establish whether an agent is acting according to the pragmatics of the language. The idea of using rights to constrain agent’s communicative

534


behaviour is inspired by [15] and [1]. Our proposal is also related to [13], but here we present a complete semantics for the deontic operators. We have shown with an example, how our proposal can be used to define IPs using a declarative language. In so doing, the right-based ACL is not confined to a meaningless sequential exchange of tokens. Future work will involve extending such protocol to cover other patterns of conversations, which include concurrent interactions. Moreover, we want to consider sanctions mechanisms to punish violations. We believe that van der Torre et al’s approach [21] provides an interesting lead for this purpose.

References 1. Alonso, E.: Rights and argumentation in open multi-agent systems. Artificial Intelligence Review 21 (2004) 3–24 2. Austin, J.L.: How to do Things with Words. Oxford University Press, Oxford (1962) 3. Cohen, P., Levesque, H.: Intention is Choice with Commitment. Artificial Intelligence 42 (1990) 213–261 4. Cost, R.S., Chen, Y., Finin, T., Labrou, Y., Peng, Y.: Modeling agent conversations with colored petri nets. In: Workshop on Specifying and Implementing Conversation Policies, Third International Conference on Autonomous Agents (Agents ’99), Seattle (1999) 5. Dastani, M., van der Ham, J., Dignum, F.: Communication for goal directed agents. In Huget, M.P., ed.: Communication in Multiagent Systems - Agent Communication Languages and Conversation Policies. Springer-Verlag (LNCS 2003) 239–252 6. Dastani, M., Riemsdijk, M., Dignum, F., Meyer, J.J.: A programming language for cognitive agents: Goal-directed 3apl. In Dastani, M., Dix, J., Fallah-Seghrouchni, A.E., eds.: Programming Multi-Agent Systems (LNAI 3037). Springer-Verlag, Berlin (2004) 111–130 7. Emerson, E.A.: Temporal and modal logic. In van Leeuwen, J., ed.: Handbook of Theoretical Computer Science, volume B. North Holland, Amsterdam (1990) 995–1072 8. Esteva, M., Rodriguez, J.A., Sierra, C., Garcia, P., Arcos, J.L.: On the formal specification of electronic institutions. In Dignum, F., Sierra, C., eds.: Agentmediated Electronic Commerce (The European AgentLink Perspective). Volume volume 1191 of LNAI. Springer, Berlin (2001) 126–147 9. FIPA ACL: FIPA Communicative Act Library Specification (2002) http://www.fipa.org/repository/aclspecs.html. 10. Fornara, N., Colombetti, M.: A commitment-based approach to agent communication. Applied Artificial Intelligence 18 (2004) 853–866 11. Fornara, N., Vigano, F., Colombetti, M.: Agent communication and institutional reality. In: AAMAS 2004 Workshop on Agent Communication (AC2004), New York (2004) 12. Greaves, M., Holmback, H., Bradshaw, J.: What is a Conversation Policy? In Dignum, F., Greaves, M., eds.: Issues in Agent Communication. Heidelberg, Germany: Springer-Verlag (2000) 118–131 13. Kagal, L., Finin, T., Joshi, A.: A policy language for a pervasive computing environment. In: IEEE 4th International Workshop on Policies for Distributed Systems and Networks. (2003)


535

14. Manna, Z., Pnueli, A.: The Temporal Logic of Reactive and Concurrent Systems. Springer-Verlag, Berlin, Germany (1995) 15. Norman, T.J., Sierra, C., Jennings, N.R.: Rights and commitment in multi-agent agreements. In: Proceedings of the Third International Conference on Multi-Agent Systems. (1998) 222–229 16. Rao, A., Georgeff, M.: Modeling rational agents within a BDI-architecture. In Allen, J., Fikes, R., Sandewall, E., eds.: 2nd International Conference on Principles of Knowledge Representation and Reasoning (KR’91), Morgan Kaufmann Publishers (1991) 473–484 17. Rovatsos, M., Nickles M., Weiss G.: Interaction is Meaning: A new Model for Communication in Open Systems. In Proceedings of the Second International Joint Conference on Autonomous Agents and Multi-Agent Systems (AAMAS-03), Melbourne, Australia, (2003) 18. Searle, J.R.: Speech Acts. An Essay in the Philosophy of Language. Cambridge: Cambridge University Press (1969) 19. Singh, M.P.: A social semantics for agent communication languages. In: Issues in Agent Communication, volume 1916 of LNAI. Berlin: Springer-Verlag (2000) 20. van der Torre, L.: Contextual deontic logic: Normative agents, violations and independence. Ann. Math. Artif. Intell. 37 (2003) 33–63 21. van der Torre, L., Hulstijn, J., Dastani, M., Broersen, J.: Specifying multiagent organizations. In: Proceedings of the Seventh Workshop on Deontic Logic in Computer Science (Deon’2004), LNAI 3065. Springer (2004) 243–257 22. Wooldridge, M.: Semantic issues in the verification of agent communication languages. Journal of Autonomous Agents and Multi-Agent Systems 3 (2000) 9–31