ENGINEERING AGENT-BASED INFORMATION SYSTEMS
A Case Study of Automatic Contract Net Systems
Vincent Couturier, Marc-Philippe Huget and David Telisson
LISTIC Polytech'Savoie, Université de Savoie, B.P. 80439, F - 74944 Annecy-le-Vieux Cedex, France
Keywords: Enterprise Information Systems, Agents, Software Patterns, Reuse.
Abstract: In every business the tender has become an indispensable part to foster the negotiation of new trade
agreements. The selection and the attribution are nowadays a long process conducted manually. It is
necessary to define criteria for selecting the best offer, evaluate each proposal and negotiate a business
contract. In this paper, we present an approach based on agents for the development of an automatic award
of contracts (here called Automatic Contract Net Systems). The selection and negotiation are then
automatically performed through communication between agents. We focus in this paper on the tendering
and selection of the best offer. To facilitate the development of complex systems such as multi-agent
systems, we adopt software patterns that will guide the designer in the analysis, design and implementation
on an agent-based execution platform.
1 INTRODUCTION
Historically, companies have felt the need to
communicate and share information in order to
create economic partnerships. The concept of
extended enterprise has spread widely in the
industrial world where it is common now to launch a
tender via a website in order to award a new contract
to a subcontractor. However, beyond the tender and
deposit records, the whole process (receipt of
nominations, terms of partnership and
implementation) is rarely automated.
Various research works have focused on
management of tenders by developing information
systems. These approaches allow to deploy systems
upstream (dissemination and consultation of
proposals) and downstream (data exchange) of the
awarding contracts. However, the selection of
tenders and awarding contracts still remain a binding
process as it requires decision making and strong
autonomy of the actors involved.
In this paper we propose an approach and tools
(software patterns) to design an automatic contract
net system (ACNS) based on intelligent agents. The
choice to develop our solution with intelligent agents
comes from the autonomy requirement given above.
Indeed, the tasks of an award procedure require that
different market actors (suppliers, customers,
partners, etc.) take decisions correlated to the
sociological and environmental parameters defined
by characteristics to their field of activities. These
autonomous decisions should promote cooperation
and coordination tasks to end in an economic
partnership. It is necessary to have a system able to
search for the best offer according to given criteria
and to negotiate with the contractor if his/her
proposal is not fully satisfactory. We choose an
intelligent-based agent solution since each intelligent
agent presents intelligent decision making, and
autonomy regarding its actions. We adopt the
Contract Net Protocol (Smith, 1980) (FIPA, 2002)
for the whole process of proposing tasks, issuing
proposals and enacting contract. As part of a multi-
agent system, agents are active entities, autonomous,
intelligent and goals directed. They will work
together to achieve their personal goals
(Wooldridge, 2002).
Agent theory is now well-developed and covers
many domains from intelligent decision making,
negotiation, trust to planning to name a few.
Existing development methodologies (Gaia
(Wooldridge et al., 2000), MaSE (DeLoach et al.,
2001), etc.) for agent-based systems are not suitable,
in general, for inexperienced developers. In
particular, they may face various problems in the
analysis or design stage because of their
inexperience. This leads to inconsistent analysis or
design and poor reliability of the resulting agent-
based systems.
242
Couturier V., Huget M. and Telisson D. (2010).
ENGINEERING AGENT-BASED INFORMATION SYSTEMS - A Case Study of Automatic Contract Net Systems.
In Proceedings of the 12th International Conference on Enterprise Information Systems - Information Systems Analysis and Specification, pages
242-248
Copyright
c
SciTePress
In this paper, we propose to use the concept of
software patterns for the development process of
agent-based solutions, like existing approaches such
as Tropos (Giorgini et al., 2005) or PASSI
(Cossentino et al., 2004).
Patterns we propose in this paper cover the
whole development process from requirements
analysis to code generation. The designer of an
ACNS can thus follow our guidelines to develop
his/her solution. Thus, it will lead novice developers
to produce complex applications and to rapidly adapt
to any implementation environment.
The following paragraph explains the concept of
pattern. Then, we present the categories of patterns
dedicated to engineering ACNS and the reuse
process.
2 THE CONCEPT OF PATTERN
Alexander introduced the concept of pattern in 1977
for the design and construction of homes and offices
(Alexander et al., 1977). Patterns were adapted to
software engineering and mainly to object-oriented
programming and are called software patterns.
In Alexander’s proposition, a pattern describes a
problem which occurs over and over again in an
environment as well as a solution that can be used
differently several times. A software pattern follows
the same principle and offers a solution to
developers when building software in a specific
context. Thus, patterns can be seen as abstractions
used by design or code experts that provide solutions
in different phases of software engineering.
Patterns can be divided into four categories:
analysis patterns (Fowler, 1997), architectural
patterns (Buschmann et al., 1996), design patterns
(Gamma et al., 1995), and idioms (Coplien, 1992),
the latter are also known as implementation patterns.
3 CATEGORIES OF PATTERNS
DEDICATED TO AUTOMATIC
CONTRACT NET SYSTEMS
AND THEIR REUSE
3.1 Pattern Categories
The first patterns applied for engineering of
Automatic Contract Net Systems are Agent Analysis
Patterns. They define agent structure and design
multiagent systems at a high level of abstraction.
They can be applied to design either reactive or
cognitive agents. As mentioned before, we propose
to develop agent-based Automatic Contract Net
Systems. Thus, the designer will be able to reuse
these patterns to design agents for his/her ACNS at a
high level of abstraction.
Agent Analysis Patterns are generic and have to
be applied with ACNS domain patterns. These ones
capitalize the domain knowledge specific to
Automatic Contract Net Systems and favour its
reuse.
Patterns dedicated to architectural representation
and design of ACNS are ACNS architectural
patterns and design patterns.
The former have to be applied at the beginning
of the design process and help defining the ACNS
structural organization. They represent the different
architectural styles for ACNS which are means of
capturing families of architectures and can be seen
as a set of design rules that guide and constrain the
development of ACNS architecture (levels, internal
elements, collaborations between elements…).
Architectural styles depend on which architecture
we choose for the ACNS: Market-based one,
Subcontract-based one or Peer-to-Peer-based one.
Design patterns describe technical elements
required to develop agent-based Automatic Contract
Net Systems. Analysis and conceptual models
obtained by applying ACNS domain patterns and
Agent Analysis Patterns are refined with behaviour,
collaboration and software entities. Thus, the ACNS
design model is obtained by adapting software
elements specified in the design patterns solutions.
Among them, we can distinguish generic Agent
Design Patterns (dedicated, for instance, to define
interaction protocols between agents such as
Contract Net Protocol), and patterns specific to
ACNS design, called ACNS design patterns.
Finally, we have specified two kinds of support
patterns: Model Transformation Patterns and Reuse
Support Patterns.
Model Transformation Patterns help ACNS
developers to build applications from ACNS and
Agent design patterns and can be applied at the end
of the design phase. They specify transformation
rules to map design models to models specific to
agent development frameworks such as JADE
(Bellifemine et al., 2007), Madkit (Gutknecht &
Ferber, 2000) or Mercury (Huget, 2008).
Reuse Support Patterns are process patterns
which help developers navigating into a collection of
patterns and reusing them. They describe, by using
activity diagrams, a sequence of patterns to apply to
resolve a problem. ACNS Reuse Support Patterns
help developers to design and build such systems by
guiding them among our collection of patterns.
ENGINEERING AGENT-BASED INFORMATION SYSTEMS - A Case Study of Automatic Contract Net Systems
243
The different patterns described here regarding
the development cycle of an ACNS are shown on
Figure 1.
Figure 1: The use of the different proposed patterns in the
development cycle of an ACNS.
Note: The different patterns presented here are
shorter version ones.
3.2 Pattern Reuse
The reuse of patterns dedicated to develop ACNS
consists in applying them during analysis, design
and implementation phases. First, developers
analyze context and problem and select relevant
patterns. This activity can be favoured by using
Reuse Support Patterns (see Table 1) which
represent sequences of patterns that can be applied
to develop Automatic Contract Net Systems. Thus,
developers adapt pattern solution elements
(instantiation) to represent the system they want to
develop. Finally, the third activity aims at using
Model Transformation Patterns to generate skeleton
application from pattern instances.
We present, in next section, Agent Patterns and
ACNS Patterns we designed to develop Automatic
Contract Net Systems.
4 PATTERNS
FOR ENGINEERING
AUTOMATIC CONTRACT NET
BASED SYSTEMS
4.1 Patterns for the Analysis Phase
Agent Analysis Patterns are generic ones used for
building agents at a high level of abstraction:
Pattern Agent Structure”: this pattern defines
what an agent is in terms of its structure. An
agent is a set of roles it will play during its
execution.
Pattern Adding cognitive interaction to Role”:
this pattern inserts the notion of protocol and
message within the agent. The agent is then
able to communicate via high-level messages
with other agents.
Pattern Adding behavior to cognitive
interaction”: this pattern defines the behavior
associated to sending and receiving messages.
Two domain patterns were designed for the ACNS
application. An Automatic Contract Net System
considers two kinds of interacting entities: (1) one or
more Consumer and (2) one or more Producer. The
“Consumer” pattern defines the Consumer concept.
The “Producer” pattern is equivalent to this one
except it considers the concept of Producer instead
of the concept of Consumer.
4.2 Patterns for the Design Phase
In this section, we present ACNS Architectural
Patterns for the architectural design of a Contract
Net system then patterns for the detailed design of
an ACNS. These patterns have to be applied after
analysis patterns and domain patterns described
above.
4.2.1 ACNS Architectural Patterns
We develop three architectural patterns related to the
different architectures an ACNS could have:
Pattern “Market-based ACNS”: a
marketplace is defined with this pattern. A
marketplace is composed of several
consumers and several providers.
Consumers try to find the best proposal for a
service. Two approaches are possible to
retrieve this best proposal: (1) A descending
price auction or (2) A call for proposals.
Pattern “Subcontract-based ACNS”: An
ACNS with subcontracts is a restricted
version of the previous pattern “Market-
based ACNS”. In this particular case, there
is only one consumer and several providers.
The best proposal is found after a call for
proposals.
ICEIS 2010 - 12th International Conference on Enterprise Information Systems
244
Table 1: Reuse Support Pattern “Engineering an Automatic Contract Net System”.
Interface
Name
Engineering Automatic Contract Net Systems
Classification
Reuse Support Pattern
Rationale
This pattern presents ACNS and agent patterns that can be applied to develop Automatic Contract Net Systems.
Note: We only describe here patterns for the development of a subcontract-based ACNS for JADE platform.
Solution
Process
Pattern “Peer-to-Peer-based ACNS”:
previous patterns impose to use a central
server so as to store the address of the
different consumers and providers. This
approach does not resist to the scalability
problem and the bottleneck is located on
searching the central server to retrieve the
different consumers and providers.
In this pattern here, there is no more central
server and the different consumers and providers
know each other via social networks. This kind of
architecture copes with the scalability problem.
4.2.2 Agent Design Patterns and ACNS
Design Patterns
These patterns describe the different concepts
needed for designing an ACNS (ACNS Design
patterns) and for designing a multiagent system used
for ACNS (Agent Design Patterns). Only one pattern
of the former is presented in abstract form (Cf. Table
2).
4.3 Patterns for the Phase
of Implementation: Model
Transformation Patterns
We define several Model Transformation patterns
for developing ACNS for different architectures
(subcontract-based architectures, market-based ones
and peer-to-peer-based ones) and for different
execution platforms (JADE, Madkit, and Mercury).
Due to space restriction, we only present here in
Table 3, a short version---without method
transformations---of a Model Transformation pattern
for JADE implementation of a subcontract-based
ACNS.
ENGINEERING AGENT-BASED INFORMATION SYSTEMS - A Case Study of Automatic Contract Net Systems
245
Table 2: ACNS Design Pattern “Consumer-Producer Interaction”.
Interface
Name
Consumer-Producer Interaction
Classification
Design Pattern ^ACNS Pattern
Rationale
This pattern describes the interaction between Consumer agents and Producer agents and behaviours associated with this interaction.
Solution
Model
Participants
The Agent concept corresponds to the notion of agent defined in the agent theory. An agent is an autonomous, active entity which
asynchronously interacts with other agents and cooperates with others so as to solve a global problem.
The Role concept defines a catalogue of behaviours the agent will play within the multiagent system.
The Consumer concept refers to the notion of customers in commerce. Customers acquire a service from providers. The Consumer
concept inherits from the Role concept since it represents a specific role in a Contract Net system. A field category is associated to this
concept to refer to the kind of service the Consumer is looking for.
The Producer concept refers to the notion of producers in commerce. Producers propose services to customers. The Producer
concept inherits from the Role concept since it represents a specific role in a Contract Net system. The Producer concept has two
attributes: category and proposal. Category defines the kind of service the Producer provides. Proposal refers to the proposal the
Producer issues when receiving a call for proposals from the Consumer. Here, the proposal is an amount for performing the service.
The Consumer concept is related to the Producer concept through an association entitled producers. The consumers association
describes a Consumer asks to 0 or more Producer for a service given criteria and a Producer provides service to a Consumer. It is
possible a Consumer does not find a Producer if there is no Producer for the given criteria.
The Consumer concept is related to the Message concept through an association entitled proposals. A Consumer sends 0 or more
Message to Producer and a Message is related to only one Consumer. Exchanged messages are those found in the Contract Net Protocol
pattern. The different proposals coming from the Producer are those in this association.
The Producer concept is related to the Message concept through an association entitled call for proposal. A Producer receives one
Message from Consumer and a Message is related to only one Producer. This message corresponds to the call for proposals the
Consumer does in the context of the Contract Net protocol (Contract Net Protocol pattern).
The Protocol concept defines a protocol. This Protocol is composed of an attribute id that uniquely identifies the protocol. A protocol
is a legal suite of sequences of messages.
The Message concept refers to the notion of messages in protocols. A message has several attributes: sender and receiver which
respectively refer to the sender of the message and the receiver of the message. The attributes performative and content correspond to the
content of the message for the latter and the illocutionary force--the verb--for the former. A performative is the verb used to describe the
action and is applied on the content.
The Task concept refers to the notion of behaviours. Here, behaviours correspond to the behaviours when sending and receiving
messages. Behaviours when sending messages are denoted by the outgoing behaviour association between the Task concept and the
Message concept. Behaviours when receiving messages are denoted by the incoming behaviour association between the Task concept
and the Message concept.
It is optional to describe behaviours when designing protocols and messages. The Task has one attribute description that gives the
associated behaviour. There is no predefined format for this attribute. Designers may decide to use formal methods or programming
languages, to represent only one action or a workflow depending on behaviour complexity.
ICEIS 2010 - 12th International Conference on Enterprise Information Systems
246
Table 3: Model Transformation Pattern “JADE Implementation of a Subcontract-based ACNS”.
Interface
Name
JADE Implementation of a subcontract-based ACNS
Classification
Model Transformation Pattern ^ ACNS Pattern
Rationale
An Automatic Contract Net System considers two kinds of interacting entities: (1) one or more Consumer and (2) one or more Producer.
This pattern defines the Consumer concept.
Solution
Model
Participants
This pattern ensures the transformation from a conceptual model of an ACNS to a set of classes for the JADE platform. Agents on the
JADE platform are defined as a specialization of the Agent class provided by the JADE platform. The Consumer and Producer concepts
are derived as Consumer and Producer classes inheriting from the Agent class. The Agent class from the JADE platform provides the
different methods required for the Agent lifecycle (creation, invocation, execution and deletion). These methods correspond to the ones
proposed in the Agent concept. The set of attributes and methods from the Role concept is added to the Consumer and Producer classes.
Behaviours on incoming messages and outgoing messages are defined via the Message and the Task concepts in the upper part of the
figure. Behaviours in the JADE platform are defined as a specialization of the Behaviour class. We distinguish the Consumer behaviours
from the Producer behaviours during the transformation. Actually, we consider the Producer behaviours as cyclic; the Producer learns
from previous calls for proposals to prepare better proposals. It is not possible with the Behavior class to define cyclic behaviour hence
explaining why the behaviour for Producer inherits from CyclicBehavior.
5 CONCLUSIONS
This paper describes our work about specifying and
reusing patterns so as to engineer agent-based
Automatic Contract Net Systems (ACNS). The
different patterns presented here represent the
building blocks which, after adaptation, can be used
to develop analysis and design models for a new
ACNS, define the architecture and ease
implementation. The patterns cover the phases of
analysis, design and implementation for engineering
an ACNS.
The approach developed and the different
patterns are experimentally validated on a specific
ACNS for booking flight tickets. The client is here
the travel agency and the providers are the different
flight companies. Reusing the patterns help eliciting
the business entities (analysis model), architecting
the system (the architecture is a subcontract-based
one since there is a unique consumer and several
producers), defining the design model and
generating skeleton code for the JADE platform.
ENGINEERING AGENT-BASED INFORMATION SYSTEMS - A Case Study of Automatic Contract Net Systems
247
We have developed a toolkit so as to ease
engineering Information System applications and
specifically ACNS. This toolkit is based on our
software patterns. It takes as input a Reuse Support
Pattern, guides the developer--by asking questions--
through the different patterns to be used, and finally
generates code skeleton. The process is then not
fully automated due to developer’s interventions.
Thus, s/he can complete and refine the generated
code and run his/her agents on a JADE platform.
Future work aims at reusing the different
patterns presented here and augmenting the set of
patterns so as to develop other Enterprise
Information Systems (schedule management for
instance).
REFERENCES
Alexander, C., Shikawa, S., Silverstein, M., Jacobson, M.,
Fiksdahl-King, I., & Angel, S., 1977. A pattern
language: towns, buildings, construction, New York,
Oxford University Press.
Bellifemine, F. L., Caire, G., & Greenwood, D., 2007.
Developing Multi-Agent Systems with JADE, New
York, Wiley.
Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P.
& Stal, M., 1996. Pattern-Oriented Software
Architecture: A System of Patterns, New York, John
Wiley & Sons.
Coplien, J.O., 1992. Advanced C++: programming styles
and idioms, Addison-Wesley.
Cossentino, M., Luca, S., & Antonio, C., 2004. Patterns
Reuse in the PASSI Methodology, In A. Omicini, P.
Petta, J. Pitt (eds.), LNCS (LNAI): vol. 3071, ESAW
2003, pp. 294-310, Springer.
DeLoach, S.A., Wood, M.F., & Sparkman, C.H., 2001.
Multiagent Systems Engineering. International
Journal of Software Engineering and Knowledge
Engineering, 11(3).
Foundation for Intelligent Physical Agents, 2002. FIPA
Contract Net Interaction Protocol Specification, from
http://www.fipa.org/specs/fipa00029/
Fowler, M., 1997. Analysis Patterns, Addison-Wesley.
Gamma, E., Johnson, R., Helm, R., & Vlissides, J., 1995.
Design patterns, elements of reusable object-oriented
software, Addison-Wesley.
Giorgini, P., Kolp, M., Mylopoulos, J., & Castro, J., 2005.
Tropos: A Requirements-Driven Methodology for
Agent-Oriented Software, Agent-Oriented
Methodologies, pp. 20-45.
Gutknecht, O., & Ferber, J., 2000. The MADKIT agent
platform architecture, In T. Wagner (Ed.), LNCS : vol.
1887, International Workshop on Infrastructure for
Multi-Agent Systems, Springer-Verlag, pp. 48-55.
Huget, M. Ph., june 2008. Mercury: une plate-forme pour
l'exécution de systèmes multi-agents, Paper presented
at the 8ème Conférence Internationale sur les
NOuvelles TEchnologies de la REpartition (NOTERE
2008), Lyon, France (in French).
Smith, R.G., 1980. The Contract Net Protocol: High level
Communication and Control in a Distributed Problem
Solver, IEEE transactions on Computers, 29(12), pp.
1104-1113.
Wooldridge, M., Jennings, N. R., & Kinny, D., 2000. The
Gaia Methodology For Agent-Oriented Analysis And
Design, Journal of Autonomous Agents and Multi-
Agent Systems, vol. 3, pp. 285-312.
Wooldridge, M.J., 2002. An Introduction to MultiAgent
Systems, New York, Wiley.
ICEIS 2010 - 12th International Conference on Enterprise Information Systems
248