Patterns for Adaptive Multi-Agent Systems in
Intelligent Manufacturing
Sudong SHU and Douglas H. NORRIE
Division of Manufacturing Engineering, Department of Mechanical Engineering,
University of Calgary, 2500 University Dr., Calgary, AB, T2N 1N4, CANADA
e-mail : [sdshu | norrie]@enme.ucalgary.ca
Abstract
This paper proposes a set of agent design patterns that can be applied in the development of adaptive
multi-agent systems, particularly in intelligent manufacturing. These agent design patterns can assist
designers to solve common problems in agent design. It has been found that there are six basic agent
design patterns for the particular type of multi-agent system considered. These patterns are for:
metamorphic architecture; mediators; task decomposition; virtual clustering; partial cloning; and
prototyping. The relevance of patterns to the design of the adaptive multi-agent system is first discussed,
then the agent design patterns involved in the system are described.
The objective of this research is to raise reusability in multi-agent system design from the component
to the architecture level. It is also directed towards a design methodology and providing a conceptual
reference to adaptive multi-agent system design.
•
1.Introduction
Manufacturing is currently shifting from mass
production to mass customization. Because of this
trend, the next generation of manufacturing
enterprises should have the ability to respond to
customers’ requests adaptively, dynamically and
rapidly. It is important to develop manufacturing
systems
that
are
modifiable,
extensible,
reconfigurable, adaptable, and fault tolerant.
Intelligent agent-based approaches are considered to
provide a new paradigm for manufacturing
technology (Wooldridge and Jennings, 1994).
Agent-based manufacturing systems can in principle
respond rapidly to changes in the market, and adapt
and adjust to the emergency occurrences in the
manufacturing process.
Although agent technology is considered a
promising field, there are still some issues that
should be investigated. Up to now, an adaptive,
robust and maintainable architecture based on
software engineering principles (such as exists for
object oriented analysis and design, with its use of
patterns), has not yet been formulated (Aridor and
Lange, 1998). Software reusability, in particular, is
still an important problem in the development of
agent based systems. Currently developed multiagent systems have the following problems
(Jennings, 1996):
•
•
Lack of agreed definitions: Agents built by
different teams have different architectures and
capabilities
Effort Duplication: The agent architecture,
designs and components could not be reused
No Software System Development Standard:
Each system has its own software standard and
designs can not transfer easily from one system
to another
In order to apply object design patterns in agent
system design, the relationships and differences
between objects and agents should be first
considered (Kendall, 1994,1997,1998). An object is
a software abstraction with behavior, inheritance,
encapsulation, compound properties, state and
identity. An agent can be considered as and modeled
as an enhanced object that is able to reason and to
collaborate via structured messages. Agents are also
active objects. In a multi-agent system, the agents
each have their own thread of control, and they are
pro-active. An agent-based system can be more
adaptive, robust and flexible than an object oriented
system since the agents in the system have
autonomous and pro-active properties. Part of agent
system’s flexibility is in its openness, which means
that agents can enter and/or exit a society, and they
have the ability to carry out opportunistic problem
solving through various techniques, including
constraint based reasoning, planning, negotiation
and reasoning.
In object oriented systems, design patterns are
flexible, reusable and effective designs (Gamma et
al., 1995). The design pattern concept applied to
multi-agent system design can lead to development
of an open, adaptive, robust and maintainable
software architecture (Aarsten et al.,1995).
Object oriented design patterns can be
fragments of a high-level conceptual model that
may be useful in many software systems, including
multi-agent systems. Using patterns can have three
benefits:
• For Re-use: A designer can bootstrap
himself or herself into better systems by
using the best aspects of a proven earlier
system. Reuse patterns are like logical
design templates that can be adopted from
the earlier system and just require some
configuration or alteration for the new
system.
• For Guidance: Not all patterns are reusable
libraries of O-O classes. Guidance patterns
serve to direct the analyst’s focus to a set of
issues that previous analysts have found
insightful.
• For Communication: Patterns are a useful
tool for explaining existing systems.
Patterns can particularly assist a novice
designer. When they “understand” patterns,
they are capable of comparing and
contrasting a wide range of system designs.
A multi-agent based manufacturing system
incorporates heterogeneous manufacturing agents
within different multi-agent factories or shop floors.
These shop floors carry out concurrent engineering
manufacturing design evaluations by adapting
manufacturing resources to specific needs, through
dynamic organization. Adaption and reconfiguration
is thus a focus of the design patterns presented here.
2.Architecture for Adaptive MultiAgent System
communication mechanisms to find appropriate
agents for establishing collaborative subsystems.
In order to work cooperatively, in this system, a
mediator agent may create a virtual cluster of agents
to collaborate on a task. The main coordination
mechanism is based on mediators which manage
task decomposition and virtual clustering. Resource
agents are also cloned as needed, for concurrent
information processing. These clone agents are
assigned to the virtual coordination clusters, whose
agents negotiate with each other to find the best
solution for a given task.
The Intelligent Machine Architecture (IMA) is
another approach for the design of software system
that could integrate existing models, algorithms and
models (R.T. Pack et al., 1997).
An adaptive agent system should have a strong
design foundation based on masterful software
patterns. A software pattern can address conceptual,
architectural or design levels. A pattern is normally
described in a set format to ease dissemination. In
general, a design pattern format has four essential
elements: 1) a name, 2) a problem and its context,
3) the solution (the objects, their responsibilities,
interfaces, and implementation) and 4) results and
trade-off.
It has been found that there are six basic agent
design patterns involved in the development of
metamorphic adaptive multi-agent systems. These
agent design patterns can be catalogued as two
types. One is the architectural pattern: the
Metamorphic Architecture Pattern. The other
includes these component or method patterns:
Mediator Pattern, Task Decomposition Pattern,
Virtual Clustering Pattern, Partial Cloning Pattern,
and Prototyping Pattern. The relationships between
these agent patterns are shown in Fig.1. At the
architectural level, the metamorphic pattern can be
Task Decomposition Pattern
Leads to using
Mediator Design Pattern
Creates virtual clustering
when mediators use
Virtual Clustering Pattern
is used to add clone to
virtual cluster
An
intelligent
multi-agent
architecture
(MetaMorph) has been previously developed to
address system adaptation and extended-enterprise
issues (Maturana and Norrie, 1996, 1997a). This
metamorphic system uses an agent-based mediatorcentric federation architecture. In this architecture,
each intelligent agent is linked with mediator agents
to find other agents in the environment. Mediator
agents can use brokering and recruiting
Partial Cloning Pattern
is used in creating
a clone
Prototyping Pattern
Metamorphic Architecture Pattern
Fig. 1 Agent Design Pattern Relationship in
Metamorphic Architecture
composed from the low-level component or method
patterns. Through interaction of these low-level
agent patterns, the adaptive behaviour of the system
architecture can be achieved. Following the rules
inherited from the agent patterns, the development
of multi-agent system can meet the desired goal of
reconfigurability.
• A distributed system should satisfy this set of
specific system requirements: heterogeneity,
scalability, reconfigurability and easy
accessibility.
3.1.4 Solution:
3.
Design
Patterns
Metomorphic System
in
a
It is important to describe the agent patterns
involved in the metamorphic system using some
formal specification (Rumbaugh, et al., 1991). In
this section, we will follow a common format to
describe them. The format includes: Context,
Problem, Forces, Solution, Example and Related
Patterns.
3.1 Metamorphic Architecture Pattern
3.1.1 Context:
The multi-agent system should meet the system’s
reconfiguration and adaption demands. But, in large,
distributed systems, it is hard to design and manage
the system development without an architecture.
And it becomes very important to reuse the
architectural and component features at the different
levels of realization. An architecture pattern could
also give guidelines for system development related
to the specific domain.
A
mediator-centric
federation
organization
architecture has been adopted for the metamorphic
system (Maturana and Norrie, 1996, 1997a). There
are two main types of agent in the system: resource
agent and mediator agent. Resource agents are
autonomous and cooperative. Mediator agents are
autonomous, cooperative and self-learning. The
core negotiation mechanism is based on task
decomposition and dynamically-formed agent
groups (clusters).
In this particular type of architecture, intelligent
agents can link with mediator agents to find other
agents in the environment. Mediator agents assume
the role of system coordinators by promoting
cooperation among intelligent agents and learning
from other agent’s behaviors.
Fig.2 shows the conceptual diagram for the
architectural pattern. Fig. 3 shows the structural
elements in the metamorphic agent pattern. Fig. 4 is
the collaboration diagram for the architectural level.
3.1.5 Known Uses:
3.1.2 Problem:
How can the multi-agent system be best
organized and structured in software? What
software system architecture could best support the
behavior of the adaptive multi-agent system? How
to model a multi-agent system that could meet the
domain requirements?
3.1.3 Forces:
•
•
•
•
Metamorphic agent system is complex and
spans several levels of abstraction.
The architecture must encompass all aspects
of agency.
The architecture should be adaptive at both
the architectural and component levels.
The architecture should produce an
organizational structure which allows
changing capability through learning
mechanisms.
ConcreteMediator1
Mediator
VirCluster
Create()
Get_Result()
CNP_Bid()
Sub_VirCluster()
ConcreteMediator2
ConcreteVirCluster
Create
Create()
Get_Result()
Create()
Get_Result()
CNT_Bid()
Sub_VirCluster()
Fig. 2 Participants in the Metamorphic
Architecture Pattern
There are many kinds of multi-agent system
application to which this type of architecture can be
applied, particularly in intelligent manufacturing
(Maturana, 1997b).
3.2.3 Forces:
Create()
Send_Task()
1
ResourceAgentk
Do_Job()
Return_Mess()
1
Prototype
Select_Ratype()
Find_RAtype()
1
Mediator
Send_Task()
Get_Result()
1
1
VirCluster
n
1
n
Initialize()
Need_ParClone()
Do_Job()
ParCloning
Need_Prototype()
Find_Prototype()
Fig. 3 Structure in the Metamorphic
Architectural Pattern
aConcreteMediator
aConcreteVirCluster aConcreteParCloning
aConcretePrototype
ResourceAgent
create
Initialize()
Need_ParClone()
Need_Prototype()
Select_RAtype()
Do_Job()
Find_RAtype()
Find_Prototype()
Join_ParClone()
Get_Result()
Fig. 4 Collaboration in Metamorphic Architecture
Pattern
3.1.6 Related Patterns:
Mediator Pattern, Task Decomposition Pattern,
Virtual Clustering Pattern, Partial Cloning Pattern
and Prototyping Pattern
3.2 Mediator Agent Pattern
3.2.1 Context:
The mediator pattern plays a fundamental role in the
metamorphic architecture. The mediator agent
brings the individual agents together to work
cooperatively to accomplish task requirements.
3.2.2 Problem:
How can agents create static and dynamic
organizational sub-structures and implement
mechanisms for communication and negotiation
within these? How to provide agents with common
techniques for conflict resolution and messages
communication?
• The architecture should have different
levels of task resolution.
• Some problems or sub-problems have a
knowledge-based solution that can be
identified by experts (eg. a specialised
agent).
• A specialised agent is needed to create the
coordination cluster
• This agent should be created prior to and
remain alive during the life cycle of the
cluster.
3.2.4 Solution:
A distributed decision-making support system
needs to be constructed for coordinating the
activities of the multi-agent system. There are three
main phases involved: (1) Subtasking: each higherlevel task entering the system is successively
subdivided into subtasks or partial plans. (2)
Creation of virtual communities of agents: for each
subtask, a coordination cluster is created. Each
agent within a cluster potentially can contribute to
the task. (3) Execution of the processes imposed by
the task: if a task matches the capabilities of an
agent in a cluster, a positive bid is created to initiate
its commitment, and a mediator agent associated
with the cluster can evaluate such bid and assign
responsibilities.
There are three main types of mediator agent:
template mediator, the data-agent manager (DAM),
and active mediator (AM). These coordination
agents interact with each other cooperatively within
a dynamic framework.
Agents and Mediators can form the coordination tuples <Agents, Mediators>. The
resulting organized communities form a dynamic
virtual hierarchy which allows parallel search of the
space of tasks and sub-tasks. Using this approach,
the system doesn’t need to pre-establish the search
domain and maintain all search information
globally.
The participants involved in the mediator
pattern are indicated in Fig. 5. And the collaboration
relationships within the mediator pattern are shown
in Fig. 6.
3.3.3 Forces:
Select_Task()
Pass_Task()
ResourceAgentk
n
Do_Job()
Return_Mess()
1
AM
Distribute _To()
Finish_Job()
Send_Task()
Register()
Remove()
•
1
TempMediator
n
n
1
•
1
Task
1
•
Pass_Message()
Job_Finished()
DAM
Do_Job()
Finish_Job()
The task is divisible into subtasks with the
available knowledge
The decomposition is consistent with higherlevel objectives
The decomposition should relate to a goal and
there are different evaluating attributes to
identify the appropriate goal.
3.3.4 Solution:
Fig. 5 Structure in the Mediator Pattern
aConcreteTask
aConcreteTempMediator
aConcreteDAM
aConcreteAM
ResourceAgent
Send_Task()
Construct()
Pass_Message()
Distribute_To()
Do_Job()
When decomposing the task, there are rules which
should be obeyed. Each sub-task, for example, could
be related to a group of processes. The rules or
procedure for decomposition are here assumed to
be available in a task decomposition database. The
decomposition process may be extended to further
sub-levels according to the system’s requirement.
This overall process is illustrated in Fig. 7.
Finish_Job()
Finish_Job()
Job_Finished()
Task
Goal
Task_Finished()
Task
Decomposition
Search
Return Result
Task Decomp.
Database
Fig. 6 Collaboration in Mediator Pattern
Sub-Tasks
3.2.5 Known Uses
Mediator based applications can be found in
(Maturana, 1996, 1997a) and (Wiederhold, 1992).
Fig.7. Task Decomposition Description
3.4 Virtual Clustering Pattern
3.2.6 Related Patterns
Virtual Clustering Pattern, Prototyping Pattern
3.3 Task Decomposition Pattern
3.3.1 Context:
A large system may involve a complex of tasks and
goals. In order to operate efficiently and
concurrently, the tasks in the system should be
decomposed successively to smaller sub-tasks. After
decomposition, each sub-task should be operated on
cooperatively by the agents in a cluster and in a
manner consistent with the global goal.
3.3.2 Problem:
How to decompose a task to appropriate
subtasks?
3.4.1 Context:
A virtual cluster is created by a mediator agent.
Within the virtual cluster, communication and
interaction within or outside the cluster should be
well managed. The virtual cluster normally only
exists when its task or sub-task is active.
3.4.2 Problem:
How to organize and manage a virtual cluster?
3.4.3 Forces:
•
The task or sub-task request should be
satisfied by those agents potentially able to help
solve it
•
The cluster should be able to expand its
collective ability by aggregation of additional
agents
3.4.4 Solution:
An initial group is formed as a virtual organization
of agents with a specific set of goals. If the agents
in this group can solve the complete task request,
then this is the desired virtual cluster. Otherwise to
solve the incomplete task, the agents search outside
their initial virtual organization and establish
conversation links with other intelligent agents who
can potentially assist. The process above is repeated,
with subclusters being formed for decomposition in
a dynamically interlinked structure.
The collaboration within the virtual clustering
pattern is shown in Fig. 8.
aConcreteSubTask
aConcreteVirCluster
aConcreteSub_VirCluster
Form()
Construct()
Need_SubVC()
Construct_SubVCFinished()
Task_Finished()
3.5.2 Problem:
How can partial attributes and methods of an agent
be copied in creating a new clone which could then
become resident in remote agent societies? Partial
clones may also be needed in the same agent society
as their parents.
3.5.3 Forces:
• An agent must be able to bring its
capabilities, facilities, and state with it to a
new society, when these are necessary to
solve its problem in the new society
• The agent must be able to travel to a remote
location and interact, negotiate, and
exchange information in the new society
3.5.4 Solution
Three kinds of operation can be used: copy, remove,
delete. These operations may be used for the
situation when the clone agent will be joining a
virtual cluster. For the remote situation, make a
partial clone of the original agent, and place the new
agent in the distant society (virtual cluster). The
partial clone must have the necessary portions of the
capabilities and facilities of the original agent, along
with the appropriate state information necessary to
deal with its problems in the virtual cluster.
3.5.5 Related Patterns
Fig. 8 Collaboration in Virtual Clustering Pattern
Prototyping Pattern
3.4.5 Known Uses:
3.6 The Prototyping Pattern
Virtual clustering can be found in metamorphic
systems [Maturana, 1997b]
3.6.1 Context:
3.5 The Partial Cloning Pattern
3.5.1 Context:
Partial Cloning is an important operation within a
metamorphic system. It has some differences to a
standard “copy”. By this operation, the newly
created object can partially have attributes and
methods of the parent. It is essential in some cases
in an agent-based system that only part of one
agent’s capability be independently available at a
particular time of operation. By creating a partial
clone, the system can obtain the extra (limited)
capability where needed and thus work more
efficiently.
The prototyping pattern allows all of the agents in a
system to be created from a limited number of
different prototypes. These prototypes can also be
used with the partial cloning pattern to create
variants of standard agent types to suit particular
task needs.
3.6.2 Problem:
How to model both standard agents and variants of
these agents in a generic way?
3.6.3 Forces:
•
Agent creation is a common need in an agent
system
•
Prototyping is a process which can be used in
creating all kinds of agents.
3.6.4 Solution:
The prototype could be modelled in three different
layers: Specific Functionality, Generic Functionality
Specific Functionality
application field. In the generic functionality layer,
the attributes are those generic ones that would
appear in every agent’s description. The generic
interface layer provides an access between the
prototype and its environment. Messages requesting
the creation of an instance agent with specific
characteristics are received through this interface.
This architecture is shown in Fig. 9.
With this approach, agents in a system can be
represented in a generic way. The prototypes could
be also then used in the partial cloning pattern.
Generic
Functionality
4. Agent Design Patterns
Intelligent Manufacturing
Generic
Interface
Fig.9. Prototyping Description Diagram
To illustrate the application of agent patterns, we
use an example in distributed manufacturing relating
to the ordering of products. The distributed
manufacturing enterprise in this example has a
general manager (CEO), a production planning
centre and two factories. If the CEO gets the
production order first, he will pass this order to the
manufacturing factory. We assume that the product
three parts: X, Y, Z. The example is shown in Fig.
10 and is described in more detail in [Shen and
Norrie, 1999].
and Generic Interface. The specific functionality
layer contains the functionalities that are highly
related to the agent’s special interests in the
Virtual Clustering Pattern
IAF1
IAF2
DM1
C5
Mediator Pattern
TM1
Product Order
C3
DM2
Task Decomposition Pattern
in
Partial Cloning Pattern
RA3
RA1
Prototypng Pattern
RA2
RA3
Fig. 10 Agent Design Patterns in Product Ordering
5. Conclusion
This paper has presented various patterns for use in
adaptive multi-agent systems. Agent design patterns
can accelerate the specification and design of an
agent-based system. This research is aimed at
providing a strong software engineering foundation
for agent based system development.
References
Aarsten, A., G. Elia, and G. Menga.(1995) G++: A
Pattern Language for Computer-Integrated
Manufacturing. in J. Coplien and D. Schmidt
(eds.) Pattern Languages of Program Design.
Addison-Wesley
Aridor, Y. and D. B. Lange (1998) Agent Design
Patterns: Elements of Agent Application
Design, Autonomous Agents '98 (Agents'98),
pp. 108-115
Gamma, E., R. Helm, R. Johnson, and J. Vlissides
(1995) Design Patterns: Elements of Reusable
Object-Oriented Software. Addison-Wesley
Jennings, N.R., P. Faratin and M. Johnson(1996)
Using Intelligent Agents to Manage Business
Processes, First International Conference on the
Practical Application of Intelligent Agents and
Multi-Agent Technology. London, pp.135-143
Kendall, E.A., M.T. Malkoun, and C.H. Jiang(1995)
A Methodology for Developing Agent Based
Systems for Enterprise Integration, EI’95, IFIP
TC5 Working Conference on the Models and
Methodologies for Enterprise Integration, Heron
Island, Australia, Nov., pp.123-134
Kendall, E. A., C. V. Pathak, P. V. Murali Krishna
and C. B. Suresh(1997) The Layered Agent
Pattern Language , Pattern Languages of
Programming (PLOP'97), September, pp.53-63
Kendall, E.A., P.V.M. Krishna, C.V. Pathak and
C.B. Suresh(1998) Patterns of Intelligent and
Mobile Agents, Autonomous Agents '98
(Agents'98),pp.115-122
Maturana. and D.H. Norrie(1996) Multi-agent
Mediator
Architecture
for
Distributed
Manufacturing.
Journal
of
Intelligent
Manufacturing, 7, pp.257-270
Maturana, F. and D.H. Norrie(1997a) Distributed
Decision-Making using the Contract Net within
a Mediator Architecture, Decision Support
Systems, 20, pp. 53-64
Maturana, F.(1997b) Metamorph: an Adaptive
multi-agent
Architecture
for
Advanced
Manufacturing Systems, Ph. D Thesis, The
University of Calgary
Pack, R.T. et al.(1997) Intelligent Machine
Architecture
for
Object-Based
System
Integration, International Conference on
Advanced Intelligent Mechatronics, Japan, Jun.,
1997
Rumbaugh, J. et al.(1991) Object-Oriented
Modelling and Design. Prentice Hall, 1991
Shen, W. and D.H. Norrie (1999) Developing
Intelligent Manufacturing Systems using
Collaborative Agents, Submitted for the Second
International
Workshop
on
Intelligent
Manufacturing Systems, IMS’99, 22-24
September 1999, Leuven, Belgium
Wiederhold, G. (1992) Mediators in the
architectural of future information systems,
IEEE Transaction on Computer, pp.38-48
Wooldridge, M.J.and N.R.(1994) Jennings, Agent
Theories, Architecture and Languages, ECAI-94
Workshop on Agent Theories, Architectures,
and Languages, Amsterdam, ed. J.G Carbonell
and J. Siekmann, Springer Verlag,