-
Many researchers claim that an e ective way to approach the design and
development of a MAS consists in conceiving it as a structure composed of four main
entities: Agents, Environment, Interactions, and Organization [
32,18,19
]. Such a
separation of concerns enjoys many advantages from a software engineering point
of view, since it enables a modular development of code that eases code reuse and
maintainability. Currently, there are many frameworks that support designers
and programmers in realizing one of these components (e.g., [
8,10,25,11,29
]). To
the best of our knowledge, JaCaMo [
9
] is the the most complete among the
wellestablished proposals, providing a thorough integration of the three components
agents, environments, and organizations into a single programming framework.
Another work along this direction is [
7
], which posits that agents and
environments should be linked and interconnected through standard interfaces to fully
leverage each of them.
A recent extension to JaCaMo [
32
] further enriches the framework by
introducing an interaction component. The interaction component allows regulating
both agent interactions and the interactions between agents and environment.
More precisely, an interaction component encodes {in an automaton-like shape{
a protocol, in which states represent protocol steps, and transitions between
states are associated with (undirected) obligations that can assume three forms:
actions performed by the agents in the environment, messages that an agent
sends to another agent, and events that an agent can perceive (i.e., events
emitted from objects in the environment). Such protocols provide a guideline of how
a given organizational goal should be achieved.
Interaction components, as de ned in [
32
], however, present also some
drawbacks. Works such as [
15
] show the importance, for the agents to be autonomous,
to reason about the social consequences of their actions by exploiting constitutive
norms that link the agents' actions to their respective social meanings. However,
an interaction component operates as a coordinator that, by relying on
obligations, issues commands about what an agent has to do, and when. This impedes
agents from reasoning on the normative e ects of their actions. On the one hand,
the obligations are not constitutive norms while, on the other hand, the social
meaning of such commands is not known to the agents but only implicitly
encoded within the protocol. Agents lose part of their deliberative power since,
once they join an interaction component, they have no other choice but
deciding whether satisfying or not those obligations they are in charge of, while the
rationale behind these obligations remains hidden to them. Consequently, this
approach does not suit those situations where interaction is not subject to an
organizational guideline, such as in the case when interaction is among agents
and each agent decides what is best for itself [
31
], or when guidelines amount
to declarative, underspeci ed constraints that still leave agents the freedom to
take strategic decisions on their behavior.
Although we substantially agree with [
32
] about the importance of explicitly
capturing the agents' interactions with appropriate abstractions, we also note
that organization-driven guidelines, presented in that work, are but a kind of
interaction; we thus propose a complementary approach which better supports
the deliberative capabilities of the agents. Indeed, when organizational goals are
not associated with corresponding guidelines, agent deliberation is crucial for the
achievement of goals. An agent, in fact, has to act not only upon its own goals,
but also upon what interactions could be necessary for achieving these goals. In
other terms, an agent has to discover how to obtain a goal by interacting with
others, i.e. to establish when to create an engagement, and which (sub)goals
should be achieved rst in order to ful ll its engagements. It is important to
underline that when agents can fully exploit their deliberative capabilities, they
can take advantage of opportunities ( exibility ), and can nd alternative ways
to get their goals despite unexpected situations that may arise (robustness).
We claim that whenever guidelines are missing, the interactions among the
agents should be supported by the very fundamental notions of goal and
engagement. For this reason, we propose in this paper to complement the interaction
protocol in [
32
], and more in general organizational and normative approaches
[
17,20,23,16
], with an interaction artifact that can be used by the agents as a
common ground. Our interaction artifacts encode the notion of engagement as
social commitment [
26
]. The choice of commitments stems by the fact that,
differently from obligations, commitments are taken by an agent as a result of an
internal deliberative process. They can be directly manipulated by the agents,
and they have proved to be very e ective in modeling (directed) social
relationships. In addition, a recent work by Telang et al. [
28
] shows how goals and
commitments are strongly interrelated. Commitments are therefore evidence of
the capacity of an agent to take responsibilities autonomously. Citing Singh [
27
],
an agent would become a debtor of a commitment based on the agent's own
communications: either by directly saying something or having another agent
communicate something in conjunction with a prior communication of the debtor.
That is, there is a causal path from the establishment of a commitment to prior
communications by the debtor of that commitment. By contrast, obligations can
result from a deliberative process which is outside the agent; this is the case of
the interaction component in [
32
]. This is the reason why we believe that the
introduction of a deliberative process on constitutive rules that rely on obligations
would not really support the agents' autonomy.
Practically, the proposal relies on the JaCaMo platform [
9
], and hence we
dubbed it JaCaMo+: Jason agents engage commitment-based interactions which
are rei ed as CArtAgO artifacts. CArtAgO is a framework based on the A&A
meta-model [
30,24
] which extends the agent programming paradigm with the
rst-class entity of artifact: a resource that an agent can use, and that models
working environments. It provides a way to de ne and organize workspaces,
that are logical groups of artifacts, that can be joined by agents at runtime. The
environment is itself programmable and encapsulates services and functionalities,
making it active. JaCaMo+ artifacts represent the interaction social state and
provide the roles agents enact. The use of artifacts enables the implementation
of monitoring functionalities for verifying that the on-going interactions respect
the commitments and for detecting violations and violators.
The paper extends and details the approach introduced in [
3
], and is
organized as follows. Section 2 introduces some basic notions about goals and
commitments. Section 3 discusses the extensions to JaCaMo that have been
introduced in JaCaMo+; Section 4 shows, by exemplifying the FIPA Contract
Net Protocol, how agents can be programmed by means of patterns encoding
the interplay between goals and commitments.
2
Basic Notions
A social commitment models the directed relation between two agents: a debtor
and a creditor, that are both aware of the existence of such a relation and of its
current state: A commitment C(x; y; s; u) captures that agent x (debtor)
commits to agent y (creditor) to bring about the consequent condition u when the
antecedent condition s holds. Antecedent and consequent conditions are
conjunctions or disjunctions of events and commitments. Unlike obligations,
commitments are manipulated by agents through the standard operations create,
cancel, release, discharge, assign, delegate [
26
]. A commitment is autonomously
taken by a debtor towards a creditor on its own initiative, instead of dropping
from an organization, like obligations. This preserves the autonomy of the agents
and is fundamental to harmonize deliberation with goal achievement. The agent
does not just react to some obligations, but it rather includes a deliberative
capacity by which it creates engagements towards other agents while it is
trying to achieve its goals (or to the aim of achieving its goals). Since debtors are
expected to satisfy their engagements, commitments satisfy the requirement in
[
14
] of having a normative value, providing social expectations on the agents'
behaviors, as well as obligations. Commitments also satisfy the requirement in
[
17
] that when parties are autonomous, social relationships cannot but concern
the observable behavior of the agents themselves.
Commitment-based protocols assume that a (notional) social state is
available and inspectable by all the involved agents. The social state traces which
commitments currently exist between any two agents, and the states of these
commitments according to the commitments lifecycle. By relying on the social
state, an agent can deliberate to create further commitments, or to bring about
a condition involved in some existing commitment. Most importantly,
commitments can be used by agents in their practical reasoning together with beliefs,
intentions, and goals. In particular, Telang et al. [
28
] point out that goals and
commitments are one another complementary: A commitment speci es how an
agent relates to another one, and hence describes what an agent is willing to
bring about for another agent. On the other hand, a goal denotes an agent's
proattitude towards some condition; that is, a state of the world that the agent
should achieve. An agent can create a commitment towards another agent to
achieve one of its goals; but at the same time, an agent determines the goals to
be pursued relying on the commitments it has towards others: A commitment is
satis ed when the related goal is achieved. Note that, similarly to commitments,
goals have their own lifecycle that evolves according to the actions performed
by the agents (leading to the achievement or unful llment of goals), but also to
the decisions of the agents to purse, suspend, or drop the goals themselves.
In [
28
], a goal G is formalized as G(x; p; r; q; s; f ), where x is the agent
pursuing G, p is a precondition that must be satis ed before G can become
Active, r is an invariant condition that is true when G becomes Active and
holds until the achievement of G, q is a post-condition (e ect) that becomes
true when G is successfully achieved, and nally, s and f are the success and
failure conditions, respectively. In the following sections we will show how such a
formalization can be mapped into Jason plans, and how it turns out to be useful
for the agent programming purpose.
3
JaCaMo+
JaCaMo [
9
] is a platform integrating Jason (as an agent programming language),
CArtAgO (as a realization of the A&A meta-model [
30
]), and Moise (as a
support to the realization of organizations). In this section we shortly describe how
JaCaMo+ is obtained by extending the CArtAgO and Jason components of the
standard JaCaMo.
3.1
Extending CArtAgO
Exploiting [
1
], JaCaMo+ enriches CArtAgO's artifacts with an explicit
representation of commitments and of commitment-based protocols. The resulting
class of artifacts rei es the execution of commitment-based protocols, including
the social state of the interaction, and enables Jason agents both to be noti ed
about the social events and to perform practical reasoning also about the other
agents. This is possible thanks to the social expectations raised by commitments.
Since an artifact is a programmable, active entity, it can act as a monitor of the
in progress interaction. The artifact can therefore detect violations that it can
ascribe to the violator without the need of agent introspection.
Speci cally, a JaCaMo+ artifact encodes a commitment protocol, that is
structured into a set of roles. By enacting a role, an agent gains the rights to
perform social actions, whose execution has public social consequences, expressed
in terms of commitments. If an agent tries to perform an action which is not
associated with the role it is enacting, the artifact raises an exception that is
noti ed to the violator. On the other hand, when an agent performs a protocol
action that pertains to its role, the social state is updated accordingly by adding
new commitments, or by modifying the state of existing commitments.
In CArtAgO, the Java annotation1 @OPERATION marks a public
operation that agents can invoke on the artifact. In JaCaMo+, a method tagged
with @OPERATION corresponds to a protocol action. We also add the
annotation @ROLE to specify which roles are enabled to use that particular action.
Another extension is an explicit representation of the social state, which is
maintained within the artifact. By focusing on an artifact, an agent registers to be
noti ed of events that are generated inside the artifact. Note that all events
that amount to the execution of protocol actions/messages are recorded as facts
in the social state. This is done for the sake of a greater degree of decoupling
between actions/events/messages and their e ects [
5,6
]. In particular, when the
social state is updated, the JaCaMo+ artifact provides such information to the
focusing JaCaMo+ agents by exploiting proper observable properties. Agents are,
thus, constantly aligned with the social state.
3.2
Extending Jason
Jason [
10
] implements in Java, and extends, the agent programming language
AgentSpeak(L). Jason agents have a BDI architecture. Each has a belief base,
and a plan library. It is possible to specify achievement (operator `!') and test
(operator `?') goals. Each plan has a triggering event (causing its activation),
1 Annotations, a form of metadata, provide data about a program that is not
part of the program itself. See https://docs.oracle.com/javase/tutorial/java/
annotations/
which can be either the addition or the deletion of some belief or goal. The syntax
is inherently declarative. In JaCaMo, the beliefs of Jason agents can also change
due to operations performed by other agents on the CArtAgO environment,
whose consequences are automatically propagated. We extend the Jason
component of JaCaMo by allowing the speci cation of plans whose triggering events
involve commitments. JaCaMo+ represents a commitment as a term cc(debtor,
creditor, antecedent, consequent, status) where debtor and creditor identify
the involved agents (or agent roles), while antecedent and consequent are the
commitment conditions. Status is the commitment state (the set being de ned
in the commitments life cycle [
21
]). Commitments operations (e.g. create, see
Section 2) are realized as internal operations of the new class of artifacts we
added to CArtAgO. Thus, commitment operations cannot be invoked directly
by the agents, but the protocol actions will use them as primitives to modify the
social state.
A Jason plan is speci ed as:
triggering event : hcontexti
hbodyi
where the triggering event denotes the events the plan handles, the context
speci es the circumstances when the plan could be used, the body is the course of
action that should be taken. In a Jason plan speci cation, commitments can be
used wherever beliefs can be used. Otherwise than beliefs, their
assertion/deletion can only occur through the artifact, in consequence to a social state change.
The following template shows a Jason plan triggered by the addition of a
commitment in the social state:
+cc(debtor; creditor; antecedent; consequent; status) : hcontexti
hbodyi.
More precisely, the plan is triggered when a commitment, that uni es with the
one in the plan head, appears in the social state. The syntax is the standard for
Jason plans. Debtor and creditor are to be substituted by the proper roles. The
plan may be devised so as to change the commitment status (e.g. the debtor will
try to satisfy the comment), or it may be devised so as to allow the agent to react
to the commitment presence (e.g., collecting information). Similar schemas can
be used for commitment deletion and for the addition/deletion of social facts.
Further, commitments can also be used in contexts and in plans as test goals
(?cc(: : : )), or achievement goals (!cc(: : : )). Addition or deletion of such goals
can, as well, be managed by plans; for example:
+!cc(debtor; creditor; antecedent; consequent; status) : hcontexti
hbodyi.
The plan is triggered when the agent creates an achievement goal concerning a
commitment. Consequently, the agent will act upon the artifact so as to create
the desired social relationship. After the execution of the plan, the commitment
cc(debtor; creditor; antecedent; consequent; status) will hold in the social state,
and will be projected onto the belief bases of all agents focusing on the artifact.
Programming in JaCaMo+
In this section we show how Jason agents can be easily programmed by
considering a commitment-based protocol as a guideline for the programmer: We rst
present a programming approach which exploits the practical rules by Telang
et al. [
28
], and then we exemplify the approach implementing the initiator and
participant agents of the well-known Contract-Net Protocol (CNP).
4.1
Practical Rules as Programming Code-Blocks
For both goals and commitments, [
28
] de nes lifecycles, and operations through
which the state of a goal, or a commitment, evolves over time. The relationship
between goals and commitments is formalized in terms of practical rules, which
capture patterns of pragmatic reasoning. They include: (1) rules from goals to
commitments to capture how commitments evolve when the state of some goals
change; and (2) rules from commitments to goals to capture how a goal evolves
when the corresponding commitment changes in the social state. These rules
can be easily encoded in JaCaMo+, and used by a programmer as templates for
implementing Jason agents. In the following we discuss four examples of rules
that will be used in the CNP scenario.
Goal rules. This JaCaMo+ template tackles the case when a goal G =
G(x; p; r; q; s; f ) appears in the knowledge base of agent x; namely, x wants to
achieve the success condition s, and hence an appropriate plan is triggered:
1 +!G : p
2 < ?r
3 hbodyi /* plan a c h i e v i n g c o n d i t i o n s*/
4 ?q .
Di erently from [
28
], in JaCaMo+ we explicitly mention a plan of actions (the
body) to achieve the success condition s. When x can satisfy G autonomously
(no interaction is needed), conditions s and q coincide. Instead, when x cannot
satisfy G (or it is not convenient for x to achieve G autonomously), the body will
involve an interaction with another agent and, as we will see, conditions q and
s will di er. Note that, in JaCaMo+ we can also specify a plan to be triggered
when the failure condition is reached:
1 !G : f
2 <
3
hbodyi . /* plan handling f a i l u r e c o n d i t i o n f */
The following three templates re ect namesake rules in [
28
].
Entice. Agent x can achieve G with the help of agent y: x creates an o er
to agent y such that, if y brings about s (success condition of G), then x will
engage into achieving a condition u of interest for y. Such an o er is naturally
modeled as the commitment C(x; y; s; u). The JaCaMo+ template is:
1 +!G : p
2 < ?r
3 s o c i a l a c t i o n ;
4 ?cc(x; y; s; u; CONDIT IONAL) .
The body of the rule consists of a social action; namely, a protocol action o ered
by the artifact x is focused on, and whose meaning is the creation of a
commitment C = cc(x; y; s; u; CON DIT ION AL). This commitment will push agent y
to bring about the success condition s associated with G, thus this is a special
case of goal activation. Note that the post condition of this rule corresponds to
a test on the existence of the commitment C; agent x can verify, by inspecting
the social state, that the commitment really exists.
Deliver. If commitment C(x; y; s; u) becomes detached, then debtor x
activates a goal G1 = G(x; p; r; q; u; f ) to bring about the consequent. In JaCaMo+:
1 +cc(x; y; s; u; DET ACHED) : c o n t e x t
2 < !G1 ;
3 ?cc(x; y; s; u; SAT ISF IED) .
It is worth noting the test goal at the end of the rule: It allows x to verify that
after the achievement of G1, its corresponding commitment is now satis ed.
Detach. When a conditional commitment C1(y; x; s0; t), appears in the social
state, the creditor x activates a goal G2 = G(x; p0; r0; q0; s0; f 0) to bring about
the commitment antecedent. The JaCaMo+ template is:
1 +cc(y; x; s0; t; CONDIT IONAL) : c o n t e x t
2 < !G2 ;
3 ?cc(y; x; s0; t; DET ACHED) .
Note that, as in the previous case, agent x can verify that, after the satisfaction
of goal G2, the corresponding commitment is now detached.
4.2
JaCaMo+ Contract Net Protocol
As in [
32
], we assume that agents are assigned with institutional goals, de ned in
the Moise layer, to be achieved via the well-known Contract Net Protocol (CNP)
protocol. We show how CNP can be implemented in JaCaMo+ by exploiting the
templates introduced above. CNP (see Table 1) involves two roles: initiator (i)
and participant (p). An agent playing the initiator role calls for proposals from
agents playing the participant role. A participant makes a proposal if interested.
Proposals can be accepted or rejected by initiator. Accept, done, and failure do
not amount to commitment operations, but impact on the progression of
commitment states, e.g., accept causes the satisfaction of the commitment created
by cfp. Listing 1.1 reports an excerpt of the JaCaMo+ CNP protocol artifact
Java annotation @OPERATION, line 1). It can be executed only by an initiator
(JaCaMo+ Java annotation @ROLE(name=\initiator"), line 2). It publishes the
task for the interaction session as an observable property of the artifact (line 6).
All agents focusing on the artifact will have this information added to their
belief bases. The social e ect of cfp is the creation (line 9) of as many
commitments as participants to the interaction, and of a social fact (line 11), that
tracks the call made by the initiator. These e ects will be broadcast to all
focusing agents. Accept pertains to the initiator. It asserts a social fact, accept,
which causes the satisfaction of one of the commitments created at line 9
towards a speci c participant. Propose counts the received proposals and, when
their number is su cient, signals this fact to the initiator by the creation of a
commitment (line 21) towards the group of participants. Below, the JaCaMo+
initiator program:
1 /* I n i t i a l g o a l s */
2 ! startCNP .
3 /* Plans */
4 +!startCNP : true
5 < makeArtifact ( " cnp " , " cnp . Cnp " , [ ] , C) ;
6 f o c u s (C) ;
7 enact ( " i n it i a t o r " ) .
8 +enacted ( Id , " i n it i a t o r " , R o l e I d )
9 < +enactment id ( R o l e I d ) ;
10 ! solveTask ( " task - one " ) .
11 +! solveTask ( Task ) /*ENTICE*/
12 : enactment id ( My Role Id )
13 < +task ( Task ) ;
14 c f p ( Task ) ;
15 ? cc ( My Role Id , Part Role Id , " propose " ,
The rst ten lines are about the setting up of the environment. In this
implementation, the initiator agent rst creates the Cnp artifact (line 5), and then
enact the initiator role (line 7). In general, however, the artifact could already
be available, and an agent could just focus on it, and enact the initiator role.
Note that the artifact noti es the agent the success of the enactment by
asserting an enacted belief in the social state; note also that the agent receives a
unique identi er, Role Id, that will be used within the social state throughout
the subsequent interactions (i.e., commitments will mention such an identi er).
After these preliminary steps, the initiator tries to reach the goal of having
task-one performed: solveTask("task-one")2. This situation maps with the
ENTICE rule from [
28
]; we, thus, follow the JaCaMo+ template associated with
such a rule: see lines 11 - 16. The initiator, driven by its goal, performs the social
action cfp, and thereby creates a commitment towards any participant that is
focusing (or will focus) on that speci c artifact. The execution of such action
(which is performed by the initiator by its own initiative) modi es the social
state; consequently, this modi cation is noti ed to the other focussing agents
who will be in condition of taking this new social relationship into account in
their own deliberative activity. The test goal concluding the rule allows the
initiator to verify that at least one commitment has actually been created; namely,
the entice has changed the social state.
Since the initiator has created a commitment, it must be ready to bring about
the consequent of such a commitment whenever the antecedent will become true.
The initiator must therefore contain a DELIVER-template plan; see lines 17-22
2 To improve the readability of the code, we have simpli ed the notation in the Jason
program by abstracting goals with simple labels.
in which the initiator, activated by the detachment of the commitment previously
created with the cfp social action, starts a plan that will satisfy the commitment
itself. The plan, acceptORreject (lines 23-33), rst selects the best proposal, and
then performs a social action accept towards the winner agent, and a social
action reject towards any other participant that has not been selected.
The two last plans, done (line 37) and failure (line 40), are used by the initiator
to monitor the actual completion of the task with either success or failure.
Let us now consider the participant side.
A participant waits for calls for proposal by means of the CArtAgO basic
operation focusWhenAvailable (line 5). A participant, thus, must be able to
react whenever a new commitment of the form cc(initiator; participant; propose;
accept _ reject) pops up in the social state. This behavior corresponds to the
DETACH template, that is encoded in the JaCaMo+ plan in lines 9-15. In
particular, the participant triggers a plan, setup proposal that will satisfy the
antecedent of the commitment. Such a plan, in fact, will include the social action
propose (line 19). Note that the e ect of action propose is twofold: (1) it
asserts a fact "propose" in the social state, and hence satis es the antecedent of
the triggering commitment; and (2) it also creates a new commitment from the
participant to the initiator (see the protocol de nition in Table 1), of the form
cc(p; i; accept; done _ f ailure). This second commitment states that the
participant is committed to carry out the task in case the initiator accepts its proposal.
Thus, since the participant creates a commitment, it must also be ready to bring
about the consequent of that commitment when the antecedent holds, and hence
also the participant has a DELIVER-template plan in its program: see lines
2330. In the speci c case, the participant will activate a plan, doneORfailure, whose
body will include the computation of a solution for the task at hand, and also the
social actions done or failure depending on the, respectively, positive or negative
result of the computation.
4.3
Final Remarks
One of the strongest points of JaCaMo+ is the decoupling between the design
of the agents and the design of the interaction { that builds on the decoupling
between computation and coordination done by coordination models like tuple
spaces. Agent behavior is built upon agent goals and on its engagements with
other agents, which are both the result of its deliberative process. For instance,
in CNP the initiator becomes active when the commitments that involve it as a
debtor, and which bind it to accept or reject the proposals, are detached. It is
not necessary to specify nor to manage, inside the agent, such things as deadlines
or counting the received proposals: the artifact is in charge of these aspects.
The decoupling allows us to change the de nition of the artifact without
the need of changing the agents' implementation. The Cnp class in Listing 1.1
detaches the commitments when a certain number of proposals is received. We
can substitute such a class with class CnpTimer, which detaches commitments
when a given deadline expires. This modi cation does not have any impact on
the agents, whose programs remain unchanged, but for the line in which an agent
focuses on (or creates) an artifact; e.g., for the initiator, the only change occurs
in line 5 (see the following listing), in which the initiator creates a di erent type
of artifact rei ng the CNP protocol (the participant case is similar).
1 /* I n i t i a l g o a l s */
2 ! startCNP .
3 /* Plans */
4 +! startCNP : true
5 < m a k e A r t i f a c t ( " cnp " , " cnp . C n p T i m e r " , [ ] , C ) ;
6 f o c u s (C ) ;
7 e n a c t ( " i n i t i a t o r " ) .
Listing 1.4. The initiator code, using CnpTimer.
Table 2 compares JaCaMo (with interaction [
32
]), with JaCaMo+ along some
important characteristics that a MAS should feature. Let us discuss these
dimensions, with a particular attention to those where the two platforms di er from
one another. JaCaMo and JaCaMo+ do not equally support autonomy, in the
sense that an agent can autonomously selects its own duties. JaCaMo with
interaction just o ers an agent to follow a predetermined path (a guideline) through
which the agent has to ful ll a precise pattern of obligations. JaCaMo+, instead,
o ers an agent a tool, the interaction artifact, through which it can
communicate with other agents and act together with others. The choice, however, of
how and when been involved into an interaction remains within the scope of the
agents. The adoption of commitments, in fact, assures that an agent assumes the
responsibility for a task only when, by its own choice, performs a speci c action
on the interaction artifact. This has an impact on the property of exibility and
robustness. An interaction that is structured based on obligations only hinders
agents when they need to adapt to unforeseen conditions ( exibility) or when
they need to react to unwanted situations (robustness). The agent, in fact, is
not free to delegate obligations, schedule them di erently, etc. All the agent can
do is to perform the actions that, instructed by the interaction protocol, resolve
its obligations.
Protocols in [
32
] aim at de ning guidelines to the use of resources in an
organization. This, however, limits the modularity of interaction protocols because
protocols depend on operations that are de ned in the organization and there
is no explicit association of which actions pertain to which roles. Thus, for
instance, a participant may execute a cf p and the interaction artifact would allow
it to do so. JaCaMo+ interaction protocols, instead, include the de nitions of
the needed operations, and specify which of them will empower the various role
players. For both proposals the interaction logic is captured by the artifact and
is not spread across the agent codes. Both include functionalities for monitoring
the on-going interaction. In [
32
] the normative structure is leveraged to this aim,
while in JaCaMo+ this can be done inside each of the protocol artifacts.
5
Conclusions
In this paper we presented JaCaMo+, and extension to JaCaMo that enables
social behaviors into its agents. We started from the interaction protocols based
on obligations proposed in [
32
]. These protocols are suitable for modeling
interactions among di erent elements of a MAS (i.e., not only interactions between
agents, but also between agents and objects). However, obligation-based
protocols reduce agent interactions to messages that an agent is obliged to send to
another agent; that is, social relationships among agents are not handled
directly. In other words, an obligation-based protocol can be adopted only in an
organization that gives guidelines about how interactions should be carried on,
but it is not applicable in those organizations where similar guidelines are not
available.
To cope with these more challenging situations, our intuition is to de ne an
interaction in terms of goals and commitments. Commitments, in fact, are at
the right level of abstraction for modeling directed relationships between agents.
Moreover, since commitments have a normative power, they enable the agents
to reason about the behavior of others; a commitment creates expectations in
the creditor about the behavior that the debtor will assume in the near future.
Note that our view is also backed up by the practical rules discussed in
[
28
], which highlight how goals and commitments are each other related. In
particular, in this paper we have proposed to use the same rules as a sort of
methodology for programming the Jason agents. An initial implementation of
our proposal is provided by the JaCaMo+ platform. The tests (which involve
from 5 to 100 agents) show that it scales up quite well, despite the introduction
of commitments, but a more thorough testing will be performed in the near
future.
The shift from obligations to commitments is bene cial in many respects.
First of all, the autonomy of the agents is better supported because, although
charged with goals to be achieved, they are free in deciding how to ful ll their
goals. It follows that agents are deliberative, and this paves the way to self-*
applications, including the ability to autonomously take advantage from
opportunities, and the ability of properly reacting to unexpected events (self-adaptation).
For instance, by nding a way for accomplishing an organizational goal taking
into account the current state of the MAS, which is hardly foreseeable at
design time. Moreover, the interplay between goals and commitments opens the
way to the integration of self-governance mechanisms into organizational
contexts. Thus, our concluding claim is that directly addressing social relationships
increases the robustness of the whole MAS.
In the future, we intend to investigate how agents can leverage on their
deliberative capabilities, and use it not only to program interactions, but to
plan social interactions. Moreover, the modular nature of the implementation
facilitates the development of extensions for tackling richer, data-aware contexts
[
12,22,13
]. We are also interested in tackling, in the implementation, a more
sophisticate notion of social context and of enactment of a protocol in a social
context [
4
], as well as to introduce a typing system along the line of [
2
].
Acknowledgements
The authors would like to thank the anonymous reviewers for their comments,
which helped improving the paper.