DEVELOPING A MEETING SCHEDULER MULTIAGENT

SYSTEM: AN EXPERIMENTAL CASE STUDY

Pedro Cuesta, Alma Gómez, Juan C. González, and Francisco J. Rodríguez

Dpto. de Informática (University of Vigo)
Ed. Politécnico, Campus Universitario As Lagoas, Ourense E-32004 (Spain)

ABSTRACT
In this work, an experimental case study for implementing a multiagent system is presented. The built system is a
meeting scheduler, which allows users to fix meetings automatically based on the personal agendas of participants. The
main objective of this work was to put in practice an agent oriented methodology and to use a development platform. In
particular, MaSE methodology and JADE framework have been the ones selected. The utilization of the system in an
university domain has yield to promising results.

KEYWORDS

Multiagent systems, MaSE methodology, JADE, Agent Negotiation.

1. INTRODUCTION
Agents represent a powerful abstraction tool in software development. The intrinsic characteristics of agents
(autonomy, reactivity, proactivity, etc.) provide a good approach in the solution of distributed complex
problems (Jennings, 1999). Therefore, Agent-Oriented Computing has become in the last decade a new
Software Engineering paradigm (Ciancarini and Wooldridge, 2001). Although systems may be formed of a
single agent, from a Software Engineering point of view, the interest is focused in multiagent systems
(Sycara, 1998;Weiss, 1999), that is, a set of autonomous agents which work cooperatively using high level
communication languages and protocols.
There are many applications implemented using agents, nevertheless agent tools and methodologies have
not achieved, until the moment, the maturing level needed for being used under warranty in commercial
software development (Iglesias, et al., 1999). Two issues are essential if the agents are to be utilized in
software industry: the availability of tools or frameworks which simplify multiagent systems implementation
and the use of suitable methodologies which guide the engineer during the development process.
Due to the previously stated reasons, the main aim of this work was to experiment the applicability of
agent technology in real world problems. Agent oriented approach is beneficial, among others, in the
following situations (O’Malley and DeLoach, 2002):

• Where complex/diverse types of communication are required.

• In situations involving negotiation, cooperation and/or competition among different entities.
• When the system must act autonomously.

The problem selected for experimentation was a meeting scheduler, which allows to fix automatically
meetings involving several members of an organization. It has the characteristics previously introduced and,
therefore, can be constructed under an agent oriented approach. Besides, a real problem in organization is
approached. Finding a suitable date for a meeting implies many difficulties, because it requires to achieve an
agreement among the personal agendas of all invited users. Normally, this process supposes that a person has
to spend a great amount of time in calling users, asking them for their potential data, trying to match all this
information for finding a data suitable for all of them, etc. This process must be iterated until a good date is

I - 97
IADIS International Conference Applied Computing 2004

fixed. In addition, users have to update their personal agendas in accordance, leading to important problems
if the user forgets this actualisation.
Once the problem was posed, the next step was the evaluation of different agent development tools
(ZEUS, JADE, BEE-GENT,...). JADE (Bellifemine, et al, 2002) was the selected tool because it is one of the
most used tools, has sufficient documentation and is FIPA compliant (FIPA, 2000). After, several agent
methodologies (MaSE, Gaia, Tropos,…) were analysed. The chosen methodology was MaSE (DeLoach, et
al., 2001) because it is domain independent, covers the whole life cycle and is supported by a graphical tool:
agentTool (DeLoach and Wood, 2001).
The reminder of the paper is organized as follows. Next two points include an overview of the
methodology and the implementation framework used. The fourth point addresses the process of system
development, starting from the definition of requirements and following with the models constructed during
analysis and design phases. Point number five describes the system architecture, its functioning and how the
implementation was made in JADE. The paper finishes with the preliminary results and conclusions obtained
from this work.

