Autonomous Agents and Multi-Agent Systems, 4, 139–141, 2001© 2001 Kluwer Academic Publishers. Manufactured in The Netherlands.

LuCe: A Tuple-based Coordination Infrastructurefor Prolog and Java Agents

ENRICO DENTI AND ANDREA OMICINI �edenti; aomicini�@deis.uDipartimento di Elettronica, Informatica e Sistemistica (DEIS)Universita di Bologna, Viale Risorgimento, 2, 40136 Bologna, Italy

1. Aims and scope

The engineering of an application as a multi-agent system (MAS henceforth) callsfor models, languages, and tools specifically tailored to the metaphors of agent andagent society. In these systems, agents are typically required to interact and inter-operate, yet this is not enough to guarantee that the MAS operates towards theaccomplishments of its global goals: what is needed is the ability of constraininginteraction so as to ensure that the social rules of the MAS, intended as an agentsociety, are respected and enforced. This is what coordination is for [8].

In order to provide standard metaphors and abstractions to build agent societies,coordination should be one of the basic services supplied by an effective infrastruc-ture for MAS design, development and run-time support [5]. LuCe is a coordinationinfrastructure providing MAS engineers with tuple-based coordination technologyfor both Prolog and Java agents. Based on logic tuple centres [2], LuCe enables thedefinition of (reusable) intelligent coordination components, and effectively sup-ports the MAS construction process by model-specific tools, which bring the modelmetaphors to action.

2. The LuCe model

The LuCe model is based on the concept of logic tuple centre, a communicationabstraction that works like a (Linda) tuple space and is perceived by agents as such,but whose behaviour can be programmed so as to embed the required coordinationlaws [2]. Since tuple centres are perceived as tuple spaces, they feature all thetypical advantages of data-driven, tuple-based coordination models [9]: in addition,logic tuple centres feature the further advantage of adopting a logic-based languageas the agent communication language.

Because they are programmable, tuple centres can work as a full-fledged coor-dination abstraction: users can redefine the semantics of coordination acts to theagents’ eyes, encapsulating the social rules of an agent society in terms of the MAScoordination laws [4]. The adoption of a logic-based language also allows the coor-dination rules to be expressed as (meta-level) logic tuples, the specification tuples:so, in principle, an intelligent agent might program/modify the system coordinationpolicies, so as to define/adapt its global behaviour.

140 denti and omicini

Conceptually, the LuCe coordination space consists of a multiplicity ofindependently-programmable logic tuple centres, each identified by a uniquename. Moreover, LuCe is coordination transparent, that is, agents can use tuplecentres by simply referring to them by name, with no need of a meta-coordinationprimitive for tuple centre creation.

3. The LuCe infrastructure

LuCe (freely available at [6]) provides both an agent run-time system and an effec-tive coordination technology, with a comfortable IDE and specialised tools to supportthe MAS development process [5]. The LuCe infrastructure is based on three majoringredients: Java as the main standard Internet “glue technology,” a logic-based lan-guage to support the ever-increasing need of intelligence within applications, andtuple-based coordination to govern agent interaction.

The basic engine is microProlog, a light-weight Prolog interpreter written in Javaused to build LuCe Prolog agents. Java agents can be built, too, by properly sub-classing the pre-defined LuCeAgent class. Both Prolog and Java agents, as well as thetuple centres are implemented as threads of a LuCe cell: a cell is then a collectionof entities (agents and tuple centres) hosted in a given physical node of the network.A multiplicity of cells, possibly spread over the Internet, can join and build a LuCespace: all agents belonging to a given LuCe space can interact with each other bymeans of any tuple centre of that space, using the standard Linda primitives (in,out, read, etc.). Multiple spaces, singly identified by name, can coexist in the samephysical network. A new space is created by first setting up its main cell (either asa Java applet or application): further cells can then be added at any time by meansof the LuCe console interface.

Moreover, each cell provides MAS developers with a GUI to activate new (Pro-log and Java) agents, as well as to start up one of the system support tools (theInspectors), which enable developers to operate over tuple centres for deployment,debugging and monitoring purposes. In particular, the T Inspector operates on the(ordinary) tuples of a given tuple centre, the S Inspector operates on the spec-ification tuples, while the W Inspector displays the tuple centre’s pending queryqueue. Altogether, they provide both a data-oriented (from the communication andthe coordination viewpoints) and a control-oriented view over the space of agentinteraction, along with the control capabilities required to manage it effectively.

4. Evaluation and lessons learned

A tuple centre works as a conceptual locus where coordination laws can be stored,instead of spreading them over a multiplicity of agents [4]. So, LuCe allow agentsto be designed independently from each other, their interaction protocols to bedesigned and tested separately from agents and independently from each other,and coordination rules to be changed independently and incrementally added, thus

LuCe 141

easing MAS design, development, and adaptive maintenance [5]. Moreover, tuplecentres promote the definition of reusable intelligent coordination components.

The LuCe technology has been put to test by building some prototype systems,available at [6]: the tools have proved to be usable and effective, making it possibleto simulate agents still under development, monitor the execution of coordinationlaws, and supervise the system from the interaction viewpoint. Further experimentshave shown that the performance gain is significant, too, mainly because tuple cen-tres minimise the burden of agent communication [3].

The main drawbacks are the lack of a security model and the weakness of cellas a topological abstraction: in fact, LuCe is also network transparent, hiding theactual location of interacting entities from the user. These topics are currently underfurther investigation [1] in the context of the TuCSoN model [7]: we expect the firstpublic TuCSoN implementation to be available within the end of 2000.

References

1. M. Cremonini, A. Omicini, and F. Zambonelli, “Multi-agent systems on the Internet: extending thescope of coordination towards security and topology,” in F. J. Garijo and M. Boman (eds.), Multi-Agent Systems Engineering, LNAI, vol. 1647, pp. 77–88, 1999.

2. E. Denti, A. Natali, and A. Omicini, “On the expressive power of a language for programing coordi-nation media.” in Proc. 1998 ACM Symp. Appl. Comput. (SAC’98), 1998, pp. 169–177.

3. E. Denti and A. Omicini, “An architecture for tuple-based coordination of multi-agent systems,”Software Prac. Exper. vol. 29, no. 12, pp. 1103–1121, 1999.

4. E. Denti and A. Omicini, “Desigining multi-agent systems around an extensible communicationabstraction,” in J.-J. C. Meyer and P.-Y. Schobbens (eds.), Formal Models of Agents, LNAI, vol. 1760,pp. 90–102, 1999.

5. E. Denti and A. Omicini, “A coordination infrastructure for agent-based Internet applications,” inProc. 9th IEEE WET ICE 2nd Int. Workshop on Web-based Infrastructures and Coordination Architec-tures for Collaborative Enterprises, 2000.

6. E. Denti, A. Omicini, and V. Toschi, LuCe Home Site, http://lia.deis.unibo.it/research/LuCe/, 2000.7. A. Omicini and F. Zambonelli, “Coordination for Internet application development,” Auton. Agents

Multi-Agent Syst. vol. 2, no. 3, Special issue: coordination mechanisms for web agents, 1999.8. A. Omicini, F. Zambonelli, M. Klusch, and R. Tolksdorf (eds.), Coordination of Internet Agents: Mod-

els, Technologies and Applications, Springer-Verlag: Berlin, 2000.9. D. Rossi, G. Cabri, and E. Denti, Tuple-based Technologies for Coordination, in A. Omicini,

F. Zambonelli, M. Klusch, and R. Tolksdorf (eds.), Coordination of Internet Agents: Models, Tech-nologies and Applications, Springer-Verlag: Berlin, 2000, Chap. 4.