An agent based approach for building complex software systems

AN AGENT-BASED APPROACH FOR
BUILDING COMPLEX
SOFTWARE SYSTEMS
WHY AGENT-ORIENTED APPROACHES ARE WELL SUITED FOR
DEVELOPING COMPLEX, DISTRIBUTED SYSTEMS.

B
uilding high-quality, industrial- ented techniques, the most compelling argument
strength software is difficult. would be to quantitatively show how their adoption
Indeed, it has been argued that improved the development process in a range of proj-
developing such software in ects. However, such data is simply not available (as it
domains like telecommunications, is not for approaches like patterns, application frame-
industrial control, and business process manage- works, and componentware). Given this situation,
ment represents one of the most complex construc- the best that can be achieved is a qualitative justifica-
tion tasks humans undertake. Against this tion of why agent-oriented approaches are well suited
background, a wide range of software engineering to engineering complex, distributed software systems.
paradigms have been devised.
Each successive development Managing Complexity in
either claims to make the engi- Software Systems
neering process easier or Industrial-strength software is
promises to extend the complex- N ICHOLAS R. J ENNINGS complex: it has a large number of
ity of applications that can feasi- parts that have many interactions
bly be built. Although evidence [9]. Moreover this complexity is
is emerging to support these not accidental [2], it is an innate
claims, researchers continue to property of large systems. Given
strive for more effective techniques. To this end, this this situation, the role of software engineering is to
article will argue that analyzing, designing, and provide structures and techniques that make it eas-
implementing complex software systems as a collec- ier to handle complexity. Fortunately for designers,
tion of interacting, autonomous agents (that is, as a this complexity exhibits a number of important
multiagent system [4]) affords software engineers a regularities [9]:
number of significant advantages over contemporary
methods. This is not to say that agent-oriented soft- • Complexity frequently takes the form of a hierar-
ware engineering represents a silver bullet [2]—there chy. That is, a system composed of interrelated
is no evidence to suggest it will represent an order of subsystems, each of which is in turn hierarchic in
magnitude improvement in productivity. However, structure, until the lowest level of elementary sub-
the increasing number of deployed applications [4, system is reached. The precise nature of these orga-
8] bears testament to the potential advantages that nizational relationships varies between subsystems,
accrue from such an approach. however, some generic forms (such as client/server,
In seeking to demonstrate the efficacy of agent-ori- peer, team, and so forth) can be identified. These

COMMUNICATIONS OF THE ACM April 2001/Vol. 44, No. 4 35

relationships are not static: they often vary over of basic components to be grouped together and
time. treated as a higher-level unit of analysis, and pro-
• The choice of which components in the system viding a means of describing the high-level rela-
are primitive is relatively arbitrary and is defined tionships between various units.
by the observer’s aims and objectives.
• Hierarchic systems evolve more quickly than The Case for Agent-Oriented Software
nonhierarchic ones of comparable size (that is, Engineering
complex systems will evolve from simple systems The first step in arguing for an agent-oriented
more rapidly if there are clearly identifiable stable approach to software engineering involves identify-
intermediate forms than if there are not). ing the key concepts of agent-based computing. The
• It is possible to distinguish between the interac- first such concept is that of an agent: an agent is an
tions among subsystems and those within subsys- encapsulated computer system situated in some
tems. The latter are both more frequent (typically at environment and capable of flexible, autonomous
least an order of magnitude more) and more pre-
dictable than the former. This gives rise to the view Figure 1. View of a canonical complex system.
that complex systems are nearly decomposable: sub-
systems can be treated almost as if they are inde-
pendent, but not quite since there are some
interactions between them. Moreover, although
many of these interactions can be predicted at
design time, some cannot.