2. MASE OVERVIEW
MaSE (DeLoach, et al., 2001) is a general purpose methodology for developing heterogeneous multiagent
systems. It is domain independent, covers the complete lifecycle of the system and has a tool (AgentTool
(DeLoach and Wood, 2001) which supports the basic models of the methodology and provides automatic
verification and code generation. It uses a number of graphical models to describe the types of agents in a
system and their interfaces with other agents, as well as an architecture independent detailed definition of the
internal agent design.
The lifecycle of MaSE is iterative. It is pretended that the analyst or designer moves among steps and
phases freely. With each successive step, additional detail is added and, eventually, a complete and consistent
system design is obtained.
The analysis and design processes are divided in seven steps which are introduced next. The analysis
phase produces a set of roles whose tasks describe what the system has to do to meet its overall requirements.
For achieving this objective, it starts by the stage of (1) Capturing Goals, where goals are identified for initial
requirements and structured into a Goal Hierarchy Diagram. Next, the (2) Applying Use Cases stage
identifies the use cases and creates the sequence diagrams to help to identify an initial set of roles and
communication paths. Finally, the (3) Refining Goals phase transforms the goals previously obtained into a
set of roles. Together with roles a set of tasks are created; tasks define the role behaviour.
The main aim of design stage is to define the overall system organization by transforming the roles and
tasks introduced during analysis into agent types and conversations. The first stage, (4) Creating Agent
Classes maps roles to specific agent classes and identifies conversations. The following phase, (5)
Constructing Conversation, defines protocols in the form of state diagrams. The third phase of design, (6)
Assembling Agent Classes allows to define the internal functionality of agent classes. The final stage is (7)
System Design, where the agent instances are created from the agent classes.

3. JADE
JADE, Java Agent DEvelopment Framework, (Bellifemine, 2002) is a software development framework
which simplifies the implementation of multi-agent systems. It includes two products: a runtime agent
platform and a package to develop Java agents. At the moment, it is one of the most used frameworks for
agent development.
JADE provides support to distribution across different machines and configuration controlled via a
remote GUI. The FIPA communication model has been fully implemented and includes components like:
interaction protocols, ACL, content languages, encoding schemes, ontologies and transport protocols. This
provides an efficient and flexible support to agent communication architecture. One of the most important
characteristics in this field is that the transport mechanism adapts to each situation, by transparently choosing
the best available protocol (Java RMI, SMTP, HTTP, …).

I - 98
 DEVELOPING A MEETING SCHEDULER MULTIAGENT SYSTEM: AN EXPERIM ENTAL CASE STUDY

As it has been said before, the JADE Agent Platform complies with FIPA specifications (FIPA, 2000) and
includes all those mandatory components that manage the platform, that is an Agent Management System
(AMS), a Directory Facility (DF) and an Agent Communication Channel (ACC). AMS is a white page
service for all agents while DF provides a yellow pages service in the platform. Finally, the ACC is in charge
of message passing between agent platforms.
JADE incorporates also a number of auxiliary tools which simplify the platform administration and the
system development. Some of the most imp ortant ones are introduced next: RMA (Remote Management
Agent, a graphical console for platform management and control), Introspector Agent (a useful tool that
allows to monitor the life cycle of an agent and its exchanged ACL messages), Dummy Agent (a monitoring
and debugging tool that allows to compose ACL messages and send them to other agents) and the Sniffer (an
agent which can intercept and display ACL messages).
All agents in JADE extend the Agent class and inherit features to accomplish basic interaction with the
agent platform and a basic set of methods included in the custom behaviour of an agent such as sending or
receiving messages, using standard interaction protocols, etc. The particular tasks of an agent are
implemented as Behaviour objects. A programmer who wants to implement a task should define one or
more behaviour subclasses, instantiate them and add the behaviour objects to the agents task list. A library of
standard FIPA interaction protocols is provided using initiator and responder behaviours.
With respect to ontologies JADE provides a package that allows to create application specific ontologies
and to use them with independence of the adopted content language.

4. MEETING SCHEDULER DEVELOPMENT

4.1 Requirements
The main objective of the system is to implement a meeting scheduler which helps users inside an
organization to fix meetings among them. In order to accomplish this general objective the system shall
provide a way to:

• Manage users. Users have to register before been able to access the system. This means that the
system must provide a way for creating and deleting users, organizing them in groups, etc.

• Maintain an agenda for each user. The personal agenda will be configured for each user. It will
reflect the user work timetable and will allow the inclusion of periodical and non periodical
appointments. For each appointment different attributes can be established (starting time, length,
description…).

• Organize meetings. The user must be able to call for a meeting within a given period. For each
meeting some data as its description, the foreseeable length of time, the place where it will take
place, etc. must be provided. In addition, the user will choose the participants (individuals or
groups) and indicate the minimal number of participants which are needed for deciding that the
meeting can be carried out. A user may cancel his participation at any time, if this implies that
number of participants falls behind the minimal, the meeting will be cancelled. Only the
organizing user can cancel or modify the place of the meeting.

• Inform users. Once a meeting has been successfully established, all users must be informed and
their personal agenda will be updated accordingly. The user will be notified of any modification
which affect a meeting in which he is involved.

I - 99
IADIS International Conference Applied Computing 2004

4.2 Analysis and Design

As it has been introduced before, the analysis and design have been done following MaSE methodology.
According to it, the different models proposed have been constructed.
Taking into account the functional requirements introduced previously, the step of Capturing Goals has
been used for transforming them in a structured set of system goals. The results of this step are shown in the
Goal Hierarchy Diagram introduced in Figure 1.

Figure 1. Goal Hierarchy Diagram

The second step done has been Applying Use Cases. This implied the definition of more than twelve
basic Use Cases, the identification of paths of communication and the construction of all necessary Sequence
Diagrams. These diagrams have reached the number of twenty six, including all the exceptional situations
which may arise.
Finally, the third stage of Analysis, Refining Goals, transformed the previous goals in a set of roles and
their associated tasks. This step implied the construction of a Role Model Diagram and several Concurrent
Task Diagrams, each one specifying the role behaviour for each task, using a finite state automaton. In the
meeting scheduler system, six roles were identified by the developer (see Figure 2):

• System manager, which has associated the tasks of maintenance of users and groups.
• Users manager, which includes the tasks of managing the information of groups and users.
• Users informer. The only task associated to this role is providing up to date information of users
and groups.
• Meeting scheduler. This role includes the following tasks:
o Fix a meeting.
o Obtain the suitable date and time.
o Notify user.
• Agenda manager, having the task of updating agenda.
• User, which is responsible of managing his personal agenda and proposing a meeting.

I - 100
 DEVELOPING A MEETING SCHEDULER MULTIAGENT SYSTEM: AN EXPERIM ENTAL CASE STUDY

Figure 2. Role Model Diagram

The first stage in the design phase was Creating Agent Classes. In this example, the roles previously
described were grouped in four agent classes: user interface, administrator interface, matchmaker and
meeting manager agents. The final result of this stage was the Agent Classes Diagram (Figure 3) which
shows the overall agent system classes and conversations among them. Conversations were detailed in the
following stage of design, called Constructing Conversations. Each conversation requires two
Communication Class Diagrams one for the initiator and other for the responder. The final step of system
design was done using a Deployment Diagram (using the UML notation) for showing the system structure.
For constructing the diagram it was taken into account that many instances of the same agent class can be
running in the system at the same time. For instance, many users can be connected, each one in a different
host. Besides, the meeting manager agent and the matchmaker can be running in two different servers. These
latest agents must be always running for the system to be operative.

Figure 3. Agent Class Diagram

I - 101
IADIS International Conference Applied Computing 2004

5. SYSTEM DESCRIPTION

5.1 Architecture
The system constructed on the basis of the requirements previously described allows to establish meetings
automatically using the personal agendas of users. The system architecture is composed of four kind of
agents.

• User Interface agent. This agent is the link between each user and the system. Each organization
member by means of his interface agent can define his agenda and initiate the process of calling for
a meeting other members.

• Administrator Interface agent. It is responsible of regis tering users and assigning them to groups.

• Meeting Manager agent. Each interface agent has associated an agent of this kind. It is in charge of
attending callings for a meeting from other agents. This implies to examine the personal agenda of
the user in order to negotiate the meeting date and time. Using this agent the user does not need to
be connected to the system to fix a meeting.

• Matchmaker agent. This agent offers the information about the system users. It is based on JADE
AMS (Agent Management System) and shows the groups to which the user belongs, his address,
etc. to interface agents.

In a normal functioning of the system, the meeting maganer agent for each user, as well as the
matchmaker agent must be always running. This means that they are to be installed in some kind of server
which must be accessible to all interface agents.

5.2 How does the System Work?

The first step that must be done by the administrator, using his interface agent, is to register the organization
members in the system, create the groups and assign users to these groups. Each time the administrator
interface agent makes a change, it is communicated to matchmaker agent, which is responsible for providing
information about users and groups.
Once this first step is done, the users must introduce some information in their personal agenda, by means
of his specific interface agent. The agenda contains the working timetable for each user during a particular
period and the different activities scheduled (this activities can be periodical or non periodical). This agenda
is accessed both by the interface agent and the meeting manager agent. The first agent actualises the agenda
while the other consults it when it is looking for date and time for a meeting.
The most important functionality of the system is the process of establishing meetings. All users in the
system are authorized to organize a meeting and they must introduce the following information: period of
time within the meeting must take place, user/groups implied, location, minimal number of participants,…
Once this information has been introduced and validated, the meeting scheduler agent of the user will initiate
the negotiation with the meeting scheduler agents of the rest of the invited users in order to obtain a possible
date and time for the meeting. When this process finishes, the each user agendas will have been updated for
including this new appointment and the corresponding message will be showed for each interface agent.

I - 102
 DEVELOPING A MEETING SCHEDULER MULTIAGENT SYSTEM: AN EXPERIM ENTAL CASE STUDY

5.3 The JADE Implementation

In system construction, the facilities of JADE for implementation have been used. That is, the agent classes
have been programmed as extensions of the classes provided by JADE framework. In particular, the user
interface agent and administrator interface agent class extend GuiAgent Class. Since matchmaker and
meeting scheduler agent do not need an interface with the user, they are programmed as extensions of Agent
Class. In fact, GuiAgent Class is just an extension of Agent Class with mechanisms for adding an interface
to the agent.
The implementation of conversations has been done using, as before, the methods provided by JADE
which support the contract-net protocol. Although JADE platform provides all interaction protocols, the
contract-net has been the one chosen for this system, in order to fix the meeting date and time. In other
simpler conversations the query interaction protocol, and the request interaction protocol (FIPA, 2000) were
used.
On the other hand, the ontology needed for the system has been implemented using other tools which
differ from the ones provided by JADE platform. This decision has been taken considering the facilities
provided by the selected tool: Protégé 2000 and the availability of a plug-in for JADE, called beangenerator.

6. PRELIMINARY RESULTS AND FUTURE WORK

The meeting scheduler multiagent system has been proved as a beta version in the Computer Science School
belonging to University of Vigo. This centre has many committees which help in its government and which
are composed of professors, teachers, students, … The committees join periodically and require a minimal
number of attendants for being able to take decisions. Before using the meeting scheduler system, finding a
suitable data for a meeting was hard work.
The system has facilitated very much the achievement of data for the meetings, with a high diminution in
the amount of time required. The main drawback found when using the system, is that it relies on the idea
that all users have their agenda up to date. Other important issue it that the algorithm for fixing the date gives
a higher priority to the agenda of the organizing user.
As future work, the previous drawback must be overcome. The system will be improved for allowing that
all agendas have the same priority. In addition, the meeting scheduler agent will be endowed with a more
proactive behaviour in order to choose the date and time for an appointment, using new requirements, or for
capturing automatically user preferences.

7. CONCLUSIONS
Applying a particular agent methodology has been difficult due, in great part to the lack of available
documentation. Besides, although the application of the methodology has simplified the definition of a
suitable system model, the most part of the specification has not been of help in JADE implementation. For
instance, communication class diagrams have a level of abstraction too low (the states the agent passes for
during conversation are specified in detail), while in JADE communications are defined at a higher level and
it is not necessary to introduce such details.
The development platform used, JADE, provides mechanisms suitable for the construction of multiagent
systems, making easy the programmer task when implementing agents and the communication among them.
An aspect that can be improved in the tool would include debugger utilities adapted to the agent model
defined.

ACKNOWLEDGEMENTS
This research is supported by the Spanish national project TIC 2002-04516-C03-01.

I - 103
IADIS International Conference Applied Computing 2004

REFERENCES
Bellifemine, F., et al, 2002. Jade Programmer’s Guide (JADE 2.6). http://sharon.cselt.it/projects/jade/.
Ciancarini, P. and Wooldridge, M., 2001. Agent-Oriented Software Engineering. First International Workshop AOSE
2000, Lecture Notes in Computer Science Vol. 1957. Springer-Verlag, Berlin.
DeLoach, S. A., et al, 2001. Multiagent systems engineering. In The International Journal of Software Engineering and
Knowledge Engineering, Vol. 11, No. 3.
DeLoach, S. A. and Wood, M., 2001. Developing multiagent systems with agenttool. In Intelligent Agents VII. Agent
Theories Architectures and Languages, 7th International Workshop (ATAL 2000), C. Castelfranchi, Y. Lesperance
(Eds.). Lecture Notes in Computer Science. Vol. 1986, Springer Verlag, Berlin.
FIPA, 2000. FIPA Specifications. http://www.fipa.org/.
Iglesias, C. A., et al., 1998. A survey of agent-oriented methodologies. In Proceedings of the 5th International Workshop
on Intelligent Agents V: Agent Theories, Architectures, and Languages (ATAL-98), Lecture Notes in Artificial
Intelligence, Vol. 1555, Springer-Verlag: Heidelberg, Germany, pp. 317-330.
Jennings, N. R., 1999. Agent-based computing: Promise and perils. In Proceedings of the 16th International Joint
Conference on Artificial Intelligence (IJCAI-99-Vol2). Stockholm, Sweden, pp. 1429-1436.
O’Malley, S.A, and DeLoach, S.A., 2002. Determining When to Use an Agent-Oriented Software Engineering
Paradigm. Proceedings of the Second International Workshop On Agent-Oriented Software Engineering (AOSE-
2001), Lecture Notes in Computer Science, Vol. 2222. pp.188-2005.
Sycara, K. P., 1998. Multiagent systems. The AI Magazine, Vol. 10, No. 2, pp. 79-92.
Weiss, G., 1999. Multiagent Systems. A Modern Approach to Distributed Artificial Intelligence. MIT Press, Cambridge,
USA.

I - 104