(IJCNS) International Journal of Computer and Network Security, 69

Vol. 1, No. 2, November 2009

A Collaborative Framework for Human-Agent

Systems
Moamin Ahmed1, Mohd Sharifuddin Ahmad2 and Mohd Zaliman Mohd Yusoff3
1
College of Information Technology, Universiti Tenaga Nasional,
Km 7 Jalan Kajang-Puchong, 43009 Kajang, Selangor, Malaysia
momen42@yahoo.com

2
College of Information Technology, Universiti Tenaga Nasional,
Km 7 Jalan Kajang-Puchong, 43009 Kajang, Selangor, Malaysia
sharif@uniten.edu.my

3
College of Information Technology, Universiti Tenaga Nasional,
Km 7 Jalan Kajang-Puchong, 43009 Kajang, Selangor, Malaysia
zaliman@uniten.edu.my

the agents to take over the timing and execution of

Abstract: In this paper, we demonstrate the use of software
agents in assisting humans to comply with the deadlines of a communication from humans. However, the important tasks,
collaborative work process. Software agents take over the i.e. preparation and moderation tasks are still performed by
communication between agents and reminding and alerting humans. The agents continuously urge human actors to
humans in complying with scheduled tasks. We use the FIPA complete the tasks by the deadline and execute
agent communication protocol to implement communication communicative acts to other agents when the tasks are
between agents. An interface for each agent provides the means
completed.
for humans to communicate with their agents and to delegate
mundane tasks to them. This paper reports an extension to our previous work in
Keywords: intelligent software agents, multiagent systems, the same project [1]. Section 2 of this paper briefly dwells
workflow, collaboration. on the issues and problems relating to the EPMP. Section 3
reviews the related work on this project. In Section 4, we
1. Introduction develop and present our framework to resolve the problems
of EPMP. Section 5 discusses the development and testing
In a human-centric collaboration, the problem of adhering
of the system and Section 6 concludes the paper.
to deadlines presents a major problem. The diversity of tasks
imposed on humans and the procedures attached to them
pose a major challenge in keeping the time to implement 2. Issues and Problems in EPMP
scheduled tasks. One way of overcoming this problem is to
The EPMP is the standard process of our faculty for
use a scheduler or a time management system which keeps
examination paper preparation and moderation. The process
track of deadlines and provides reminders for time-critical
starts when the Examination Committee (EC) sends out an
tasks. Other researchers have developed agent-based
instruction to start prepare examination papers. A Lecturer
solutions to resolve similar problems in workflow systems
then prepares the examination paper, together with the
[18], [19], [20], [21]. However, such systems do not always
solutions and the marking scheme (Set A). Upon
provide the needed assistance to perform mundane follow-
completion, he then submits the set to be checked by an
up tasks and resolve delays caused by humans. In this paper,
appointed Moderator.
we demonstrate the development and application of software
The Moderator checks the set and returns it to the
agents to implement a collaborative work of Examination
Lecturer with a moderation report (Set B). If there are no
Paper Preparation and Moderation Process (EPMP) in our
corrections, the Lecturer submits the set to the Examination
academic faculty. We use the FIPA agent communication
Committee for further actions. Otherwise, the Lecturer
language (ACL) to implement communication between
needs to correct the paper and resubmit the corrected paper
agents [3], [4]. An interface for each agent provides a
to the Moderator for inspection. If corrections have been
convenient means for humans to delegate mundane tasks to
made, the Moderator returns the set to the Lecturer. Finally,
software agents. The use of such interface and the
the Lecturer submits set to the Committee for further
subsequent communication performed by agents and
processing. Figure 1 shows the process flow for the EPMP.
between agents contribute to the achievement of a shared
goal, i.e. the completion of the examination paper The Lecturer and Moderator are given deadlines to
preparation and moderation process within the stipulated complete the process as shown in Table 1. The process
time. continues over a period of four weeks in two preparation-
We use the FIPA ACL to demonstrate the usefulness of moderation-correction cycles.
70
Figure 1. The EPMP Process Flow
Table 1: Typical Schedule for Examination Paper
Preparation and Moderation
Tasks Deadlines
Set A should be submitted to the
Week 10
respective moderators
1st moderation cycle Week 10 & 11
nd
2 moderation cycle (Set B) Week 12 & 13
Set B should be submitted to EC Week 14
Lack of enforcement and the diverse tasks of lecturers and
moderators caused the EPMP to suffer from delays in action
by the academicians. Lecturers wait until the last few days
of the second cycle to submit their examination papers,
which leaves insufficient time for the moderators to
scrutinize the papers qualitatively. Due to the manual nature
of the process, there are no mechanisms which record the
adherence to deadlines and track the activities of defaulters.
To resolve some of these problems, we resort to the use of
software agents to take over the communication tasks
between agents and the reminding and alerting tasks
directed to humans. We will describe more of these
functions in greater details in Section 4.3.
3. Related Work
3.1 Agents and Agent Communication Language
The development of our system is based on the work of
many researchers in agent-based systems. For example,
agent communication and its semantics have been
established by research in speech act theory [14], [20],
KQML [3], [14] and FIPA ACL [4], [5], [9]. We based our
design of agent communication on the standard agent
communication protocol of FIPA [4], [5] and its semantics
[6]. FIPA ACL is consistent with the mentalistic notion of
agents in that the message is intended to communicate
attitudes about information such as beliefs, goals, etc. Belief,
Desire, and Intention (BDI) is a mature and commonly
adopted architecture for intelligent agents [12]. FIPA ACL
message use BDI to define their semantics [6]. Cohen and
(IJCNS) International Journal of Computer and Network Security,
Vol. 1, No. 2, November 2009
Perrault [18] view a conversation as a sequence of actions
performed by the participants, intentionally affecting each
other's model of the world, primarily their beliefs and goals.
While KQML and FIPA ACL epitomize agent
communication, many researchers have developed other
techniques of agent communication. Payne et al. [17]
propose a shallow parsing mechanism that provides message
templates for use in message construction. This approach
alleviates the constraint for a common ACL between agents
and support communication between open multiagent
systems. Chen and Su [2] develop Agent Gateway which
translates agent communication messages from one
multiagent system to an XML-based intermediate message.
This message is then translated to messages for other
multiagent systems.
Pasquier and Chaib-draa [16] offer the cognitive
coherence theory to agent communication pragmatic. The
theory is proposed as a new layer above classical cognitive
agent architecture and supplies theoretical and practical
elements for automating agent communication.
3.2 Workflow Systems
Software agents have also been applied in workflow systems
to resolve some specific issues. Many business processes use
workflow systems to exploit their known benefits such as
automation, co-ordination and collaboration between
entities. Savarimuthu et al. [19] and Fluerke et al. [7]
describe the advantages of their agent-based framework
JBees, such as distribution, flexibility and ability to
dynamically incorporate a new process model. Researches
have also been made on the monitoring and controlling of
workflow [19]. Wang and Wang [21], for example, propose
an agent-based monitoring in their workflow system.
Our framework extends the capabilities of these systems
by employing a mechanism that enforces and motivates
humans in the process loop to comply with the deadlines of
scheduled tasks. We implement this mechanism by
establishing a merit and demerit point system which rate
human’s compliance to deadlines.
3.3 Ontology
The term ontology was first used to describe the
philosophical study of the nature and organization of reality
[11, 12]. In AI it is simply defined as “an explicit
specification of a conceptualization” [10]. This definition
provokes many controversies within the AI community
especially with regard to the meaning of conceptualization.
An ontology associates vocabulary terms with entities
identified in the conceptualization and provides definitions
to constrain the interpretations of these terms.
Most researchers concede that an ontology must include a
vocabulary and corresponding definitions, but there is no
consensus on a more detailed characterization [13].
Typically, the vocabulary includes terms for classes and
relations, while the definitions of these terms may be
informal text, or may be specified using a formal language
like predicate logic as implemented in [8].
 (IJCNS) International Journal of Computer and Network Security, 71
