Multi-Agent Architecture

Other Names

Multi-Agent architectures are also called Agent-Based architectures or Agent-Based systems.

Problem

Open architecture components need to provide higher levels of adaptability, mobility, discovery, and intelligence in order to support applications that exhibit emergent behavior or that need to function in volatile environments. For example, components may need to interact with other components that are unknown at the time the component is implemented. A component may have an open-ended goal such as research companies that sell memory chips. Tto do this the component may need to discover and communicate with other components that have this knowledge.

Solution

A multi-agent architecture can be viewed as a special case of the container-component architecture. In this case the components are agents and the container is an agent environment that provides discovery and communication services to its agents.

An agent is an active goal-oriented component that plays one or more roles in the environment. Each role perpetually executes a control loop such as:

1. Observe state of the environment
2. If environment state = goal state, then quit
3. Select an action
4. Perform action
5. Goto 1

An agent may observe all or part of the environment in step 1. This may involve observing what the other agents in the environment are up to.

Different agents may have different goals.

The action selected in step 3 depends on the observation made in step 1. It may also depend on the internal state of the agent. This internal state could be a simple one-bit memory or a complex knowledge base system.

Performing the action in step 4 modifies the state of the environment. It may also modify the agent's internal state and goals. The action may involve sending messages to other agents.

Structure

The following design summarizes these definitions.

Here's a sketch of how Role might be implemented in Java:

abstract class Role {
Agent host;
abstract public void execute();
abstract boolean isFinished(); // = true if goal achieved
}

An agent perpetually executes its roles:

class Agent extends Thread {
List<Role> roles;
Queue<Message> messages;
int agentID; // unique ID#
public void run() {
while(!roles.isEmpty()) {
for(Role role: roles) {
role.execute();
if (role.isFinished()) {
roles.remove(role);
}
}
}
}
}

Of course new roles can be added to the list of roles. Also, roles may extract messages from their host's message queue and they can add new messages to the message queues of other agents.

Examples of Multi-Agent architectures

There is a standard reference architecture for multi-agent systems called FIPA.

There are several implementations of the FIPA architecture, including JADE and Zeus. Jade has been successfully used to implement commercial applications.

The Semantic Web Services Architecture (SWSA) is couched in the concepts of multi-agent architectures.