Multi-paradigm Coordination for MAS: Integrating Heterogeneous Coordination Approaches in MAS Technologies Stefano Mariani Andrea Omicini DISI, A LMA M ATER S TUDIORUM–Università di Bologna DISI, A LMA M ATER S TUDIORUM–Università di Bologna via Sacchi 3, 47521 Cesena, Italy via Sacchi 3, 47521 Cesena, Italy Email: s.mariani@unibo.it Email: andrea.omicini@unibo.it Abstract—Open distributed multi-agent systems featuring Subjective coordination [1] represents instead the dual autonomous components demand coordination mechanisms for approach – typically adopted in the (distributed) artificial both functional and non-functional properties. Heterogeneity of intelligence field [7] – where coordination issues are directly requirements regarding interaction means and paradigms, stem- tackled by the agents themselves, determining their best course ming from the diverse nature of components, should not affect of (inter-)action in the attempt to achieve their own goals. the effectiveness of coordination. Along this line, in this paper we share our pragmatical experience in the integration of objective Thus, the burden of coordination is here distributed among and subjective, synchronous and asynchronous, reactive and pro- coordinables, expressing their autonomy w.r.t. coordination active coordination approaches within two widely-adopted agent- commitments through their own deliberation process. oriented technologies (JADE and Jason), enabling coordinating Clearly, respecting agents’ autonomy is a foremost issue in components to dynamically adapt their interaction means based the design of coordination models for MAS, be them objective on static preference or run-time contingencies. or subjective. Also, the issue of autonomy emerges while designing other facets of coordination model and technologies, I. I NTRODUCTION corresponding to the aforementioned classification criteria. Open and distributed multi-agent systems (MAS) featur- Enforcing a reactive programming style for handling in- ing autonomous components demand efficient coordination teractions – as typically done in the context of event-based mechanisms for both functional and non-functional properties. systems and actor-based frameworks – often leads to the Heterogeneity of requirements regarding interaction means problem of inversion of control—namely, the fact that the flow and paradigms – e.g. message-passing vs. shared space, syn- of interactions determines when the interacting components chronous vs. asynchronous, proactive vs. reactive, etc. – stem- should act and what they should do, thus definitely wipe out ming from the heterogeneous nature of components – e.g. pro-activeness of components. Also, on a lower level, the software agents vs. physical devices – implies that coordination management of the component control flow is taken out from should be effective despite heterogeneity. the programmers’ hands, and left to the framework. In the Coordination approaches in the literature can be classified overall, inversion of control results in a blatant example of according to diverse criteria, such as the means through which violation of the component autonomy. interaction happens – e.g. messages vs. tuples –, synchronism Adopting a synchronous semantics for interaction primi- of interaction primitives, enforced programming style—e.g. tives invocation, without adequate mediating abstractions un- reactive, such as with actors, vs. pro-active, such as with coupling the invoker flow of control from the (possibly) agents. The most general classification distinguishes coordina- suspensive semantics of the primitive, is another way to violate tion approaches as either objective or subjective [1], depending the components autonomy. A typical example can be observed on who is responsible for the ”burden of coordination”: the in any L INDA-like coordination model [8], where interacting coordinable, or the coordination medium—following the meta- components are usually bound to withstand the outcomes of model and the terminology proposed in [2]. the coordination process—e.g. getting stuck whenever a getter primitive finds no matching tuple in the shared space. Objective coordination [1] refers to the approach – typi- cally stemming from the software engineering research field – Accordingly, in this paper we share our pragmatical ex- where coordination-related concerns are encapsulated within perience in integrating objective and subjective, synchronous dedicated abstractions, such as coordination artefacts [3] (the and asynchronous, reactive and pro-active coordination ap- medium), offering coordination as a service to coordinables proaches, enabling participating components to (deliberatively) [4]. Thus, coordination abstractions take responsibility for dynamically adapt their interaction means based on static coordination, by steering agent societies – that is, ensemble preference or run-time contingencies – while still having their of cooperating/competing agents – towards the achievement autonomy preserved –, in the context of two widely adopted of social (shared) goals, through the suitable management of agent-oriented technologies, that is, JADE [9] and Jason [10], the dependencies between agents’ activities [5], [6]—despite featuring their own subjective coordination mechanisms, and agent’s individual goals, yet without harming their autonomy. adopting the TuCSoN middleware as the provider of objective 91 coordination. The goal is to provide MAS designers and noting that method action() is executed from the beginning programmers with a flexible development framework capable every time: there is no way to “stop-then-resume” a behaviour of seamlessly supporting multi-paradigm coordination, where during its execution. agents deliberatively choose which coordination paradigm and interaction means to adopt for the current interactions—and, The ACC is the middleware service in charge of asyn- more importantly, where such a choice does not affect nega- chronous message passing among agents: each agent has its tively the other interactive, or non-interactive, activities they own mailbox where incoming communications are silently are (possibly, concurrently) undertaking. put, waiting to be explictly (pro-actively) considered by the receiving agent—for the sake of preserving its autonomy. The remainder of the paper is organised as follows. Sec- When and how to process the mailbox is up to the agent’s tion II describes how the subjective coordination paradigm own deliberation: may be instantiated within a message-based setting, also wr.t. synchronism and programming style, by discussing the • method receive() attempts to asynchronously re- concrete cases of JADE (Subsection II-A) and Jason (Subsec- trieve the first message, or a message compliant with a tion II-B). Section III describes how the objective coordination given message template, from the mailbox—returning paradigm may be implemented within a tuple-based setting, nothing in case no message is found by discussing the TuCSoN approach (Subsection III-A). Sec- • method blockingReceive(), as the name sug- tion IV describes our solution for enabling multi-paradigm gests, attempts to synchronously retrieve the first mes- coordination, by briefly describing TuCSoN4JADE (Subsec- sage, or a message compliant with a given message tion IV-A) – already presented in [11], but useful here for template, from the mailbox—waiting until a message comparison and generalisation purposes – and by thoroughly is eventually found discussing TuCSoN4Jason (Subsection IV-B)—also, an exam- ple showcasing effectiveness of multi-paradigm coordination is Clearly, the first method preserves the autonomy of the agent provided in Subsection IV-C. Finally, Section V briefly reports no matter what. The same does not hold for the second one, on some similar works by fellow researchers, while Section VI because deciding to wait for a specific interaction potentially summarises the work, and outlines future improvements. hinders the ability of the agent to remain responsive to other interactions—although based on a deliberate choice of the II. M ESSAGE - BASED S UBJECTIVE C OORDINATION agent itself. In this section we briefly describe the approach to subjec- The reason is that method blockingReceive() sus- tive coordination adopted by two agent development frame- pends the agent as a whole, not only the calling behaviour. works well-known within the MAS community: JADE (Sub- Thus, the JADE Programmers Guide itself [12] suggests section II-A) and Jason (Subsection II-B). the adoption of the following programming pattern: call receive() instead of blockingReceive(), then call method block() – of the Behaviour class – if no message A. Subjective Coordination in JADE is found, so as to suspend only the calling behaviour—which JADE (Java Agent DEvelopment Framework) [9] is a Java- will be automatically resumed by JADE upon reception of any based framework and infrastructure to develop and deploy message. Therefore, if programmers want their agents’ auton- open, distributed, agent-based applications in compliance with omy preserved while subjectively coordinating, they should FIPA standard specifications for interoperable intelligent MAS. abide to the “block-then-resume” pattern just described. In JADE, autonomy of agents is supported by the behaviour ab- Besides plain message passing, JADE provides to program- straction, whereas coordination adopts the subjective paradigm mers a number of ready-to-use FIPA interaction protocols, thanks to an asynchronous message-passing layer – the Agent such as the Contract Net [13] and the general-purpose Achieve Communication Channel (ACC) – on top of which FIPA inter- Rational Effect [14], in the form of a callbacks framework: action protocols are implemented and provided to developers— as a callbacks framework. • programmers declare which FIPA protocol their inter- A behaviour can be logically interpreted as “an activity acting agents should commit to, by instantiating the to perform with the goal of accomplishing a task”. Thus, corresponding Java object different courses of actions of a JADE agent are encapsulated • then, they implement the actual body of the callback into distinct behaviours the agent executes simultaneously. methods corresponding to each interaction (message More technically, JADE behaviours are Java objects, which to be received or sent) as expected according to the are executed pseudo-concurrently within a single Java thread specific FIPA protocol adopted by a built-in non-preemptive round-robin scheduler. During JADE agent initialisation, behaviours are added to the ready As any other framework adopting a callback scheme, JADE queue, ready to be scheduled. Then, method action() of FIPA protocols promote a reactive programming style, where the first behaviour – implementing one of the agent’s course of agents synchronously wait for messages to advance through the action – is executed. Behaviours switch occurs only when the protocol stages. Agents’ pro-activeness – so, their autonomy – method returns; hence, in the meanwhile no other behaviour is thus limited. Nevertheless, JADE internally implements FIPA can start execution (non-preemptive scheduler). Behaviours protocols abiding to the block-then-resume pattern, so that removal from the ready queue occurs only when the done() interacting agents stay responsive to concurrent interactions method returns true; otherwise, the behaviour is re-scheduled while subjectively coordinating—besides being able to carry at the end of the queue (round-robin scheduler). It is worth out non-interactive activities through concurrent behaviours. 92 Summing up, JADE support to subjective coordination is ◦ asynchronous, where the caller intention never provided through asynchronous message passing – respecting gets suspended, and the query result has to agents’ autonomy thanks to the block-then-resume pattern – be handled reactively through a proper plan and built-in FIPA protocols—limiting instead autonomy due handling the belief addition event +b to reactiveness enforced by the callbacks framework. ◦ synchronous, where the caller intention gets suspendend until the receiver’s reply becomes B. Subjective Coordination in Jason available—that is, a matching belief appears in its belief base Jason [10] is both an agent language and an agent runtime ◦ timed synchronous, where the synchronism is system. As a language, it implements a dialect of AgentSpeak limited by a finite upper bound on waiting [15]; as a run-time system, it provides some services needed time, whose expiration causes the intention to to execute a MAS—e.g. agents’ reasoning engine and a non- be resumed—and labelled with a timeout distributed execution platform. Although Jason is entirely outcome programmed in Java, it features BDI agents, so a higher- level language (the Jason language) is used to program Jason It is worth noting that intentions only (not the whole Jason agents using BDI abstractions. In Jason, autonomy of agents agent) are automatically suspended whenever they perform is supported by plan/intention concurrent execution machinery, a (communication) action which cannot complete – e.g. the whereas coordination adopts the subjective paradigm1 thanks request for information following a test-goal attempt –, to to the asynchronous message passing layer. be resumed as soon as the action obtains its “completion Similarly to JADE behaviours, a Jason plan can be con- feedback” (see [10], page 86)—e.g. the message conveying the ceptually interpreted as a course of action to be performed to requested information. This mechanism may be interpreted as accomplish a task. Technically, a Jason plan differs consider- the equivalent of JADE block-then-resume pattern, which is ably from JADE behaviours: (i) it is scheduled for execution as automatically handled here by the Jason runtime. soon as a triggering event occurs, (ii) it is not directly executed Summing up, Jason support to subjective coordination “as is” (in general), but is instantiated as an intention, then is provided through both asynchronous and synchronous executed, (iii) intentions are pseudo-concurrently executed one message passing, respecting agents’ autonomy thanks to action each, according to a round-robin scheduler. Therefore, the intention suspension mechanism—unlike JADE, where whereas in JADE the behaviour is the basic execution step, blockingReceive() suspends the agent as a whole. in Jason the same role is played by the single action, not by the plan/intention as a whole. Intentions may be suspended – III. A RTEFACT- BASED O BJECTIVE C OORDINATION either by the programmer or by the Jason reasoning engine – for a number of reasons—e.g. because the agent needs to wait In this section we briefly describe the approach to objective for a message, or an environmental event. coordination adopted by the TuCSoN coordination model and Jason agents can in fact exchange beliefs (but also plans technology, taken as a reference for artefact-based coordination and goals), both synchronously and asynchronously through and exploited in Section IV as the provider of objective the same .send() internal action, in the form of messages coordination services. encoded in a KQML-like language, with a very similar se- mantics. Depending on the illocutionary force determining A. Objective Coordination in TuCSoN the meaning of messages (e.g., askOne vs. tell), their TuCSoN [16] is a Java-based, (logic) tuple-based coordi- reception causes different events (e.g., test-goal addition vs. nation model and infrastructure for open, distributed MAS. It belief addition) automatically triggering execution of the cor- provides objective coordination as service by implementing respondent plans. It is worth noting that there is no explicit and extending the L INDA model [8] with ReSpecT tuple receive communication primitive involved, here, nor a mailbox centres [17], the coordination artefacts [3] encapsulating coor- to explicitly monitor2 . The basic illocutionary forces concerned dination mechanisms and policies, distributed over a network with exchanging beliefs are: of TuCSoN nodes. • tell, to share a (list of) belief(s) with a target (list of) TuCSoN preserves interacting agents’ autonomy through agent(s). Addition of the communicated information the Agent Coordination Context (ACC) [18] abstraction— to the belief base of the receiver agent, where it waits mainly; TuCSoN architecture also contributes, as clarified to be pro-actively considered, causes a belief addition below by describing TuCSoN “two-steps” execution. ACC are event, handled by plans starting with the +b clause assigned to agents as they enter a TuCSoN-coordinated MAS, • askOne to query another agent’s belief base—sort with the responsibility, among the many others, to uncouple the of a “remote test-goal”3 . The internal action askOne synchronism of a coordination operation invocation from the comes in three flavours: suspensive semantics of the coordination primitive used – e.g. 1 While objective coordination could in principle be implemented on top L INDA in –, by mapping operations to events asynchronously dispatched to the coordination media (ReSpecT tuple centres). of Jason Environment Java API for programming MAS (computational) environments, it is not considered here since no first-class support for More precisely, the suspensive semantics of getter prim- environment abstractions is provided. 2 Actually, a mailbox exists, but the Jason agent is completely unaware of itives, as inherited by the L INDA model, implies that if no it. matching tuple is found the operation waits indefinitely until 3 Actually, a test-goal is executed on the receiver agent side, thus, if plans it becomes available. This semantics does not depend on starting with the +?b clause exist, they are triggered to handle the request. agent own deliberation: it is set by the coordination model 93 at hand, and is what enables distributed synchronisation and The simplest and most straightforward solution would coordination, in the very hand. The synchronism of invocation be letting JADE agents directly access TuCSoN services, instead, couples (or uncouples) the fate of a coordination requiring nothing more than a correct usage of TuCSoN operation with that of the invoker agent, and is subject to the API—since both technologies are implemented on top of Java. agent own deliberation. This means that: Nevertheless, direct API access would inevitably hinder JADE agents autonomy while resorting to objective coordination • in case the agent chooses the synchronous invocation synchronously: their control flow would be coupled to that mode, it gets suspended, too, if the operation gets of the coordination operation requested, so that in case of sus- suspended pension the whole agent would get stuck, not just the invoker • if the asynchronous invocation mode is used, instead, behaviour. This way, roughly speaking, agents’ deliberate suspension policy is confined to the operation, whereas choice to exploit objective coordination could negatively affect the invoker agent can continue performing its activi- their ongoing subjective coordination activities, as well as any ties, pro-actively inspecting the status of the operation other non-interactive activity in process. This would represent when preferred—and eventually getting the result a glaring example of an artificial dependency (unintentionally) created by a “non-autonomy-preserving” approach to multi- In order to do so, the execution of any TuCSoN operation paradigm coordination. follows two steps: Instead, an appropriate integration between TuCSoN and • the request to carry out a given coordination operation JADE was achieved in [11] by developing a bridge compo- is performed by the agent through its ACC, which nent in charge of suitably suspending and resuming JADE then dispatches the corresponding operation event to behaviours depending on the outcome of the requested TuC- the target tuple centre—invocation step SoN coordination operation—besides providing a suitable API wrapping TuCSoN services to JADE agents: the TuC- • the response to the coordination operation invoked is SoN4JADE bridge4 . sent back to the requesting agent by the tuple centre through its ACC, as soon as the response is available— In particular, the bridge is based on the fact that whenever completion step any JADE behaviour is re-scheduled its action() method is re-started, thus the synchronous invocation of TuCSoN Put in other terms, any coordination service provided by coordination operation is repeated. The whole TuCSoN4JADE TuCSoN is asynchronous by default; nevertheless, interacting machinery works because the invocation – through TuC- agents may deliberately choose the invocation synchronism of SoN4JADE API method synchronousInvocation() – each coordination operation—potentially limiting their auton- transparently checks whether the operation just invoked can be omy: either synchronous or asynchronous. completed: in case the operation result is not available, yet, the Summing up, TuCSoN coordination model preserves agent request is actually dispatched by TuCSoN ACC to the target autonomy by uncoupling the suspensive semantics of coordina- tuple centre, and the invoker behaviour is suspended by calling tion operations from their invocation semantics (synchronism) method block(). As soon as the operation result becomes – actually promoting pro-activeness over reactiveness – thanks available, the bridge component resumes the suspended be- to the ACC architectural abstraction. haviour and hands off the completion event—so that the second invocation, due to behaviour restart, immediately succeeds. IV. E NABLING M ULTI - PARADIGM C OORDINATION Summing up, TuCSoN4JADE lets JADE agents free to In this section we describe two software modules enabling choose, for every single interaction event, which coordination TuCSoN-based multi-paradigm coordination for JADE and paradigm suits their needs best, based on both design-time Jason agents, namely, TuCSoN4JADE (Subsection IV-A) and preference and run-time contingencies, without possibly hin- TuCSoN4Jason (Subsection IV-B) respectively, emphasising dering other ongoing coordination activities. the technical solutions adopted to preserve conceptual integrity of the resulting development framework—especially, w.r.t. au- B. The case of TuCSoN4Jason tonomy of agents. Subsection IV-C provides an example about how a widely spread and well-known coordination scenario, In the case of Jason, the main integration issue is to that is, a Contract Net Protocol based interaction, may benefit make TuCSoN synchronous invocation semantics compatible from a multi-paradigm coordination approach. with Jason concurrency model based on intentions. In fact, simply wrapping the TuCSoN API into suitable Jason abstrac- A. The case of TuCSoN4JADE tions, such as internal actions, would inevitably hinder Jason agents autonomy while resorting to objective coordination syn- An autonomy preserving integration of JADE and TuCSoN chronously: their control flow would be coupled to that of the was already presented in [11], with an emphasis on the impact coordination operation requested, thus in case of suspension that technical choices regarding concurrency and communi- the whole agent would get stuck, not only the invoker intention. cation aspects have on the opportunities for objective and subjective coordination integration—also accounting for the Yet again, agent deliberate choice to exploit objective conceptual issues of autonomy of interacting agents. There, coordination negatively affects their ongoing subjective co- the main issue was making TuCSoN synchronous invocation ordination activities, thus resulting in another failed attempt semantics compatible with JADE concurrency model based on behaviours. 4 http://apice.unibo.it/xwiki/bin/view/TuCSoN/4JADE 94 Figure 1: TuCSoN4Jason architecture to fully enable multi-paradigm coordination. Thus, an ade- The set of internal actions, implemented by the quate integration between TuCSoN and Jason requires a fine- public classes within package t4jn.api extending grained integration of TuCSoN two-steps execution mecha- TucsonInternalActionImpl, is responsible for nism with Jason intention suspension mechanism, properly providing Jason agents with the means to request TuCSoN suspending/resuming intentions based on coordination oper- coordination services, that is, basically, the set of available ations outcome: the TuCSoN4Jason bridge is the Java library coordination primitives. Besides the usual tuple space providing such integration5 . primitives such as out, rd, and in, primitive getResult deserves special attention: it is responsible for uncoupling First of all, we analyse the integration solution provided the request of a coordination operation from its completion, by TuCSoN4Jason from the architectural point of view, high- handling (automatic) intention suspension when the result of lighting its main components—Figure 1: a getter primitive (such as in) is not yet available. • a custom agent architecture enabling customisation of each Jason agent inner reasoning engine • an operation completion listener enabling TuCSoN to couple Jason intention suspension mechanism with its invocation semantics • a set of custom internal actions enabling Jason agents to request TuCSoN coordination services and inspect operations outcome The custom agent architecture, implemented by class T4JnArchImpl, is responsible for dispatching coordination operation requests from Jason agents to the TuCSoN service, keeping track of pending as well as completed operations (in collaboration with the other components), and coordinating the other TuCSoN4Jason components. The operation completion listener, implemented by class TucsonResultsHandler, is responsible for handling no- tifications of operations completion coming from TuCSoN, for tracking them within the custom agent architecture, (au- tomatically) resuming suspended intentions when their result becomes available, and unifying TuCSoN tuples (the operation results) with Jason variables. Figure 2: TuCSoN4Jason flow of interactions 5 http://apice.unibo.it/xwiki/bin/view/TuCSoN/4Jason 95 Collaboration between components – as depicted in Fig- 1 ... ure 2 – makes TuCSoN4Jason bridge capable of enabling 23 // result NOT available if (!(results.containsKey(actionId))) { autonomy-preserving multi-paradigm coordination for Jason 4 Circumstance c = ts.getC(); agents, by carefully coupling Jason intention suspension mech- 5 // suspend calling intention anism with TuCSoN two-step execution of suspensive primi- 67 Intention i = c.getSelectedIntention(); this.suspendIntention = true; tives. 8 i.setSuspended(true); 9 c.addPendingIntention( Whenever a TuCSoN operation is requested (message 1), 10 jason.stdlib.suspend.SELF_SUSPENDED_INT through Jason custom internal actions, the bridge component 11 12 + i.getId(), i); // track suspended intention – in particular, the custom agent architecture represented by 13 arch.getSuspendedIntentions().put(actionId, i); interface T4JnArch – takes care of asynchronously dispatch- 14 mutex.unlock(); // thread-safety ing the request to TuCSoN (message 1.1) by exploiting TuC- 15 16 } return true; SoN services devoted to asynchronous operation invocation— 17 ... not depicted to keep the picture simple. Then it tracks the pending state of the requested operation (message 1.2) and Figure 3: Suspension of a Jason intention, due to spawns a dedicated handler for its completion (message 1.3)— getResult() being called with no result available yet TucsonResultsHandler. As soon as the operation is ready to be completed, the handler is notified by TuCSoN with the result (message 2), so that the state of the corresponding operation can be changed from “pending” to “completed” 12 ... // corresponding action caused suspension (message 2.1), and, if needed, resume the suspended intention 3 if (this.suspendedIntentions.containsKey(this.actionId)) { within which TuCSoN4Jason getResult() internal action 4 Intention suspendedIntention = this.suspendedIntentions 5 .remove(this.actionId); was called (message 2.3, Figure 4). 6 this.mutex.unlock(); // thread-safety 7 ... // parse result It is worth noting that the notification may happen at any- 8 Circumstance c = this.ts.getC(); time, without prior knowledge on whether getResult() has 9 // scan pending intentions either been called or not. Dually, from the Jason agent stand- 10 11 Iterator ik = c.getPendingIntentions().keySet() .iterator(); point, there is no prior (design-time) knowledge on whether the 12 while (ik.hasNext()) { operation succeeded until getResult() is (synchronously) 13 String k = ik.next(); 14 if (k.startsWith(suspend.SUSPENDED_INT)) { called. 15 Intention i = c.getPendingIntentions().get(k); In fact, any Jason custom internal action has an asyn- 16 17 // find corresponding intention if (i.equals(suspendedIntention)) { chronous invocation semantics, that is, it does not wait for 18 i.setSuspended(false); operation completion, so that the agent is free to choose when 19 ik.remove(); 20 ... // other reasoner-related stuff to ask for it whenever it pleases (message 3)—deliberatively. 21 c.resumeIntention(i); When doing so, the TuCSoN4Jason bridge checks if the 22 } operation result is available (message 3.1): if it is, the agent 23 24 } } gets it and the current intention can proceed (message 3.2); 25 } otherwise, the calling intention gets suspended (message 3.3, 26 ... Figure 3), until the result becomes available. Figure 3 shows a code excerpt taken from the Figure 4: Resuming a previously suspended intention to due getResult() custom internal action implementation. There, its result becoming available TuCSoN4Jason manipulates the state of the Jason reasoner be- hind any Jason agent – thanks to T4JnArchImpl extending Jason AgArch – so as to make it suspend the intention within which getResult() was called, in case no result is available choose, for every single interaction event, the coordination yet. In particular, line 4 retrieves from the reasoner the current paradigm that best suits their needs, based on both design- execution context (Circumstance), line 6 gets the current time preference and run-time contingencies, without hindering intention (the one where getResult() was called), lines any other ongoing coordination activities. 8 − 13 actually suspend the intention. Subjective coordination based on asynchronous message Figure 4, instead, shows a code excerpt taken from the passing, handled with a reactive programming style based on TucsonResultsHandler() component implementation. belief addition events (+b), can be seamlessly and simulta- There, TuCSoN4Jason manipulates the state of the Jason neously exploited by Jason agents while they are objectively reasoner so as to make it resume the intention within which coordinating based on either getResult() was called, as soon as its result becomes available. In particular, line 4 tracks that such an intention • synchronous TuCSoN operations, emulated by fol- is no longer pending, line 8 retrieves from the reasoner the lowing an operation invocation – asynchronous by current execution context, lines 10 − 15 iterate over pending deafult – with an immediate call to getResult() intentions according to the reasoner state, line 17 finds the • asynchronous TuCSoN operations handled adopt- intention to be resumed among the ones being iterated over, ing a pro-active programming style, e.g. calling lines 18 − 21 actually resume the intention. getResult() as part of the Jason plan when the Summing up, TuCSoN4Jason lets Jason agents free to information is actually needed 96 • asynchronous TuCSoN operations handled adopt- implemented to shield the caller intention. Thus it is stuck too, ing a reactive programming style, e.g. calling hindering the caller agent from scheduling other intentions in getResult() in a separate parallel plan dedicated the meanwhile—in particular, the “purchase” interaction chain solely to handling the operation result—e.g. storing (4b-5b) cannot carry on until a new call-for-proposals is issued. it as a belief, thus triggering belief addition plans, Figure 6 depicts the same scenario, now programmed upon or explicitly triggering dedicated plans processing the the TuCSoN4Jason bridge, thus preserving autonomy. Since result the rd call is shielded by a proper mechanism within the bridge, the suspensive semantics is confined to the caller inten- C. Multi-paradigm CNP with TuCSoN4Jason tion. This means that only the caller intention is suspended – As a simple yet expressive example of multi-paradigm using the proper mechanisms provided by Jason (see Figure 3) coordination, we describe a book trading scenario implemented – whereas other activities can carry on concurrently—e.g., the as a Jason MAS—the example is included in TuCSoN4Jason purchase transaction already in place (4b-5b). distribution. In particular, we re-interpret the well-known Con- The wide applicability of the CNP, as well as its suitability tract Net Protocol (CNP) [13] in a multi-paradigm coordination for implementation as a multi-paradigm coordination protocol setting, where part of the protocol relies on synchronous tuple- – drawing from both objective and subjective, synchronous, based objective coordination – delivered by TuCSoN – and and asynchronous approaches – makes the concept of multi- part on asynchronous message-based subjective coordination— paradigm coordination quite relevant in the context of agent built-in in Jason. development frameworks and coordination technologies—also In short, n seller agents advertise their catalogue of books, making the need for suitable middleware components such as whereas m buyer agents browse such catalogues looking for TuCSoN4Jason quite apparent. books. The whole interaction chain naturally follows FIPA Contract Net Interaction Protocol [20]: buyers start a call-for- V. D ISCUSSION & R ELATED W ORKS proposals, sellers reply with actual proposals, buyers choose In [21], CArtAgO [22] is integrated with three differ- which one to accept, the purchase is carried out. A fundamental ent agent development frameworks: Jason, 2APL [23], and requirement – called concurrency property in the following – simpA [24]. The approach taken is an example of autonomy- is that sellers should stay reactive to call-for-proposals even preserving integration: e.g., in the case of Jason-CArtAgO, in the middle of a purchase transaction—otherwise they could Jason intentions suspension mechanism is successfully inte- lose potential revenues. The book trading scenario is thus taken grated with CArtAgO artefacts by exploiting CArtAgO agent here as a paradigmatic example of the practical relevance of body abstraction. In particular, whenever a Jason agent re- preserving autonomy while enabling multi-paradigm coordina- quests execution of an operation on a CArtAgO artefact, the tion. caller intention is automatically suspended until the “effector Accordingly, we re-think the CNP by integrating objective feedback” is received. Thus, nothing can hinder Jason agent and subjective coordination approaches: tuple-based call-for- autonomy if they simultaneously operate on artefacts while proposals with message-based purchase. In fact, since the call- exchanging messages with other agents. for-proposals should reach all the sellers, putting a single call- In [19], integration between JADE and TuCSoN tech- for-proposals tuple in a shared contract-net space is more effi- nologies is successfully achieved, allowing JADE agents to cient than messaging each seller individually. On the contrary, exploit TuCSoN coordination services as part of the JADE since the purchase is typically a 1-to-1 interaction, messaging platform. However, without preserving autonomy. JADE model can efficiently do the job. As a result, this approach is not just of autonomy and TuCSoN model of coordination [11] were conceptually correct, but also more efficient—less messages, not considered: in fact, if a coordination operation gets sus- less network operations, etc. pended, the caller behaviour is unavoidably suspended, too, For the purpose of comparison, we first attempt to imple- because of its single thread of control being stuck waiting for ment the MAS without exploiting TuCSoN4JADE, just directly operation completion. This inevitably leads to the suspension calling TuCSoN API from within Jason with Jason internal of all other behaviours the agent is (possibly) concurrently actions without further concerns (Figure 5); then we repeat executing. Roughly speaking, the agent choice to rely on the same exercise by relying on TuCSoN4Jason (Figure 6). objective coordination may affect its ongoing subjective co- As one could expect, the result is that in the former case the ordination activities. This is a clear example of an artificial concurrency property – thus, agent autonomy – is lost, whereas dependency (unintentionally) created by a “non autonomy- it is preserved as expected in the latter. preserving” approach. Figure 5 depicts one possible instance of the run-time VI. C ONCLUSION & O UTLOOK interactions between a given seller and a given buyer. In particular, the seller is replying to a previous call-for-proposals Enabling multi-paradigm coordination along a number of (message 3b). Meanwhile, it is also ready to serve new orthogonal dimensions of coordination – such as objective incoming call-for-proposals (3a). Here is the problem: the vs. subjective stance, synchronism of coordination primitive suspensive coordination operation rd gets stuck until a call- invocation, reactiveness of the programming style promoted for-proposals is issued by a buyer. This is fine: it is exactly by the API – potentially brings about a wide range of for this suspensive semantics that the L INDA model works. communication, synchronisation, namely, coordination-related What is not-so-fine is that the rd is stuck on a network-level requirements to be satisfied, whenever the coordinables are call and no “defensive” programming mechanism has been provided with the ability to change the way they exploit 97 Figure 5: Non autonomy-preserving approach taken in [19]: rd suspensive semantics extends to the caller behaviour, then to the caller agent, blocking all its activities. Figure 6: TuCSoN4Jason autonomy-preserving approach to multi-paradigm coordination: rd suspensive semantics is confined to the caller intention only, thus the caller agent can carry on its other concurrent intentions. coordination services at run-time, depending on preference or MAS [25], where, besides distribution and heterogeneity, also ever-changing, unpredictable contingencies. autonomy and (situated) intelligence typically play a key role: autonomy, for infusing the system with non-functional For these reasons, technologies like TuCSoN4Jason and properties such as tolerance to failures, situated intelligence TuCSoN4JADE may be key-enablers in all those application for improving the system effectiveness by leveraging reasoning scenarios featuring distributed and heterogeneous components over, e.g., contextual information. which, on the one hand, heavily depends on communication and coordination to carry out their duties, on the other hand, The fact that Jason adopts the BDI model for agents, may need to adopt diverse coordination paradigms depending coupled with TuCSoN choice of working with first-order on both their own capabilities and run-time contingencies. logic tuples, makes TuCSoN4Jason even more relevant for Such a sort of scenarios are usually dealt with by pervasive the aforementioned class of systems. 98 In the near future, we plan to further strengthen integration [14] Foundation for Intelligent Physical Agents, “FIPA Communicative between TuCSoN and both Jason and JADE: for the former, Act Library Specification,” http://www.fipa.org/specs/fipa00037/, 6 Dec. private tuple spaces as belief bases and shared tuple spaces 2002. as environmental resources are both directions we wish to [15] A. S. Rao, “AgentSpeak(L): BDI agents speak out in a logical computable language,” in Agents Breaking Away, ser. Lecture Notes in explore; for the latter, we envision automatic translation back Computer Science, W. Van de Velde and J. W. Perram, Eds. Springer, and forth FIPA ACL messages and first-order logic tuples, as 1996, vol. 1038, pp. 42–55, 7th European Workshop on Modelling well as support for tuple-based FIPA interaction protocols. Autonomous Agents in a Multi-Agent World (MAAMAW’96), Eindhoven, The Netherlands, 22-25 Jan. 1996, Proceedings. [Online]. Available: http://link.springer.com/10.1007/BFb0031845 R EFERENCES [16] A. Omicini and F. Zambonelli, “Coordination for Internet application [1] A. Omicini and S. Ossowski, “Objective versus subjective coordination development,” Autonomous Agents and Multi-Agent Systems, vol. 2, in the engineering of agent systems,” in Intelligent Information Agents: no. 3, pp. 251–269, Sep. 1999, Special Issue: Coordination Mechanisms An AgentLink Perspective, ser. Lecture Notes in Computer Science, for Web Agents. [Online]. Available: http://link.springer.com/10.1023/ M. Klusch, S. Bergamaschi, P. Edwards, and P. Petta, Eds. Springer A:1010060322135 Berlin Heidelberg, 2003, vol. 2586, pp. 179–202. [Online]. Available: [17] A. Omicini and E. Denti, “From tuple spaces to tuple centres,” http://link.springer.com/10.1007/3-540-36561-3 9 Science of Computer Programming, vol. 41, no. 3, pp. 277–294, [2] P. Ciancarini, “Coordination models and languages as software Nov. 2001. [Online]. Available: http://www.sciencedirect.com/science/ integrators,” ACM Computing Surveys, vol. 28, no. 2, pp. 300–302, Jun. article/pii/S0167642301000119 1996. [Online]. Available: http://portal.acm.org/citation.cfm?id=234732 [18] A. Omicini, “Towards a notion of agent coordination context,” in [3] A. Omicini, A. Ricci, and M. Viroli, “Coordination artifacts as Process Coordination and Ubiquitous Computing, D. C. Marinescu and first-class abstractions for MAS engineering: State of the research,” C. Lee, Eds. Boca Raton, FL, USA: CRC Press, Oct. 2002, ch. 12, in Software Engineering for Multi-Agent Systems IV: Research Issues pp. 187–200. and Practical Applications, ser. Lecture Notes in Computer Science, [19] A. Omicini, A. Ricci, M. Viroli, M. Cioffi, and G. Rimassa, A. F. Garcia, R. Choren, C. Lucena, P. Giorgini, T. Holvoet, “Multi-agent infrastructures for objective and subjective coordination,” and A. Romanovsky, Eds. Springer Berlin Heidelberg, Apr. Applied Artificial Intelligence: An International Journal, vol. 18, 2006, vol. 3914, pp. 71–90, invited Paper. [Online]. Available: no. 9–10, pp. 815–831, Oct.–Dec. 2004, special Issue: Best papers http://link.springer.com/10.1007/11738817 5 from EUMAS 2003: The 1st European Workshop on Multi-agent [4] M. Viroli and A. Omicini, “Coordination as a service,” Fundamenta Systems. [Online]. Available: http://www.tandfonline.com/doi/10.1080/ Informaticae, vol. 73, no. 4, pp. 507–534, 2006, Special Issue: Best 08839510490509036 papers of FOCLASA 2002. [Online]. Available: http://content.iospress. [20] Foundation for Intelligent Physical Agents, “FIPA Contract Net In- com/articles/fundamenta-informaticae/fi73-4-04 teraction Protocol specification,” http://www.fipa.org/specs/fipa00029/, [5] C. Castelfranchi, “Modelling social action for AI agents,” Artificial 6 Dec. 2002. Intelligence, vol. 103, no. 1-2, pp. 157–182, Aug. 1998. [21] A. Ricci, M. Piunti, L. D. Acay, R. H. Bordini, J. Hübner, [Online]. Available: http://www.sciencedirect.com/science/article/pii/ and M. Dastani, “Integrating heterogeneous agent programming S0004370298000563 platforms within artifact-based environments,” in 7th International [6] T. W. Malone and K. Crowston, “The interdisciplinary study of Joint Conference on Autonomous Agents and Multiagent Systems coordination,” ACM Computing Surveys, vol. 26, no. 1, pp. 87–119, (AAMAS-08), L. Padgham and D. C. Parkes, Eds. Estoril, Portugal: 1994. [Online]. Available: http://dl.acm.org/citation.cfm?doid=174668 IFAAMAS, 12–16 May 2008, pp. 225–232. [Online]. Available: [7] G. M. O’Hare and N. R. Jennings, Eds., Foundations of Distributed http://dl.acm.org/citation.cfm?id=1402419 Artificial Intelligence, ser. Sixth-Generation Computer Technology. [22] A. Ricci, M. Viroli, and A. Omicini, “CArtAgO: A framework for John Wiley & Sons, Apr. 1996. [Online]. Available: http://eu.wiley. prototyping artifact-based environments in MAS,” in Environments for com/WileyCDA/WileyTitle/productCd-0471006750.html MultiAgent Systems III, ser. Lecture Notes in Artificial Intelligence, [8] D. Gelernter, “Generative communication in Linda,” ACM Transactions D. Weyns, H. V. D. Parunak, and F. Michel, Eds. Springer, on Programming Languages and Systems, vol. 7, no. 1, pp. 80–112, Jan. May 2007, vol. 4389, pp. 67–86, 3rd International Workshop 1985. [Online]. Available: http://dl.acm.org/citation.cfm?doid=2433 (E4MAS 2006), Hakodate, Japan, 8 May 2006. Selected Revised and [9] F. L. Bellifemine, A. Poggi, and G. Rimassa, “JADE–a FIPA-compliant Invited Papers. [Online]. Available: http://link.springer.com/10.1007/ agent framework,” in 4th International Conference and Exhibition 978-3-540-71103-2 4 on the Practical Application of Intelligent Agents and Multi-Agent [23] M. Dastani and J.-J. C. Meyer, “A practical agent programming Technology (PAAM-99). London, UK: The Practical Application language,” in Programming Multi-Agent Systems, ser. Lecture Notes in Company Ltd., 19–21 Apr. 1999, pp. 97–108. [Online]. Available: Computer Science, M. Dastani, A. El Fallah Seghrouchni, A. Ricci, http://jade.cselt.it/papers/PAAM.pdf and M. Winikoff, Eds. Springer, 2008, vol. 4908, pp. 107–123, [10] R. H. Bordini, J. F. Hübner, and M. J. Wooldridge, Programming 5th International Workshop, ProMAS 2007 Honolulu, HI, USA, Multi-Agent Systems in AgentSpeak using Jason. John Wiley & Sons, May 15, 2007 Revised and Invited Papers. [Online]. Available: Ltd, Oct. 2007. [Online]. Available: http://eu.wiley.com/WileyCDA/ http://link.springer.com/10.1007/978-3-540-79043-3 7 WileyTitle/productCd-0470029005.html [24] A. Ricci, M. Viroli, and G. Piancastelli, “simpA: A simple agent- [11] S. Mariani, A. Omicini, and L. Sangiorgi, “Models of autonomy and oriented Java extension for developing concurrent applications,” in coordination: Integrating subjective & objective approaches in agent Languages, Methodologies and Development Tools for Multi-Agent development frameworks,” in Intelligent Distributed Computing VIII, Systems, ser. Lecture Notes in Computer Science. Springer, Jul. 2008, ser. Studies in Computational Intelligence, L. Braubach, D. Camacho, vol. 5118, pp. 261–278, 1st International Workshop, LADS 2007, and S. Venticinque, Eds., vol. 570. Springer, 2014, pp. 69–79, 8th Durham, UK, September 4-6, 2007. Revised Selected Papers. [Online]. International Symposium on Intelligent Distributed Computing (IDC Available: http://link.springer.com/10.1007/978-3-540-85058-8 16 2014), Madrid, Spain, 3-5 Sep. 2014. Proceedings. [Online]. Available: [25] F. Zambonelli, A. Omicini, B. Anzengruber, G. Castelli, F. L. http://link.springer.com/10.1007/978-3-319-10422-5 9 DeAngelis, G. Di Marzo Serugendo, S. Dobson, J. L. Fernandez- [12] F. Bellifemine, G. Caire, T. Trucco, and G. Rimassa, “JADE program- Marquez, A. Ferscha, M. Mamei, S. Mariani, A. Molesini, S. Montagna, mer’s guide,” http://jade.tilab.com/doc/programmersguide.pdf, Telecom J. Nieminen, D. Pianini, M. Risoldi, A. Rosi, G. Stevenson, M. Viroli, Italia S.p.A., Apr. 2010. and J. Ye, “Developing pervasive multi-agent systems with nature- inspired coordination,” Pervasive and Mobile Computing, vol. 17, [13] R. G. Smith, “The Contract Net Protocol: High-level communication pp. 236–252, Feb. 2015, Special Issue “10 years of Pervasive and control in a distributed problem solver,” IEEE Transactions on Computing” In Honor of Chatschik Bisdikian. [Online]. Available: Computers, vol. C-29, no. 12, pp. 1104–1113, 1980. [Online]. Available: http://www.sciencedirect.com/science/article/pii/S1574119214001904 http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=1675516 99