Scott Briening

Intelligent software agents have received a great deal of attention recently in artificial intelligence research. The definition of agents is just as unstable as the definition of artificial intelligence, in that no one seems to agree on what exactly should be considered an agent, and what should not be. The shear number and diversity of applications in which agent technology may be applied is the primary reason for this lack of a concise and stable definition. This paper will first explore what it is that separates intelligent agents from other approaches. Then the many different types of agents will briefly be categorized in order to further illustrate how agents are a solution for many development issues, not only for artificial intelligence. Finally, I will discuss research that is currently underway in the application of intelligent agents to computer war game playing.

With the increase in the adoption of the object oriented programming paradigm in combination with distributed computation, intelligent agents have become a popular solution for application development. Agents are usually implemented as an object in a high level language, whose data members and functions are private to that agent. Agents can communicate with other agents by passing messages to each other. Each agent has one simple and specific task for which it was designed to perform. After performing this task it may transmit certain results (in the form of a message) to other agents. The agent that received the message would then in turn perform their one specific task on that data. This allows for an extremely clean, modular approach to software design. However, it is important to note that this does not make these agents 'intelligent agents'. This is a part of the definition problem. Currently, any software that is broken down into specific modules that implement message passing is considered an agent-based approach. Software implemented with agents may seem to be "smarter" than monolithic software packages, but this is only a byproduct of their coordinated, distributed effort. However, a distinction between intelligent agents and ordinary modular, class-based, message passing software can be made with the presence of a representation of knowledge internal to or shared amongst the agents.

The research branch of British Telecom Incorporated has done a large amount of intelligent agent research. They have broken down agents into four primary categories: smart agents, collaborative learning agents, collaborative agents, and interface agents. Smart agents exhibit cooperation, learning, and autonomous abilities; collaborative learning agents exhibit learning and cooperation abilities; collaborative agents exhibit cooperation and autonomous abilities; interface agents exhibit learning and autonomous abilities. In addition to these primary categories, agents can be either mobile or static; i.e., they stay on one system or move about a network, respectively. This categorization of agents is not formally accepted, but is just as good of a division system than any other. Of these four categories, not all are suited for intelligent agents. For example, an interface agent may serve as a language or protocol translator, and may not interact with any other agent (unless of course, some agent is producing or consuming the translated data.)

The Experimental Knowledge Systems Laboratory at the University of Massachusetts is currently exploring the possibilities of intelligent agents. Their purpose is written as follows:

This group is currently experimenting with an agent based war game simulation, originally conceived by DARPA as a "master tactician in a box. (EKSL)". In this simulation, a human player can compete against the computer in a game of capture the flag. (It can also be configured for two human players or two computer players.) The computer player is of course agent based, using the GRASP planner (which is discussed later). The simulation takes physical (collisions, deformations, impassable objects, etc.) as well as psychological (fear, moral, fatigue, etc.) considerations into account in order to allow for the most accurate simulation possible. The game board is pseudo-three dimensional. (I.e., a two dimensional plane is used, but height is only binary - you can either be on the ground or on a hill. Each hill is the same height.) Players have both land battalions and air support at their disposal.

There are three primary modules which constitute this simulation program. The Abstract Force Simulator (AFS) abstracts this war game to a high level and handles simulating the physical reaction between game elements. Each entity in the game state is represented as a 'blob' which has certain physical properties. Each section of terrain has properties such as the amount of friction, which determines how quickly a 'blob' can move across that space. The Hierarchical Agent Control (HAC) module is dubbed as a "general toolkit for designing an action hierarchy". This toolkit is used to manage the behavior of a large number of interacting agents. The General Reasoning using Abstract Physics (GRASP) Planner is a technology that is used to represent dynamic activities and help agents make better informed decisions about how to win the game. Using all of these modules together allows for an extremely accurate representation of a real world environment for game play (EKSL, flag project homepage).

