AN AGENT-BASED APPROACH FOR    BUILDING COMPLEX   SOFTWARE SYSTEMSWHY AGENT-ORIENTED APPROACHES ARE WELL SUITED FOR       ...
relationships are not static: they often vary over                                       of basic components to be grouped...
or to manage the dependencies that ensue from being          agents may form a team to deliver a service that nosituated i...
tant observation is that complex systems have mul-           eral, there will be multiple candidates and the dif-tiple loc...
representational power enables agent systems to            way of characterizing many types of problems. Just asexploit tw...
fact to others who it believes are capable of perform-          Case Study: Provisioning a Virtualing it, these agents may...
order to offer a new service).                                                            ented approaches are appropriate...
Upcoming SlideShare
Loading in …5
×

An agent based approach for building complex software systems

1,045 views

Published on

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,045
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
29
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

An agent based approach for building complex software systems

  1. 1. AN AGENT-BASED APPROACH FOR BUILDING COMPLEX SOFTWARE SYSTEMSWHY 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 suitedbackground, a wide range of software engineering to engineering complex, distributed software systems.paradigms have been devised.Each successive development Managing Complexity ineither claims to make the engi- Software Systemsneering process easier or Industrial-strength software ispromises to extend the complex- N ICHOLAS R. J ENNINGS complex: it has a large number ofity of applications that can feasi- parts that have many interactionsbly be built. Although evidence [9]. Moreover this complexity isis emerging to support these not accidental [2], it is an innateclaims, researchers continue to property of large systems. Givenstrive for more effective techniques. To this end, this this situation, the role of software engineering is toarticle 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 importantmultiagent system [4]) affords software engineers a regularities [9]:number of significant advantages over contemporarymethods. 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 interrelatedis no evidence to suggest it will represent an order of subsystems, each of which is in turn hierarchic inmagnitude 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
  2. 2. relationships are not static: they often vary over of basic components to be grouped together andtime. 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 Softwarenonhierarchic ones of comparable size (that is, Engineeringcomplex systems will evolve from simple systems The first step in arguing for an agent-orientedmore 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 antions among subsystems and those within subsys- encapsulated computer system situated in sometems. The latter are both more frequent (typically at environment and capable of flexible, autonomousleast 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 someinteractions between them. Moreover, althoughmany of these interactions can be predicted atdesign time, some cannot. Drawing these insights together, it is possible todefine a canonical view of a complex system (see Fig- subsystem related to infrequenture 1). The system’s hierarchical nature is expressed interaction subsystem frequent interactionthrough the “related to” links, components within a componentsubsystem are connected through “frequent interac-tion” links, and interactions between components areexpressed 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 definitionfor helping to manage complexity [1]: that require elaboration. Agents are: clearly identifi- able problem-solving entities with well-definedDecomposition: The most basic technique for boundaries and interfaces; situated (embedded) in atackling large problems is to divide them into particular environment over which they have partialsmaller, more manageable chunks, each of which control and observability—they receive inputs relatedcan then be dealt with in relative isolation (note to the state of their environment through sensors andthe 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 particularlimits 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 ownmodel 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 timelyscope 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 goalsaging the interrelationships between the various and take the initiative) [11].problem-solving components (note the subsystem When adopting an agent-oriented view, it soonand interaction links of Figure 1). The ability to becomes apparent that most problems require orspecify and enact organizational relationships helps involve multiple agents: to represent the decentralizeddesigners 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 onenotation of control. Hence the more neutral term “organization” is used here. another: either to achieve their individual objectives36 April 2001/Vol. 44, No. 4 COMMUNICATIONS OF THE ACM
  3. 3. or to manage the dependencies that ensue from being agents may form a team to deliver a service that nosituated in a common environment. These interac- one individual can offer). The temporal extent oftions can vary from simple semantic interoperation, these relationships can also vary enormously, rangingthrough 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 actate 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 collectivesinteractions generally occur through a high-level [4, 11].(declarative) agent communication language (often Drawing these points together (see Figure 2), it canbased 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 modelingtime and by whom (compare this with method invo- complex systems; andcation or function calls that operate at a purely syn- • Show that the agent-oriented philosophy fortactic 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-Orientedapparatus to make context-dependent decisions Decompositionsabout 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 interactingof the relationship between the agents. For example, components, working together to achieve particularthey may be peers working together in a team or one objectives occurs throughout the system. Given thismay 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 Ineling organizational relationships (manager, team other words, each component can be thought of asmember). 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 acknowledgedleader) and new relations are created (a number of within the object-oriented community (see [7]). COMMUNICATIONS OF THE ACM April 2001/Vol. 44, No. 4 37
  4. 4. 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 powerfuldecompositions means the individual components abstractions are those that minimize the semanticshould 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 thetrol (that is, they should be active) and they should constructs present in the solution paradigm. In thehave 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 organizationalfill both their individual and collective objectives, they relationships. Taking each in turn:need to interact (recall complex systems are only nearlydecomposable). 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 constituentpotential links: interactions will occur at unpredictable components that act and interact according to theirtimes, 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 asand predict or analyze all the possibilities at design agents has been made previously.time. It is more realistic to endow the components withthe ability to make decisions about the nature and The interplay between the subsystems andscope 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 thatcomponent 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-levelated 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 invariablydeclarative 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” orspontaneously 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. Theycommunication language, coupling becomes a also require collections of components to be treated asknowledge-level issue. At a stroke this removes syn- a single conceptual unit when viewed from a differenttactic concerns from the types of errors caused by level of abstraction. Here again the agent-orientedunexpected interactions. Secondly, the problem of mindset provides suitable abstractions. A rich set ofmanaging control relationships between the software structures are available for explicitly representingcomponents (a task that bedevils traditional objec- organizational relationships. Interaction protocolstive-based decompositions) is significantly reduced. exist for forming new groupings and disbandingAll agents are continuously active and any coordina- unwanted ones. Finally, structures are available fortion or synchronization that is required is handled modeling collectives. The latter point is especiallybottom-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 componentsway to modularize a complex system is in terms of working together to achieve a collective goal.multiple autonomous components that can act andinteract in flexible ways in order to achieve their set The Need for Flexible Management ofobjectives. Given this, the agent-oriented approach is Changing Organizational Structuressimply the best fit to this ideal. Organizational constructs are first-class entities in agent systems—explicit representations are made ofThe Suitability of Agent-Oriented organizational relationships and structures. More-Abstractions over, agent-oriented systems have the concomitantA 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. This38 April 2001/Vol. 44, No. 4 COMMUNICATIONS OF THE ACM
  5. 5. representational power enables agent systems to way of characterizing many types of problems. Just asexploit two facets of the nature of complex systems. the real-world is populated with objects that haveFirst, the notion of a primitive component can be operations performed on them, so it is equally full ofvaried according to the needs of the observer. Thus active, purposeful agents that interact to achieve theirat 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 fromcan be viewed as primitive components, and so on precisely this perspective: “we view the world as a set ofuntil the system eventually bottoms out. Secondly, autonomous agents that collaborate to perform somesuch 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 programmingplex systems. Their availability means that individ- models exhibit increasing degrees of localization andual agents or organizational groupings can be encapsulation [8], and agents follow this trend bydeveloped in relative isolation and then added into localizing purpose inside each agent, by giving eachthe system in an incremental manner. This, in turn, agent its own thread of control, and by encapsulatingensures there is a smooth growth in functionality. action selection. Additionally, ever-richer mechanisms for promoting reuse are being provided. Here, theWill Agent-Oriented Techniques Be agent view also reaches new heights. Rather thanWidely Adopted? stopping at reuse of subsystem components (designThere 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), agentsa software engineering paradigm: the degree to enable whole subsystems and flexible interactions towhich agents represent a radical departure from be reused. In the former case, agent designs andcurrent software engineering thinking and the implementations are reused within and betweendegree to which existing software can be integrated applications. Consider, for example, the class of agentwith agents. architectures that have beliefs (what the agent knows), A number of trends become evident when examin- desires (what the agent wants) and intentions (whating the evolution of programming models. There has the agent is doing) at its core. Such architectures havebeen an inexorable move from languages that have been used in a wide variety of applications includingtheir conceptual basis determined by the underlying air traffic control, process control, fault diagnosis andmachine 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 COMMUNICATIONS OF THE ACM April 2001/Vol. 44, No. 4 39
  6. 6. fact to others who it believes are capable of perform- Case Study: Provisioning a Virtualing it, these agents may submit a bid to perform the Private Networktask if they are interested, and the originator then As an exemplar of a complex, distributed systemdelegates the task to the agent that makes the best consider the task of dynamically provisioning abid) 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 bereused in significant numbers of applications. In more definitive, let the task in question be settingshort, 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 andand, for this reason, the main concepts and tenets of organizations (see Figure 3). There are the end usersthe 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 willporation of agents is that their adoption does not do this). This negotiation revolves around the costrequire a revolution in terms of an organization’s soft- of the conference call and the quality of service thatware capabilities. Agent-oriented systems are evolu- is desired. The SPA that wins the contract thentionary and incremental as legacy (non-agent) negotiates with the various NPAs to determinesoftware can be incorporated in a relatively straight- which of them can deliver the desired quality andforward 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 benefitspresents an agent interface to the other software com- that are have been claimed for an agent-orientedponents. Thus from the outside it looks like any other approach to software engineering. Autonomousagent. On the inside, the wrapper performs a two-way agents are the most natural means of representing thetranslation function: taking external requests from distinct individuals and organizations that are presentother 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 andrequests and mapping them into the appropriate set has control over the actions it chooses and theof agent communication commands. This ability to resources that it expends. The agents need to bewrap 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 networkrequirements are placed on the system, agents may be capacity from another NPA in order to maintain itsdeveloped and added. This feature enables a complex agreed upon quality of service if part of its networksystem to grow in an evolutionary fashion (based on fails) and they need to be able to opportunisticallystable 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 complementaryworking version of the system available. service capabilities and may decide to act together in40 April 2001/Vol. 44, No. 4 COMMUNICATIONS OF THE ACM
  7. 7. 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 generalknowledge-level interactions in order to achieve their points are then made more concrete by showing howindividual 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 forinteraction is negotiation. Thus, to set the time of the proponents of other software engineering paradigmsvideoconference or to select a particular service or net- to claim that the key concepts of agent-orientedwork 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-orientedments. 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 providescircumstances. 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 toorganizational context. The application involves a developing complex, distributed systems and annumber of different real-world organizations: individ- extension of those currently available in otherual end users, companies that provide the different paradigms. ctypes of services, and network providers that controlthe underlying telecommunications infrastructure.These relationships directly affect the agents’ behavior. ReferencesFor 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-compliantunrelated companies. Similarly, the PCAs that have agents. In Proceedings of the 5th International Conference on Practicalagreed 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 agentlectives 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 distributednew 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 Proceedingstemporary 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.ConclusionAgent-oriented techniques are being increasinglyused 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 ofenter the mainstream of software engineering it is Southampton, UK.vital that clear arguments are advanced as to theirsuitability 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 forarticle 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: itcannot naturally represent the autonomous problem-solving behavior of the con-stituent components (recall objects do not encapsulate action choice); it has nothingto say about the design of flexible problem-solvers that balance reactive and proactiveproblem-solving nor about interagent negotiation (other than the fact that it involvesmessage exchanges), and it has no innate mechanism for representing and reasoningwith the fact that the agents represent different stakeholder organizations (other thanthe fact that they are different classes). © 2001 ACM 0002-0782/01/0400 $5.00 COMMUNICATIONS OF THE ACM April 2001/Vol. 44, No. 4 41

×