Vol. 1, No. 2, November 2009

FIPA ontology uses a specification of a representational and tracked by the agents in their environment
vocabulary for a shared domain of discourse involving
definitions of classes, relations, functions, and other objects
[5].

4. The Collaborative Framework

We develop our framework based on a four-phased cycle
shown in Figure 2. The development process includes
domain selection, domain analysis, tasks and message
exchanges and application.

Figure 3. The Model’s Architecture

4.3 Tasks and Message Exchanges

An agent sends a message autonomously when some states
of the environment are true. It performs the following
actions to complete the message-sending task (See Figure
4):
Figure 2. The Four-Phased Development Cycle

4.1 Domain Selection

Our framework involves a working relationship between an
agent and its human counterpart. Considering the nature of
the tasks and the complexity of the work process, the EPMP
seems to be a suitable platform on which to develop a
multiagent framework.
The mundane tasks of document submissions, deadlines
reminding and work progress tracking could be delegated to
software agents. Consequently, we chose the EPMP as a
platform for our framework that contains both humans and
agents. The goal of this collaborative process is to complete
the preparation and moderation of examination papers.

4.2 Domain Analysis

Domain analysis consists of analyzing the process flow,
identifying the entities and modeling the process. We have
described and analyzed the process in Section 2 and will not
repeat it here. For the purpose of our model, we create three
agents that represent the Examination Committee (C),
Moderator (M) and Lecturer (L). Figure 3 shows the
architecture of our model.
Humans communicate with their agents via an interface
and their corresponding agents monitor and update their
environment to communicate between agents, perform tasks
that enables the progression of the workflow, and reminding
and alerting their human counterparts to meet the deadlines.
With this model, important human activities are recorded
Figure 4. Agent Actions
4.3.1 Check the state of the Environment
The agent always checks its environment, which consists of
four parts:
• Status of uploaded files: The agent checks its user if he
has uploaded Set A or Set B to a specified folder. If he
has done so, the agent checks the next step.
• Status of deadlines: The agent checks the system’s date
72
everyday and compare it with the deadline.
• Status of subprograms: When an agent perform a task,
it records the actions in a subprogram, e.g. when the
Committee agent sends the Prepare message, it records
this event to use it later for sending a remind message.
• Message signal: The agent opens a port and makes a
connection when it senses a message coming from a
remote agent.
4.3.2 Send messages
The agent decides to send a message when some status of
the environment are true, otherwise it will inform all agents
of any delays from its user and penalizes its user with
demerit points. When sending a message, it performs the
following actions:
• Open Port (Connect): When the agent decides to send a
message, it opens a port and makes a connection.
• Send Message (online or offline): The message will be
received when the remote agent is online. Two problems
may occur: (i) The remote agent is offline; (ii) The IP
address of the remote agent is inadvertently changed. We
resolve these problems by exploiting the Acknowledge
performative. If the sending agent does not receive an
Acknowledge message from a remote agent, it will
resend the message in offline mode. The same process is
executed if the IP address is changed. We focus on these
issues to ensure that the agents must achieve the goal in
any circumstances because it relates to completing the
students examination papers.
• Register action, date and merit/demerit point: When
the agent has sent the message, it registers the action
and the date in a text file. It also evaluates the user by
giving merit or demerit points based on the user’s
adherence to any deadlines. The Head of Department
could access these points to evaluate the staff’s
commitment to EPMP and take the necessary corrective
action.
• Record in Subprograms: The agent records some
actions as subprograms when it needs to execute those
actions later.
• Close Port (Disconnect): The agent disconnects and
closes the port when it has successfully sent the message.
4.4 Autonomous Collaborative Agents Application
We then apply the task and message exchanges to the EPMP
domain. To facilitate readability, we represent the tasks and
message exchanges for each agent as T#X and E#X
respectively, where # is the task or message exchange
number and X refers to the agents C, M, or L. A message
from an agent is represented by µ#SR, where # is the message
number, S is the sender of the message µ, and R is the
receiver. S and R refer to the agents C, M, or L. For
system’s tasks, CN#X refers to the task an agent performs to
enable connection to a port and DCN#X indicates a
disconnection task.
We extend the state of the environment to include
systems’ parameters that enable agents to closely monitor
the actions of its human counterpart. The side effect of this
ability is improved autonomy for agents to make correct
(IJCNS) International Journal of Computer and Network Security,
Vol. 1, No. 2, November 2009
decision as well as improved ability to implement one-to-
many and many-to-many message exchanges, e.g.
inform_all message.
Based on the analysis of Section 4.2, we create the
interaction sequence between the agents. However, due to
space limitation and the complexity of the ensuing
interactions, we only show sample interactions between the
Committee (C) and the Lecturer (L) agents:
1. Agent C
CN1C : Agent C opens port and enables connection
when a start date is satisfied.
E1C : C sends a message µ1CL, to L – PREPARE
examination paper.
- Agent L sends an ACK message, µ1LC.
- Agent C reads the ACK, checks the ontology
and understands its meaning.
- If ACK message is not received, it sends
offline message.
T1C : Agent C registers the action and the date.
T2C : Agent C calculates the merit or demerit point
and saves it for Head of Department’s
evaluation.
DCN1C : Agent C disables connection and closes the
port.
When Agent C decides to send a remind message it will
perform the following:
CN2C : Agent C connects to Agent L
- Agent C makes this decision by checking its
environment (the date, status of uploaded
file and notice in subprograms).
E2C : C sends a REMIND message to Agent L
- Agent L receives the message and display on
its screen to alert its human counterpart.
DCN2C : Agent C disconnects and closes the port when
it completes the task.
2. Agent L
CN1L : Agent L opens port and enables connection
when it receives the message from Agent C.
- Agent L makes this decision by checking its
environment (message signal).
- Agent L reads the performative PREPARE,
checks the ontology and understands its
meaning.
E1L : Agent L replies with a message µ1LC, to C –
ACK.
T1L : Agent L displays the message µ1CL, on the
screen to alert its human counterpart.
T2L : Agent L opens and displays a new Word
document on the screen.
- Agent L opens a new document to signal its
human counterpart to start writing the
examination paper.
T3L : Agent L opens and displays the Word
document of the Lecturer form on the screen.
- Agent L opens the form which contains the
policy to follow.
DCN1L : Agent L disconnects and closes the port.
When the human Lecturer uploads a completed
examination paper via an interface, agent L checks its
 (IJCNS) International Journal of Computer and Network Security, 73