Drawing these insights together, it is possible to
define a canonical view of a complex system (see Fig- subsystem related to infrequent
ure 1). The system’s hierarchical nature is expressed interaction
subsystem frequent interaction
through the “related to” links, components within a component
subsystem are connected through “frequent interac-
tion” links, and interactions between components are
expressed through “infrequent interaction” links. action in that environment in order to meet its
Given these observations, software engineers have design objectives [10].
devised a number of fundamental tools of the trade There are a number of points about this definition
for helping to manage complexity [1]: that require elaboration. Agents are: clearly identifi-
able problem-solving entities with well-defined
Decomposition: The most basic technique for boundaries and interfaces; situated (embedded) in a
tackling large problems is to divide them into particular environment over which they have partial
smaller, more manageable chunks, each of which control and observability—they receive inputs related
can then be dealt with in relative isolation (note to the state of their environment through sensors and
the nearly decomposable subsystems in Figure 1). they act on the environment through effectors;
Decomposition helps tackle complexity because it designed to fulfill a specific role—they have particular
limits the designer’s scope. objectives to achieve; autonomous—they have con-
Abstraction: The process of defining a simplified trol both over their internal state and over their own
model of the system that emphasizes some of the behavior; capable of exhibiting flexible problem-solv-
details or properties, while suppressing others. ing behavior in pursuit of their design objectives—
Again, this works because it limits the designer’s being both reactive (able to respond in a timely
scope of interest at a given time. fashion to changes that occur in their environment)
Organization1: The process of defining and man- and proactive (able to opportunistically adopt goals
aging the interrelationships between the various and take the initiative) [11].
problem-solving components (note the subsystem When adopting an agent-oriented view, it soon
and interaction links of Figure 1). The ability to becomes apparent that most problems require or
specify and enact organizational relationships helps involve multiple agents: to represent the decentralized
designers tackle complexity by: enabling a number nature of the problem, the multiple loci of control,
the multiple perspectives or the competing interests.
1
Booch actually uses the term “hierarchy” [1]; however, this invariably gives the con-
Moreover, the agents will need to interact with one
notation of control. Hence the more neutral term “organization” is used here. another: either to achieve their individual objectives

36 April 2001/Vol. 44, No. 4 COMMUNICATIONS OF THE ACM