The AFS is a major component of the system, but was not designed particularly for this system. It can just as easily be used to simulate a billiards game. It is dubbed as "a dynamical analog of a chessboard." This game board representation is displayed to the user using a GUI. When a player wishes to make a move, the AFS sends a command directive to the HAC, which handles actually carrying out the move. The AFS's high level of object abstraction can be seen with the way it represents battalions. Rather than each vehicle being simulated individually, a whole group is simulated as a 'blob' that moves around the battlefield with certain characteristics. This blob has certain properties which govern its operation. For instance, a blob containing sparsely placed internal tank units may have to become more dense or deform into a line in order to pass an obstacle.

The HAC is used to control the large number of agents in the game space in an orderly fashion. It allows for a set of complex interactions to be defined and then carried out within the AFS. When the HAC receives command directives (from either the human player or the GRASP planner) it uses knowledge of the environment to carry out the order. For instance, a player may order a battalion to the other side of a lake. Since the lake is an impassable object, the HAC must move the battalion around the lake rather than though it. The HAC is also responsible for being the "eyes and ears" of the individual units in that it must make sure that the appropriate information is passed amongst the units. Units are aware of other units only if they are within visual range, or have been spotted by an air reconnaissance unit. This balance between public and private knowledge is key to the accurate simulation of a battlefield environment. The HAC uses a complex command hierarchy with complex commands at the top and the simple commands that these rely on at the bottom. For instance, an action of 'move-to-point' is requested. A direction in which to head is computed, and another move-to-point operation is issued (in the form a an agent) for a short distance over this vector, which uses the child primitive 'move'. This child operation has to deal with obstacles in its path. After that has completed, knowledge gained from the move is passed back up to the parent, which issues another move-to-point operation a short distance. This process continues until the move has completed (Hierarchical Agent Control, Atkin).

The GRASP planner is the 'brain' that governs the computer's moves. GRASP determines which directive should be carried out in order to gain a better position in the game. Just as directives are sent from a human player to the HAC to carry out in the AFS, computer directives are formulated by GRASP and sent to HAC to be carried out. Instead of being a set of static rules, GRASP takes time spans into account. Physical abstractions are again used within GRASP, allowing the computer to make complex decisions on the battlefield, which are then carried out at a low level with HAC. Perhaps the most interesting feature of GRASP is its use of a dynamic state space. In classical AI solutions progression through a game is accomplished by moving from a state to another state (hopefully closer to the goal state) by the use of operations. However, GRASP does not use a predefined state space. Rather, states are generated dynamically during game play. This course of action was taken because if the states were defined to be too complex, then the problem become intractable. If the states were defined to be too general, then interesting points in the game may be passed over, thereby reducing the computer's ability to play the game well (Atkin, search spaces).

The capture the flag project is a perfect example of how intelligent agent technology can be used to create a dynamic and accurate war game simulation, in which the computer player is quite frequently unbeatable. The project is modular on many different levels, allowing for simple redefinition of the problem. Its modularity starts with the division of the program into the pieces discussed (AFS, HAC, and GRASP planner). The AFC and HAC are so modular, in fact, that they could just as easily be used to simulate a billiards game. A substitute to GRASP would have to be designed that chose a good shoot rather than a good tactical decision. The HAC has internal agent modularity that allows for the redefinition of complex actions from simpler primitives. If it were to be modified for a billiards simulation, an example of a complex move might be one named 'defensive-hit'. Its child actions would be the same primitives used in the war game simulation (e.g.: 'move'). The modularity inherent in intelligent agent technology will allow for complex AI systems to be built using piece-wise, abstracted solutions, as this example perfectly illustrates.

EKSL homepage(http://eksl-www.cs.umass.edu/research/ctf/)

Marc S. Atkin and Paul Cohen. 2000. Using Simulation and Critical Points to Define States in Continuous Search Spaces. (http://www-eksl.cs.umass.edu/papers/atkin-wsc12000.pdf)