Vol. 1, No. 2, November 2009

environment (status of uploaded file and the deadline). committed to carry out. The agent’s intention results
Agent L will decide to send a message: from its belief and a goal to achieve. Consequently, the
agents will take actions such as sending Prepare
E2L : Agent L sends a message µ2LM, to M –
message, remind message, etc.
REVIEW examination paper.
We show four samples of performatives used in the
- Agent M sends an ACK message, µ1ML.
- Agent L checks the states of the framework (Prepare, ACK, Review, Remind). The
environment. communicative act definitions for each of these
T4L : Agent L registers the action and the date. performatives are as follows:
T5L : Agent L calculates and saves the merit or • Prepare: The sender advises the receiver to start prepare
demerit points. examination paper by performing some actions to enable
its human counterpart to do so. The content of the
5. Systems Simulation and Testing message is a description of the action to be performed.
We simulate the EPMP using Win-Prolog and its extended The receiver understands the message and is capable of
module Chimera, which has the ability to handle multiagent performing the action. Prepare performative is time-
systems [22]. We use Prolog for two reasons: Firstly, Prolog dependent.
is well suited for expressing complex ideas because it
prepare(
focuses on the computation’s logic rather than its mechanics
':sender', committee,
where the drudgery of memory allocation, stack pointers,
':receiver', lecturer,
etc., is left to the computational engine. Reduced drudgery
':reply-with', task_completed,
and compact expression means that one can concentrate on
':content', start_prepare_examination_paper,
what should be represented and how. Secondly, since Prolog
':ontology', word_documents,
incorporates logical inferencing mechanism, this powerful
':language', prolog )
property can be exploited to develop inference engines
specific to a particular domain.
Chimera provides the module to implement peer-to-peer • ACK: The receiver acknowledges the sender that it has
communication via the use of TCP/IP. Each agent is received the message.
identified by a port number and an IP address. Agents send We use acknowledge for message state. If the sender
and receive messages through such configurations. receives acknowledge, it means that receiver is online and
has received the message, otherwise the receiver is offline.
We develop the collaborative process as a multiagent The sender will resend the message in offline mode.
system of EPMP based on the above framework and test the
simulation in a laboratory environment on a Local Area The content of the message is a description of the action
Network. Each of the agents C, M and L run on a PC to be performed, which the receiver understands and is
connected to the network. The simulation executes capable of performing. ACK performative depends on the
communication based on the tasks outlined in Section 4.4. receiving message signal.
For message development, we use the parameters specified ack(
by the FIPA ACL Message Structure Specification [4]. We ':sender', committee,
include the performatives, the mandatory parameter, in all ':receiver', lecturer,
our ACL messages. We also define and use our own ':in-reply-to', task_completed,
performatives in the message structure, which are Prepare, ':content', acknowledge_message,
Check, Remind, Review, Complete, Modify, ACK, ':ontology', message,
Advertise, and Inform_all. To complete the structure, we ':language', prolog )
include the message, content and conversational control
parameters as stipulated by the FIPA Specification. • Review: The sender advises the receiver to review the
examination paper by performing some actions to enable
The communication between agents is based on the BDI its human counterpart to do so.
semantics as defined by FIPA [6]. The BDI semantics gives The content of the message is a description of the action
the agents the ability to know how it arranges the steps to to be performed, which the receiver understands and is
achieve the goal: capable of performing. Review performative depends on the
• Belief: When the agent wants to send a message, it deadline and status of uploaded file.
checks its belief of which agent can perform the required review(
action. ':sender', lecturer,
• Desire: Achieving the goal completely will be the desire ':receiver', moderator,
of all agents. The agents will never stop until it has ':reply-with', task_completed,
achieved the goal. The agent’s goal is to complete the ':content', review_examination_paper,
examination paper preparation and moderation and it ':ontology', word_documents,
will know this from Committee agent’s final message. ':language', prolog )
• Intention: Intentions are courses of action an agent has • Remind: The sender advises the receiver to perform a
74 (IJCNS) International Journal of Computer and Network Security,
Vol. 1, No. 2, November 2009