or to manage the dependencies that ensue from being agents may form a team to deliver a service that no
situated in a common environment. These interac- one individual can offer). The temporal extent of
tions can vary from simple semantic interoperation, these relationships can also vary enormously, ranging
through traditional client/server-type interactions, to from providing a service as a one-off option to a per-
rich social interactions (the ability to cooperate, coor- manent bond. To cope with this variety and dynam-
dinate, and negotiate about a course of action). ics, agent researchers have devised protocols that
Whatever the nature of the social process, how- enable organizational groupings to be formed and dis-
ever, there are two points that qualitatively differenti- banded, specified mechanisms to ensure groupings act
ate agent interactions from those that occur in other together in a coherent fashion, and developed struc-
software engineering paradigms. First, agent-oriented tures to characterize the macro behavior of collectives
interactions generally occur through a high-level [4, 11].
(declarative) agent communication language (often Drawing these points together (see Figure 2), it can
based on speech act theory [6]). Consequently, inter- be seen that adopting an agent-oriented approach to
software engineering means decomposing the prob-
Figure 2. Canonical view of a multiagent system. lem into multiple, autonomous components that can
act and interact in flexible ways to achieve their set
agent
objectives. The key abstraction models that define the
interaction
organizational agent-oriented mindset are agents, interactions, and
relationship
organizations. Finally, explicit structures and mecha-
nisms are often used to describe and manage the com-
plex and changing web of organizational relationships
that exist between the agents.
The argument in favor of an agent-oriented
Sphere of approach to software engineering includes:
visibility
and
influence • Show that agent-oriented decompositions are an
Environment
effective way of partititioning the problem space of
a complex system;
actions are conducted at the knowledge level [5]: in • Show that the key abstractions of the agent-ori-
terms of which goals should be followed, at what ented mindset are a natural means of modeling
time and by whom (compare this with method invo- complex systems; and
cation or function calls that operate at a purely syn- • Show that the agent-oriented philosophy for
tactic level). Secondly, as agents are flexible modeling and managing organizational relation-
problem-solvers, operating in an environment in ships is appropriate for dealing with the dependen-
which they have only partial control and observabil- cies and interactions that exist in complex systems.
ity, interactions need to be handled in a similarly flex-
ible manner. Thus, agents need the computational The Merits of Agent-Oriented
apparatus to make context-dependent decisions Decompositions
about the nature and scope of their interactions and Complex systems consist of a number of related sub-
to initiate (and respond to) interactions that were not systems organized in a hierarchical fashion (see Fig-
foreseen at design time. ure 1). At any given level, subsystems work together
Since agents act either on behalf of individuals or to achieve the functionality of their parent system.
companies or as part of some wider initiative, there is Moreover, within a subsystem, the constituent com-
typically some underpinning organizational context ponents work together to deliver the overall func-
to agents’ interactions. This context defines the nature tionality. Thus, the same basic model of interacting
of the relationship between the agents. For example, components, working together to achieve particular
they may be peers working together in a team or one objectives occurs throughout the system. Given this
may be the manager of the others. To capture such fact, it is entirely natural to modularize the compo-
links, agent systems have explicit constructs for mod- nents in terms of the objectives they achieve.2 In
eling organizational relationships (manager, team other words, each component can be thought of as
member). In many cases, these relationships are sub- achieving one or more objectives. A second impor-
ject to ongoing change: social interaction means exist- 2
The view that decompositions based upon functions/actions/processes are more intu-
ing relationships evolve (a team of peers may elect a itive and easier to produce than those based upon data/objects is even acknowledged
leader) and new relations are created (a number of within the object-oriented community (see [7]).


tant observation is that complex systems have mul- eral, there will be multiple candidates and the dif-
tiple loci of control: “real systems have no top” [7]. ficult task is picking the most appropriate one.
Applying this philosophy to objective-achieving When designing software, the most powerful
decompositions means the individual components abstractions are those that minimize the semantic
should localize and encapsulate their own control. gap between the units of analysis that are intu-
Thus, entities should have their own thread of con- itively used to conceptualize the problem and the
trol (that is, they should be active) and they should constructs present in the solution paradigm. In the
have control over their own actions (that is, they case of complex systems, the problem to be charac-
should be autonomous). terized consists of subsystems, subsystem compo-
For the active and autonomous components to ful- nents, interactions and organizational
fill both their individual and collective objectives, they relationships. Taking each in turn:
need to interact (recall complex systems are only nearly
decomposable). However the system’s inherent com- • Subsystems naturally correspond to agent organi-
plexity means it is impossible to a priori know about all zations. They involve a number of constituent
potential links: interactions will occur at unpredictable components that act and interact according to their
times, for unpredictable reasons, between unpre- role within the larger enterprise.
dictable components. For this reason, it is futile to try • The case for viewing subsystem components as
and predict or analyze all the possibilities at design agents has been made previously.
time. It is more realistic to endow the components with
the ability to make decisions about the nature and The interplay between the subsystems and
scope of their interactions at runtime. From this, it fol- between their constituent components is most natu-
lows that components need the ability to initiate (and rally viewed in terms of high-level social interactions:
respond to) interactions in a flexible manner. “in a complex system…at any given level of abstrac-
The policy of deferring to runtime decisions about tion, we find meaningful collections of objects that
component interactions facilitates the engineering of collaborate to achieve some higher-level view” [1].
complex systems in two ways. First, problems associ- This view accords precisely with the knowledge-level
ated with the coupling of components are signifi- treatment of interaction afforded by the agent-
cantly reduced (by dealing with them in a flexible and oriented approach. Agent systems are invariably
declarative manner). Components are specifically described in terms of “cooperating to achieve com-
designed to deal with unanticipated requests and can mon objectives,” “coordinating their actions” or
spontaneously generate requests for assistance if they “negotiating to resolve conflicts.”
find themselves in difficulty. Moreover because these Complex systems involve changing webs of rela-
interactions are enacted through a high-level agent tionships between their various components. They
communication language, coupling becomes a also require collections of components to be treated as
knowledge-level issue. At a stroke this removes syn- a single conceptual unit when viewed from a different
tactic concerns from the types of errors caused by level of abstraction. Here again the agent-oriented
unexpected interactions. Secondly, the problem of mindset provides suitable abstractions. A rich set of
managing control relationships between the software structures are available for explicitly representing
components (a task that bedevils traditional objec- organizational relationships. Interaction protocols
tive-based decompositions) is significantly reduced. exist for forming new groupings and disbanding
All agents are continuously active and any coordina- unwanted ones. Finally, structures are available for
tion or synchronization that is required is handled modeling collectives. The latter point is especially
bottom-up through interagent interaction. useful in relation to representing subsystems since
From this discussion, it is apparent that the natural they are nothing more than a team of components
way to modularize a complex system is in terms of working together to achieve a collective goal.
multiple autonomous components that can act and
interact in flexible ways in order to achieve their set
The Need for Flexible Management of
objectives. Given this, the agent-oriented approach is
Changing Organizational Structures
simply the best fit to this ideal. Organizational constructs are first-class entities in
agent systems—explicit representations are made of
The Suitability of Agent-Oriented organizational relationships and structures. More-
Abstractions over, agent-oriented systems have the concomitant
A significant part of the design process is finding computational mechanisms for flexibly forming,
the right models for viewing the problem. In gen- maintaining, and disbanding organizations. This


representational power enables agent systems to way of characterizing many types of problems. Just as
exploit two facets of the nature of complex systems. the real-world is populated with objects that have
First, the notion of a primitive component can be operations performed on them, so it is equally full of
varied according to the needs of the observer. Thus active, purposeful agents that interact to achieve their
at one level, entire subsystems can be viewed as sin- objectives (see the sidebar for more detailed compari-
gletons, alternatively teams or collections of agents son). Indeed, many object-oriented analyses start from
can be viewed as primitive components, and so on precisely this perspective: “we view the world as a set of
until the system eventually bottoms out. Secondly, autonomous agents that collaborate to perform some
such structures provide the stable intermediate forms higher level function” [1].
that are essential for the rapid development of com- The basic building blocks of the programming
plex systems. Their availability means that individ- models exhibit increasing degrees of localization and
ual agents or organizational groupings can be encapsulation [8], and agents follow this trend by
developed in relative isolation and then added into localizing purpose inside each agent, by giving each
the system in an incremental manner. This, in turn, agent its own thread of control, and by encapsulating
ensures there is a smooth growth in functionality. action selection. Additionally, ever-richer mechanisms
for promoting reuse are being provided. Here, the
Will Agent-Oriented Techniques Be agent view also reaches new heights. Rather than
Widely Adopted? stopping at reuse of subsystem components (design
There are two key pragmatic issues that will deter- patterns and componentware) and rigidly preor-
mine whether agent-oriented approaches catch on as dained interactions (application frameworks), agents
a software engineering paradigm: the degree to enable whole subsystems and flexible interactions to
which agents represent a radical departure from be reused. In the former case, agent designs and
current software engineering thinking and the implementations are reused within and between
degree to which existing software can be integrated applications. Consider, for example, the class of agent
with agents. architectures that have beliefs (what the agent knows),
A number of trends become evident when examin- desires (what the agent wants) and intentions (what
ing the evolution of programming models. There has the agent is doing) at its core. Such architectures have
been an inexorable move from languages that have been used in a wide variety of applications including
their conceptual basis determined by the underlying air traffic control, process control, fault diagnosis and
machine architecture, to languages that have their key transportation [4, 8]. In the latter case, flexible pat-
abstractions rooted in the problem domain. Here the terns of interaction such as the Contract Net Proto-
agent-oriented world view is perhaps the most natural col (an agent with a task to complete advertises this

Comparing Object- and Agent-based Approaches

A lthough there are certain sim-
ilarities between object- and
agent-oriented approaches (both
object. Once the method is
invoked, the corresponding actions
are performed. Additionally,
abstraction mechanisms such as
design patterns, application frame-
works, and componentware.
adhere to the principle of informa- object-orientation fails to provide Although these are undoubtedly a
tion hiding and recognize the an adequate set of concepts and step forward, they fall short of the
importance of interactions), there mechanisms for modeling complex desired characteristics for complex
are also a number of important systems: for such systems “we find system development. By their very
differences [10]. First, objects are that objects, classes, and modules nature, they focus on generic sys-
generally passive in nature: they provide an essential yet insuffi- tem functions and the mandated
need to be sent a message before cient means of abstraction” [1]. patterns of interaction are rigid and
they become active. Secondly, Individual objects represent too predetermined. Finally, object-ori-
although objects encapsulate fine a granularity of behavior and ented approaches provide only min-
state and behavior realization, method invocation is too primitive a imal support for specifying and
they do not encapsulate behavior mechanism for describing the types managing organizational relation-
activation (action choice). Thus, of interactions that take place. ships (basically relationships are
any object can invoke any publicly Recognition of these facts led to defined by static inheritance
accessible method on any other the development of more powerful hierarchies). c


fact to others who it believes are capable of perform- Case Study: Provisioning a Virtual
ing it, these agents may submit a bid to perform the Private Network
task if they are interested, and the originator then As an exemplar of a complex, distributed system
delegates the task to the agent that makes the best consider the task of dynamically provisioning a
bid) and various forms of resource-allocation auction public communication network (such as the Inter-
(for example, English, Dutch, Vickrey) have been net) as a virtual private network for end users. To be
reused in significant numbers of applications. In more definitive, let the task in question be setting
short, agent-oriented techniques represent a natural up a videoconferencing meeting [3]. This applica-
progression of current software engineering thinking tion involves a variety of different individuals and
and, for this reason, the main concepts and tenets of organizations (see Figure 3). There are the end users
the approach should be readily acceptable to software that are each represented by their personal commu-
engineering practitioners. nication agent (PCA). The providers of services on
the network (such as setting up a
Figure 3. Dynamic provisioning of virtual videoconference, for example) are
private networks by end users. each represented by a service
provider agent (SPA). Finally,
Group that Agree time End Users there are the agents that represent
wants to PCA PCA
make call negotiation the network provider on whose
Locate videoconference provider negotiation telecommunications infrastruc-
ture the services will actually be
SPA SPA SPA Service delivered (each represented by a
Providers network provider agent (NPA)).
In setting up a videoconference
Select network provider negotiation call, the various PCAs negotiate,
on behalf of their particular users,
NPA NPA NPA NPA Network with one another in order to find
Providers a suitable time for the call. When
they come to an agreement, one
of the PCAs then contacts, and
subsequently negotiates with, the various SPAs that
The second factor in favor of a widespread incor- offer the videoconference service (not all SPAs will
poration of agents is that their adoption does not do this). This negotiation revolves around the cost
require a revolution in terms of an organization’s soft- of the conference call and the quality of service that
ware capabilities. Agent-oriented systems are evolu- is desired. The SPA that wins the contract then
tionary and incremental as legacy (non-agent) negotiates with the various NPAs to determine
software can be incorporated in a relatively straight- which of them can deliver the desired quality and
forward manner. The technique used is to place wrap- bandwidth at the best price.
ping software around the legacy code. The wrapper This application highlights many of the benefits
presents an agent interface to the other software com- that are have been claimed for an agent-oriented
ponents. Thus from the outside it looks like any other approach to software engineering. Autonomous
agent. On the inside, the wrapper performs a two-way agents are the most natural means of representing the
translation function: taking external requests from distinct individuals and organizations that are present
other agents and mapping them into calls in the in the application. Each such entity is an active prob-
legacy code, and taking the legacy code’s external lem-solver that has its own objectives to achieve and
requests and mapping them into the appropriate set has control over the actions it chooses and the
of agent communication commands. This ability to resources that it expends. The agents need to be
wrap legacy systems means agents may initially be responsive to changes in their environment (for exam-
used as an integration technology. However, as new ple, a NPA may need to arrange additional network
requirements are placed on the system, agents may be capacity from another NPA in order to maintain its
developed and added. This feature enables a complex agreed upon quality of service if part of its network
system to grow in an evolutionary fashion (based on fails) and they need to be able to opportunistically
stable intermediate forms), while adhering to the adopt new goals as they present themselves (for exam-
important principle that there should always be a ple, two SPAs may discover they have complementary
working version of the system available. service capabilities and may decide to act together in


order to offer a new service). ented approaches are appropriate for developing
A second factor is the agents’ need to engage in complex, distributed software systems. These general
knowledge-level interactions in order to achieve their points are then made more concrete by showing how
individual objectives. In this case, agents typically rep- they apply in a specific telecommunications applica-
resent self-interested entities and so the main form of tion. In making these arguments, it is possible for
interaction is negotiation. Thus, to set the time of the proponents of other software engineering paradigms
videoconference or to select a particular service or net- to claim that the key concepts of agent-oriented
work provider the agents make proposals, trade offers, computing can be reproduced using their tech-
make concessions and, hopefully, come to agree- nique—this is undoubtedly true. Agent-oriented
ments. This rich form of interaction is necessary systems are, after all, computer programs and all pro-
because the agents represent autonomous stakeholders grams have the same set of computable functions.
and also to ensure that agents can arrange their activ- However, this misses the point. The value of a para-
ities in a manner that is appropriate to their prevailing digm is the mindset and the techniques it provides
circumstances. to software engineers. In this respect, agent-oriented
Finally, there is a very clear and explicit notion of concepts and techniques are both well suited to
organizational context. The application involves a developing complex, distributed systems and an
number of different real-world organizations: individ- extension of those currently available in other
ual end users, companies that provide the different paradigms. c
types of services, and network providers that control
the underlying telecommunications infrastructure.
These relationships directly affect the agents’ behavior. References
For example, if a SPA and a NPA are in fact part of 1. Booch, G. Object-Oriented Analysis and Design with Applications. Addi-
son Wesley, 1994.
the same organization, then their negotiations are 2. Brooks, F.P. The Mythical Man-Month. Addison Wesley, 1995.
more cooperative in nature than if they represent two 3. Faratin, P., Jennings, N.R., Buckle, P. and Sierra, C. Automated nego-
tiation for provisioning virtual private networks using FIPA-compliant
unrelated companies. Similarly, the PCAs that have agents. In Proceedings of the 5th International Conference on Practical
agreed to hold a conference call act as a team rather Application of Intelligent Agents and Multi-Agent Systems. Manchester,
than a collection of individuals. Additionally, during UK, 2000, p. 185–202.
4. Jennings, N.R. and Wooldridge, M., Eds. Agent Technology: Founda-
the ongoing operation of the application new organi- tions, Applications and Markets. Springer Verlag, 1998.
zational groupings can appear and then disband. The 5. Newell, A. The knowledge level. Artificial Intelligence 18, 1982,
87–127.
PCAs of distinct end users form themselves into col- 6. Mayfield, J., Labrou, Y., and Finin, T. Evaluating KQML as an agent
lectives when they require a particular service (for communication language in M. Wooldridge, J.P. Müller, and M.
example, all the participants of the videoconference). Tambe, Eds., Intelligent Agents II, Springer, 1995, 347–360.
7. Meyer, B. Object-Oriented Software Construction. Prentice Hall, 1988.
Individual SPAs combine their capabilities to offer 8. Parunak, H.V.D. Industrial and practical applications of distributed
new services that are beyond the scope of any individ- AI. In G. Weiss, Ed., Multi-Agent Systems. MIT Press, 1999, 377-421.
9. Simon, H.A. The Sciences of the Artificial. MIT Press, 1996.
ual provider. Competing NPAs form themselves into 10. Wooldridge, M. Agent-based software engineering. In IEE Proceedings
temporary coalitions in order to respond to particu- of Software Engineering 144, 1997, 26–37.
larly large requests for network resources.3 11. Wooldridge, M. and Jennings, N.R. Intelligent agents: Theory and
practice. The Knowledge Engineering Review 10, 2 (1995), 115–152.

Conclusion
Agent-oriented techniques are being increasingly
used in a range of telecommunication, commercial,
and industrial applications. However, if they are to Nicholas R. Jennings (nrj@ecs.soton.ac.uk) is a professor in the
Department of Electronics and Computer Science at the University of
enter the mainstream of software engineering it is Southampton, UK.
vital that clear arguments are advanced as to their
suitability for solving large classes of problems (as Permission to make digital or hard copies of all or part of this work for personal or class-
opposed to specific point solutions). To this end, this room use is granted without fee provided that copies are not made or distributed for
article has sought to justify precisely why agent-ori- profit or page. To copy otherwise, tothat copies bearpost on servers orthe full citation on
the first
commercial advantage and
republish, to
this notice and
to redistribute to
lists, requires prior specific permission and/or a fee.

3
In contrast, an object-oriented approach is less suitable for this problem because: it
cannot naturally represent the autonomous problem-solving behavior of the con-
stituent components (recall objects do not encapsulate action choice); it has nothing
to say about the design of flexible problem-solvers that balance reactive and proactive
problem-solving nor about interagent negotiation (other than the fact that it involves
message exchanges), and it has no innate mechanism for representing and reasoning
with the fact that the agents represent different stakeholder organizations (other than
the fact that they are different classes). © 2001 ACM 0002-0782/01/0400 $5.00


An agent based approach for building complex software systems

More Related Content

What's hot (20)

Similar to An agent based approach for building complex software systems (20)

Recently uploaded (20)

An agent based approach for building complex software systems