Introduction

AgenTalk is a language for describing coordination protocols for multiagent systems. It is co-developed by NTT Communication Science Laboratories and Ishida Laboratory, Department of Information Science, Kyoto University.

Background

In multiagent systems, achieving coordination among autonomous agents is a major problem. Generally, a high-level protocol needs to be designed to achieve effective coordination. In the field of distributed artificial intelligence, protocols for achieving coordination have been proposed, such as the contract net protocol (1) for task allocation, and the multistage negotiation protocol (2) for resource allocation under global constraints. These protocols have been further customized to suit various application domains. In addition, as software agents proliferate, demand for customized protocols will increase.

In order to facilitate the development of multiagent coordination protocols, we designed a new language called AgenTalk. AgenTalk is not meant to be a formal specification language; rather it is meant to be a programming language capable of implementing protocols and agents behaving according to the protocols.

AgenTalk is used in implementing the agent network called Socia, whose goal is to realize a teleorganization.(3) On Socia, a desktop teleconferencing support system was developed.

Design Policy

• Explicit state representation of a protocol. An extended finite state machine which allows variables is used as a basis to describe coordination protocols. We call the representation of this state machine a script (see section Script). Using this model, states of a protocol are explicitly defined, and actions of an agent can easily be defined for each state.
• Incremental protocol definition. By introducing an inheritance mechanism in the definition of a script, protocols can be defined incrementally by extending existing scripts. For example, once a script of the contract net protocol is defined, the multistage negotiation protocol, which can be viewed as a generalization of the contract net protocol, can be defined inheriting most of the contract net protocol.
• Easy protocol customization. A programming interface is defined which specifies the portion of a state transition rule that possibly needs to be customized for each agent. By using this interface, a strategy of an agent can be described.
• Conflict resolution between coordination processes. A single agent may be involved simultaneously in multiple coordination processes (e.g., different task allocation processes), between which some interactions exist (e.g., the agent's resources are shared). By allowing multiple scripts to be executed in an agent, and supporting communication between these scripts, a conflict resolution mechanism between coordination processes can be described.

Execution Model

In AgenTalk, an agent is regarded as an entity which has its unique name, and can send and receive messages. A message's receiver (address) is specified by a receiver agent's name.

An agent basically takes an action when a message is received. A message handler specifies the action to take when a particular message is received. In AgenTalk, a message is specified as message pattern (see section Message Pattern). Primitives for defining a message pattern and its associated message handler are provided.

In addition, a state in the coordination process can be explicitly represented (see section Design Policy). From the viewpoint of a message handler, the state defines a set of messages that can be handled and how the messages are handled. It can be viewed that message handlers are added and removed dynamically when a state transition occurs. A script interpreter automatically updates the message handlers according to the script which is the representation of a finite state machine in AgenTalk (see section Script).

Implementation

Supported Lisp

The version 1.1.x of AgenTalk is implemented in Common Lisp, and Common Lisp primitives are readily available. Currently Allegro Common Lisp (ACL) version 4.2 and Macintosh Common Lisp (MCL) 3.0p2 and 3.9 are used in order to utilize a multi-process (thread) extension of Lisp. Each agent is implemented as a process (thread) in a Lisp system.

Agents communicate with each other using shared memory if they are in the same Lisp system. Agents use TCP connections to communicate with agents in different Lisp systems.

The runtime support facility written in C, which provides basic message handling functionalities of AgenTalk, is included for enabling existing applications (written in C) to communicate with lisp-based agents in AgenTalk (see section Runtime Facility (in C)).

Package

In the Lisp implementation, the following packages are used.

• agentalk (nickname at): Supported functions, methods, etc. are defined in this package and exported.
• agentalk-user (nickname atu): The default package in which application programs are usually written. This package `uses' the agentalk package.
• agentalk-message (nickname atm): A message class name and its slot names are interned in this package. (This is to minimize problems when reading a message from another Lisp system by restricting the package to be used for a message class.)
• agentalk-internal (nickname ati): Internal functions, methods, etc. are defined in this package.