very important task, e.g. to submit Set A or Set B. examination_paper:-

Remind performative depends on the deadline, status of absolute_file_name( system(ole), File ),
uploaded file and notice in subprograms. ensure_loaded( File ),
ole_initialize,
remind( ole_create( word, 'word.application' ),
':sender', committee, ole_get_property( word, documents, [],
':receiver', lecturer, WordDocuments ),
':reply-with', task_completed, assert( my_object(word_documents,WordDocuments)
':content', remind_message, ),
':ontology', message, ole_put_property( word, visible, -1 ),
':language', prolog ) my_object( word_documents, WordDocuments ),
absolute_file_name( ('C:\database\Examination
We reproduce below the sample codes that implement a Paper.docx'), FileName ),
communicative act to inform the committee agent that the ole_function( WordDocuments, open, [FileName],
EPMP process has been completed: SecondDocument ),
complete_lecturer_dialog_handler :- assert(
agent_link( Agent, Link ), my_object(second_document,SecondDocument) ).
Complete =
complete( To test the collaborative system, we deploy human actors
':sender', lecturer, to perform the roles of Committee, Lecturer and Moderator.
':receiver', committee, These people communicate with their corresponding agents
':reply-with', task_completed, to advance the workflow. An interface for each agent
':content', complete_prepare_examination_paper, provides the communication between human actors and
':ontology', word_documents, agents (see Figure 5).
':language', prolog ), nl,

agent_post( Agent, Link, Complete),

nl,check_points,
open('c:\4',append),
tell('c:\4').

For ontology development, we implicitly encode our

ontologies in the actual software implementation of the
agent themselves and thus are not formally published as an
ontology service [5]. The sample codes below show the
ontology implementation after the Committee agent (C),
receives the Complete message from the Lecturer agent (L):
committee_handler(Name,Link,complete(|Args) ):-
committee_dialog_handler( (committee,1006),
msg_button, _, _ ),
repeat, wait( 0 ),
( complete_prepare_examination_paper ),
fipa_member( ':sender', From, Args ),
fipa_member( ':reply-with', ReplyWith, Args ),
committee_reply( Name, From, ReplyWith, done,
Reply ),
agent_post( Name, Link, Reply ),
timer_create( clock3, clock_hook3 ),
timer_set( clock3,1000).
% ontology call
complete_prepare_examination_paper:-
repeat, wait( 0 ),
committee_ acknowledge_remot_agent,
examination_paper,
committee_form,
committee_message.
Due to space limitation, we will only show the ontology
for examination paper.
Figure 5. A Lecturer Agent Interface
The test produces the following results: On the set date,
the Committee agent sends the Prepare message to the
Lecturer agent. The Lecturer agent acknowledges the receipt
of the message and then shows the message on the screen
for its human counterpart. It then opens a new Word
document for the examination paper and another document
displaying the guidelines for preparing the examination
paper. While the human lecturer simulates the preparation
of the examination paper, the Committee agent sends a
reminder to the Lecturer agent which displays the reminder
on the screen for the human lecturer. When the human
lecturer uploads the completed examination paper with its
user interface (see Fig. 5), its lecturer agent checks the date,
calculates the merit/demerit points and sends the Review
message to the Moderator agent.
The Moderator agent acknowledges the receipt of the
message, displays the message on the screen for its human
counterpart, and opens the examination paper and the
moderation form. While the human moderator simulates the
moderation of the examination paper, the Committee agent
 (IJCNS) International Journal of Computer and Network Security, 75
Vol. 1, No. 2, November 2009

sends a reminder to the Moderator agent which displays the Table 2: Comparison between Manual and Automated
reminder on the screen for the human moderator. When the (Agent-based) Systems
human moderator uploads the completed moderation form Features Manual Automated
and the moderated examination paper with its user interface, Human cognitive load High Reduced
its agent checks the date, calculates the merit/demerit points Process tracking No Yes
and sends the Check message to the Lecturer agent. Merit/demerit system No Yes
Reminder/alerting No Yes
The Lecturer agent acknowledges the message, displays Offline messaging Not applicable Yes
the message on the screen for its human lecturer and opens Housekeeping Inconsistent Consistent
the moderated examination paper and the completed Document submission Human-dependent Immediate
moderation form. The human lecturer checks the Feedback Human-dependent Immediate
moderation form to know if there are corrections to be
made. In this test, we do not simulate any corrections. The 6. Conclusions and Further Work
human lecturer then uploads the moderation form and the In this research, we developed and simulated a collaborative
moderated examination paper. Its agent then checks the framework based on the communication between agents
date, calculates the merit/demerit points and sends a using the FIPA agent communication protocol. We
Complete message to the Committee agent. demonstrated the usefulness of the system to take over the
The Committee agent acknowledges the message, timing and execution of scheduled tasks from humans to
achieve a shared goal. The important tasks, i.e. preparation
displays the message on the screen for its human
and moderation tasks are still performed by humans. The
counterpart and opens the Committee form and the
agents perform communicative acts to other agents when the
moderated examination paper. The human committee then tasks are completed. Such acts help reduce the cognitive
uploads the moderated examination paper to the EC Print load of humans in performing scheduled tasks and improve
File. The Committee agent then sends an inform-all the collaborative process.
message to all agents that the EPMP process is completed. Our agents are collaborative and autonomous, but they are
This simulation shows that with the features and not learning agents. In our future work, we will explore and
autonomous actions performed by the agents, the incorporate machine learning capabilities to our agents. The
collaboration between human Committee, Lecturer and agents will learn from previous experiences and enhance the
Moderator improves significantly. The agents register dated EPMP process.
actions, remind humans about the deadlines, advertise all
agents if there is no submission when the deadline has References
expired, and award/penalize merit/demerit points to
humans. [1] Ahmed M., Ahmad M. S., Mohd Yusoff M. Z., A
review and development of Agent Communication
The human's cognitive load is reduced when the deadlines Language, Electronic Journal of Computer Science
of important tasks and documents' destinations are ignored. and Information Technology (eJCSIT), ISSN [1985-
This is alleviated by the consistent alerting services provided 7721], Vol. 1, No. 1, pp. 7 – 12, May 2009.
by the agents that ensure constant reminders of the [2] Chen J. J-Y., Su S-W., AgentGateway: A
deadlines. communication tool for multiagent systems,
Information Sciences, Vol. 150 Issues 3-4, pp 153 –
All these actions and events are recorded in the agent 154, 2003.
environment to keep track of the process flow, which [3] Finin T., Fritzson R., McKay D., McEntire R., KQML
enables the agents to resolve any impending problems. The as an Agent Communication Language, Proceedings
ease of uploading the files and the subsequent of the Third International Conference on Information
communicative acts performed by agents and between and Knowledge Management (CIKM '94), 1994.
agents contribute to the achievement of the shared goal, i.e. [4] FIPA ACL Message Structure Specification:
the completion of examination paper preparation and SC00061G, Dec. 2002.
moderation process. [5] FIPA Ontology Service Specification: XC00086D,
Aug. 2001
As such, we believe that the use of agent-based system [6] FIPA Communicative Act Library Specification
has provided some evidence that the problems of lack of SC00037J 2002/12/03.
enforcement, lack of reminder of time critical tasks and [7] Fleurke M., Ehrler L., Purvis M., JBees – An adaptive
delays in response suffered by the manual system have been and distributed framework for workflow systems,
addressed. Table 2 compares the features between the Proc. IEEE/WIC International Conference on
manual and the agent-based systems and highlights the Intelligent Agent Technology, 2003, Halifax, Canada.
improvements. [8] Fox M. S., Gruninger M., On Ontologies and
Enterprise Modelling, Enterprise Integration
Laboratory, Dept. of Mechanical & Industrial
Engineering, University of Toronto.
76 (IJCNS) International Journal of Computer and Network Security,
[9] Genesereth M. R., Ketchpel S. P., Software agents,
Communication of the ACM, Vol.37, No.7, July
1994.
[10] Gruber T. R., A Translation Approach to Portable
Ontologies, Knowledge Acquisition, 5(2):199–220,
1993.
[11] Guarino N., Giaretta P., Ontologies and Knowledge
Bases: Towards a Terminological Clarification. In N.
Mars, Editor, Towards Very Large Knowledge Bases:
Knowledge Building and Knowledge Sharing, pages
25–32. IOS Press, Amsterdam, 1995.
[12] Guerra-Hernandez A., El Fallah-Seghrouchni A.,
Soldano H., Learning in BDI Multi-agent Systems,
Universite Paris, Institut Galilee.
[13] Heflin J. D., Towards The Semantic Web: Knowledge
Representation in a Dynamic Distributed
Environment, PhD Dissertation, 2001.
[14] Labrou Y., Finin T., Semantics for an Agent
Communication Language, PhD Dissertation,
University of Maryland, 1996.
[15] Muehlen M. Z., Rosemann M., Workflow-based
process monitoring and controlling – technical and
organizational issues. Proc. 33rd Hawaii International
Conference on System Sciences, 2000, Wailea, IEEE
Press.
[16] Pasqueir P., Chaib-draa B., Agent communication
pragmatics: The Cognitive Coherence Approach,
Cognitive Systems Research, Vol. 6 Issue 4, pp 364 –
395, 2005.
[17] Payne T. R., Paolucci M., Singh R., Sycara K.,
Communicating agents in open multiagent systems,
First GSFC/JPL Workshop on Radical Agent
Concepts (WRAC), 2002.
[18] Perrault C. R., Cohen P. R., Overview of planning
speech Acts, Dept. of Computer Science University of
Toronto.
[19] Savarimuthu B. T. R., Purvis M., Fleurke M.,
Monitoring and controlling of a multiagent based
workflow system. In Proc. Australasian Workshop on
Data Mining and Web Intelligence (DMWI2004),
Dunedin, New Zealand. CRPIT, 32. Purvis, M.,
Ed.ACS. 127-132.
[20] Searle J. R., Kiefer F., Bierwisch M. (Eds.): Speech
act theory and pragmatics, Springer, 1980.
[21] Wang M., Wang H., Intelligent agent supported
workflow monitoring system, CAISE 2002, LNCS
2348, 787-791.
[22] http://www.lpa.co.uk/chi.htm.
Vol. 1, No. 2, November 2009
Authors Profile
Moamin A. Mahmoud received his B.Sc. in
Mathematics from the College of
Mathematics and Computer Science,
University of Mosul, Iraq in 2008. Currently,
he is enrolled in the Master of Information
Technology program at the College of
Graduate Studies, Universiti Tenaga
Nasional (UNITEN), Malaysia. During his
studentship at UNITEN, he conducted
additional laboratory work for degree students at the College of
Information Technology. His current research interests include
software agents and multiagent systems.
Mohd S. Ahmad received his B.Sc. in
Electrical and Electronic Engineering from
Brighton Polytechnic, UK in 1980. He
started his career as a power plant engineer
specialising in Process Instrumentation and
Control in 1980. After completing his MSc
in Artificial Intelligence from Cranfield
University, UK in 1995, he joined UNITEN
as a Principal Lecturer and Head of Dept. of
Computer Science and Information Technology. He obtained his
PhD from Imperial College, London, UK in 2005. He has been an
associate professor at UNITEN since 2006. His research interests
includes applying constraints to develop collaborative frameworks
in multi-agent systems, collaborative interactions in multi-agent
systems and tacit knowledge management using AI techniques.
Mohd Z. M. Yusoff obtained his BSc and
MSC in Computer Science from Universiti
Kebangsaan Malaysia in 1996 and 1998
respectively. He started his career as a
Lecturer at UNITEN in 1998 and has been
appointed as a Principle Lecturer at UNITEN
since 2008. His has produced and presented
more than 40 papers for local and international conferences. His
research interest includes modeling and applying emotions in
various domains including educational systems and software
agents, modeling trust in computer forensic and integrating agent
in knowledge discovery system.