Multi-Agent Systems Case Study:
Effects of Inter-Agent Communication in the Predator-Prey Domain
Timothy P. Rew
Advisor: Dr. Susan Conry
Clarkson University
Dept. of Electrical and Computer Engineering
Potsdam, NY 13699
Rationale:
Before you can grasp the effects of agent interaction in a "real-world" application, you
need to understand the concept of a domain. This is because studying agent interaction in a realworld multi-agent system would be extremely difficult due to the shear number of agents and lack
of direction (think of the internet). For that reason, we study it instead in small, controlled, and
directed test-beds, or "toy domains". In my case, that domain is the predator-prey or "pursuit"
domain. My research goals were to design, develop, and implement a working multi-agent
systems[l] test-bed application[2], and from there move on to studying actual agent
communication.
I've been working on this "Multi-Agent Systems case study" the past two years here at
Clarkson, and I feel I have a good understanding of agents and agent communication. I have
designed several experiments in an effort to gain some insight not only into the pursuit domain
itself but also into agent interaction in general.
Once these experiments are performed, I hoped to be able to develop a solid
communication heuristic to use in comparing communicating agents with non-communicating
agents, in order to determine if the benefits of communication were able to overcome a
disadvantage such as a limited view of the universe.
Objectives:
1. Design and implement a working test-bed application for studying agent communication in a
multi-agent system. The test bed will be JAVA-based simulation of a predator-prey
relationship in a simplified universe (in this case a grid of squares).
2. Once the test-bed is up and running, use it to compare several different strategies of
communication to determine which are most effective in a particular problem-solving
situation.
3. Choose one communication heuristic, and compare it to a benchmark scenario of noncommunicating agents to determine if communicating agents can overcome a limited world
view to perform comparably to non-communicating agents with complete world views.
Expected Outcome:
1. Completion of the Java testbed application, with autonomous agents.
2. Successful embedding of KQML software into project, to facilitate agent communication.
3. Experimental data based on experiments designed to compare communication strategies.
4. Solving of the scenario involving communication vs. no communication, to determine
whether communicating agents can overcome a physical limit (in this case a limited view of
the universe) to solve a problem (capturing the prey) in a comparable fashion to the noncommunicating agents, who do not suffer the same physical limit.
Time Table:
Summer 2001

Familiarization with multi-agent systems, through literature on the topic.

Completion of java application with autonomous agents.

Familiarization with KQML language and syntax, as well as the JATLite implementation.

Design several experiments to compare agent-communication strategies.
Spring 2002

Successfully integrate JATLite implementation of KQML into testbed application.

Write experiment-specific agent-communication code fore each experiment.

Run experiments, and collect data for different strategies.

Write scenario specific code for both non-communicating/complete worldview and
communicating/incomplete worldview scenarios.

Draft final report and present findings.
Overview:
The domain I have chosen to study is what is called a “pursuit game”. It involves
multiple predator agents, whose goal is to chase and capture prey agents. The prey agents’ goals
are to either simply evade the predator for a period of time, or to find and enter a goal square
before they are captured. Both predators and prey cooperate to solve their “goals” [3]. The game
takes place on an arbitrarily sized grid of squares.
Each predator or prey agent was completely autonomous at first. This was achieved by
defining a class both for predators, and for prey. These classes were written in JAVA, along with
a Graphical User Interface for initialization of the "game". Each new agent is simply an instance
of one of these classes. Each class contains a set of functions, which will comprise the
intelligence and functionality of the agents built off of that class.
Although initially autonomous, the predator and prey agents were later given the ability
to communicate, through functions based on an Agent Communication Language (ACL)[4]. The
ACL I decided to use to implement these functions is called Knowledge Query Manipulation
Language, or KQML [5]. KQML is a language and a set of protocols that support software agents
in identifying, connecting with, and exchanging information with other agents. KQML was
developed by the Knowledge Sharing Effort (KSE), which is sponsored by the Advanced
Research Projects Agency (ARPA). The ARPA KSE is a large-scale effort aiming to build sizable
knowledge bases which are sharable and reusable.
The particular implementation of KQML that I made use of is JATLite, a JAVA specific
KQML Application Program Interface developed at Stanford University [6].
The agent-communication functions I developed were used to experiment with several
different communication strategies, and often needed to be tailored or expanded upon in order to
accommodate each new strategy. I tested each strategy against a control in order to determine if it
is a) useful at all, and b) more useful than other strategies for accomplishing similar goals.
Literature Search:
1. An article from the Crossroads electronic magazine- Towards a Standardization of
Multi-Agent System Frameworks. This was an informative paper on the reasons for and need for a
standardized agent communication framework. It also gave detailed overviews of agents and
multi-agent systems.
2. A paper by Brant A. Cheikes- GIA: An Agent-Based Architecture for Intelligent Tutoring
Systems. This paper offered a detailed example of one use of multi-agent systems: an intelligent
tutoring system. This provided another perspective on multi-agent systems, that of a real-world
application.
3. A volume in IEEE Transactions on Knowledge and Data Engineering- Trends in Cooperative
Distributed Problem Solving. This was a somewhat exhaustive work on the entire concept of
multi-agent systems and their use in problem solving environments.
4. A joint work by members of the University of Maryland Computer Science Department and
Unisys Corporation- KQML as an Agent Communication Language. This document outlined the
role of KQML in agent communication, as well as giving an overview of the architecture of the
language itself.
5. Another University of Maryland paper, this one by Yannis Labrou- Proposed KQML
Specification Document. This document, while stating that it is not the official specification,
basically covers all of the aspects of the KQML language.
6. A guide written for Stanford University's JATLite software- JATLite Application Programming
Interface User's Guide. This is exactly what it claims to be, the user's guide for the JATLite API.
It covers the structure of the API, including its organization into five layers, and a description of
the JATLite router.
References:
1. Crossroads Towards a Standardization of Multi-Agent System Frameworks. 1999. Web
page: http://www.acm.org/crossroads/xrds5-4/multiagent.html
2. Cheikes, B. GIA: An Agent Based Architecturefor Intelligent Tutoring Systems. The
Mitre Corporation, Artificial Intelligence Center, Bedford, MA. Web page:
http://www.mitre.org/resources/ centers/it! g068/ gia - more.html
3. Durfee, E., Lesser, V., and Corkill, D. Trends in Cooperative Distributed Problem
Solving. In: IEEE Transactions on Knowledge and Data Engineering, March 1989,
pages 63-83.
4. Finin, T., Fritzson, R., McKay, D., and McEntire, R. KQML as an Agent Communication
Language. Computer Science Dept., University of Maryland Baltimore County,
Baltimore, MD; Valley Forge Laboratory, Unysis Corporation, Paoli, PA.
5. Labrou, Y. Proposed KQML Specification Document. Computer Science and Electrical
Engineering Dept., University of Maryland Baltimore County, Baltimore, MD, October
1996.
6. Stanford University JATLite Application Programming Interface User's Guide. 1996.
Web page: http://iava.stanford.edu/JATLiteBetaRelease/api/ API users guide.html