Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
Supply Chain Process and Agent Design for E-Commerce
Mark E. Nissen
Naval Postgraduate School
[email protected]
Abstract
Supply chain management represents a critical
competency in today’s fast-paced, global business
environment. But neither EDI nor Web-based supply
chain applications can enable both the process
integration and flexibility demanded in the business
environment of today. In contrast, intelligent agents offer
potential and capability for buyer-seller integration and
flexibility, and early applications show great promise for
supply chain integration through agent technology.
However, agent technology remains relatively immature,
and we have yet to establish, test and verify good design
principles and techniques like those now well established
for other, more conventional software technologies. The
research described in this paper builds upon recent work
on agent-based supply chain integration to propose a set
of techniques and tools to integrate process and agent
design for the supply chain in an e-commerce context.
Preliminary results from implementation include
successful development of a supply chain agent federation
and demonstration of its effective performance in a
socially-conforming manner along the supply chain.
Implications of this work with respect to the e-commerce
context include the potential for rapid agent development
by end users themselves. And research along the lines of
this investigation may have a profound impact on the
manner in which e-commerce applications are designed
and developed in the near future.
1. Supply chain development challenges
Supply chain management represents a critical
competency in today’s fast-paced, global business
environment, and a number of effective practices (e.g.,
just-in-time deliveries, electronic data interchange (EDI),
supplier inventory management) are employed to improve
the competitiveness and efficiency of enterprises around
the world. Our two decades of experience with EDI
suggests commercial processes employed by buyers and
sellers must be mutually compatible in order for business
exchanges and transactions to occur effectively. And to
support the kinds of rapid purchase and responsive order
fulfillment required for e-commerce today, these buyer
and seller processes must also be closely integrated [16].
Presently, such integration is practically ensured through
the kinds of rigid EDI links established between trading
partners.
However, the dynamic, unpredictable business
environment of today further demands considerable
process flexibility along the supply chain, as a firm’s set
of commercial suppliers, customers, trading partners and
even strategic allies—together defining its supply chain
topology—may now shift both abruptly and frequently.
EDI does not offer the flexibility required to
accommodate such abrupt and frequent change, nor does
it conform to accommodate the diverse and idiosyncratic
preferences and work habits of specific individuals within
the organization. Thus, many firms are turning their
attention toward Web-based support for commercial
transactions (e.g., intranets/extranets, electronic catalogs
and storefronts, virtual malls). Unfortunately, even such
Web-based e-commerce applications do not satisfy these
joint requirements for process integration and flexibility,
as most Web-based supply chain technologies are
developed predominately for either the buyer or seller, but
not both; that is, they fail to closely integrate buyer and
seller processes.
A relatively novel stream of research follows [1] and
others (e.g., [2, 7, 15, 17]) to argue intelligent agents offer
potential and capability for buyer-seller integration and
flexibility. In other words, software agents developed
specifically for the supply chain may support the ability to
closely integrate buyer and seller processes as well as
provide sufficient flexibility to keep-up with changes to
supply chain topologies and operations, in addition to
being tailorable to meet the diverse needs, preferences and
work habits of individuals in the organization.
For instance, individual agents can be endowed with
sufficient intelligence to act autonomously in certain
circumstances and be empowered make responsible
decisions on behalf their principals. This enables such
agents to faithfully represent their principals’ interests in
commerce, as opposed to simply retrieving product
information or executing user-directed purchase
transactions. These latter, limited capabilities are
characteristic of most e-commerce applications in use
today. Individual agents are also easily conformable to
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
1
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
their users’ preferences, and intelligent agents can be
easily cloned, specialized and adapted to accommodate
various business practices of new or changing suppliers,
customers and other trading partners. This offers
flexibility unparalleled by extant object-oriented, clientserver and distributed systems employed in this domain.
Moreover, groups of agents participating in multi-agent
systems can collaborate through federations to solve
problems too large or complex for individuals to address
by themselves. This supports close coupling and tight
integration between buyer and seller organizations.
But despite these potential advantages, agent
technology remains relatively immature, and we have yet
to establish, test and verify good design principles and
techniques (cf. [19]) like those now well established for
object-oriented design, client-server development, expert
systems implementation and other, more mature
technological areas. And most agent applications today
are developed by people with doctorates in computer
science, as opposed to buyers and sellers in the enterprise
(e.g., business managers and professionals). This situation
is similar in many respects to the early days of expert
systems, most notably before the advent of expert system
“shells” to facilitate rapid application development.
The research described in this paper builds upon
recent work on agent-based supply chain integration to
propose a set of techniques and tools to integrate process
and agent design for the supply chain in an e-commerce
context. To demonstrate the use and utility of this
proposed approach, such techniques and tools are
employed and discussed with respect to a proof-ofconcept agent federation designed and developed
specifically for enterprise supply chain integration. The
structured, graphical nature of these techniques and tools
provides some indication the task of agent development
may become less onerous and demanding, particularly as
the corresponding developmental technologies continue to
mature. Paralleling advances enabled by expert system
shell tools, this offers the prospect of reducing both the
skill level and cycle time required to develop agent
applications.
In the sections that follow, we first provide some
background information pertaining to intelligent agents.
We then describe an integrated approach to supply chain
process and corresponding agent design. Some
preliminary results from design and implementation using
these techniques and tools are discussed in turn. The paper
then summarizes key conclusions and presents a number
of suggestions for future research along these lines.
2. Intelligent agent background
Work in the area of software agents has been ongoing
for some time, and it addresses a broad array of
applications (e.g., see [8]). Although researchers have yet
to reach consensus on how the term intelligent agent
should be defined, many common attributes (e.g.,
autonomy, intelligence, mobility, collaboration) are
beginning to emerge through the literature (e.g., see [5]).
For purposes of this paper, an intelligent agent represents
a software application capable of semi-autonomous
behavior and decision making to represent the interests
and preferences of its principal in an organizational
context.
This operational definition has both technical and
organizational aspects. Technically, agents possess
sufficient knowledge and inferential capability to behave
in a manner that would be classified as “intelligent” if
performed by a person. This enables their semiautonomous behavior and decision making (e.g., in
determining which product attributes and sources to
evaluate
and
making
purchasing
decisions).
Organizationally, agents are entrusted with sufficient
authority to make commitments for users in a sociallyconforming enterprise context. This enables them to
represent their principals and adhere to the same corporate
rules, policies and procedures (e.g., in entering into
binding commercial transactions) required to be followed
by people in the organization.
Yet clearly, as computer-based applications, agents are
comprised of the same kinds of software objects and
methods used to develop other systems (e.g., distributed
applications, client-server products, remotely-invokable
applets, expert advisory systems) that do not carry the
“agent” label. To our mind, agents are easily differentiated
on the basis of their intelligent behavior and entrusted
actions; that is, regardless of the underlying software
elements that comprise agents or other, more traditional
applications, a system's technical capabilities (e.g.,
intelligent behavior) and organizational use (e.g.,
entrusted representation) can differentiate an intelligent
agent from other, conventional software applications. We
feel the technology and use of agents autonomously
performing commercial process activities along the
enterprise supply chain serve to clearly distinguish them
from non-agent applications in this domain.
To further define and differentiate intelligent agents,
we integrate the agent-taxonomy work of [5] with a threedimensional structure from [6] to develop the analytical
framework presented in Figure 1. In this framework, we
use the same intelligence and mobility dimensions noted
by Gilbert et al., but with the substitution of the new
dimension collaboration in lieu of autonomy/agency. This
follows the presumption of agent autonomy stressed by
Franklin and Graesser. For purpose of discussion, we have
annotated this three-dimensional space with one, relatively
"pure" exemplar from each dimension.
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
2
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
Collaboration
Parallel processing
ISCA
Expert systems
Intelligence
Remote programming
Mobility
Figure 1. Agent framework
For example, many expert system applications are
quite extensive in terms of formalized, expert-level
intelligence, but they traditionally are not designed to
operate on foreign hosts, nor do they generally collaborate
with other expert systems to jointly solve problems.
Similarly, remote programming of the sort enabled by
Java and Telescript equip programs to execute on foreign
machines, but these procedural applications are not
generally endowed with the capability for intelligent
inference, nor are they usually thought of in terms of
collaborative processing. Likewise, parallel processing
has an explicit focus on collaborative problem solving
between multiple, parallel processors, but this problem
solving is usually focused more on numerical processing
than intelligent reasoning, and execution on foreign hosts
is rarely envisioned. Clearly, exceptions exist for each
class (e.g., distributed AI, intelligent Java agents), but
these three exemplars should convey the basic concepts
associated with each dimension.
Notice the annotation for intelligent supply chain
agents (labeled "ISCA" in the figure). Although this class
of systems is not as extreme as any of the three exemplars
from above along any particular dimension, it occupies a
position notionally in the middle of this three-dimensional
agent space. Conversely, all three of the exemplars from
above are situated along only a single axis. This adds to
the challenge of agent development work—particularly
where intelligent problem solving must be coordinated
among a federation of autonomous agents—but it serves
to enable a new set of powerful capabilities (e.g.,
collaborative problem solving) that proves to be quite
effective and useful for providing both interorganizational integration and individual flexibility to
complex processes such as supply chain management.
3. Agent-enabled supply chain process design
This section draws from [13] to provide a specific
example for discussion in the context of integrated process
and agent design. Two primary processes are involved
with a supply chain: customer purchasing and vendor
order fulfillment. Although these customer and vendor
processes can be viewed as separate, intra-organizational
activities within each of the respective buying and selling
enterprises, a strong case can be made for viewing such
activities together, as an integrated, inter-organizational
supply chain process.
The present investigation focuses on a specific,
enterprise supply chain process. On the buyer side, we
examine procurement work done by the supply
department at a medium-size government facility in the
U.S. On the seller side, we address order-fulfillment work
done by a leading-edge U.S. technology development
company.
User:
- ID rqmts
- PR form
- Mkt survey
- Select
source
X2’
- Use
product
X5’
X5’’
X2
Supply:
- Verify form
- Research sources
- Issue RFQs
- Analyze quotes
- Issue order
- Receive goods
- Make payment
X3
X4
Contractor:
- Product
marketing
- Prep quotes
X5
- Fulfill order
- Send invoice
- Deposit funds
Process flow
Figure 2. Enterprise supply chain process
This integrated enterprise supply chain process is
delineated in Figure 2, which uses notation from the
General Commerce Model [11]. Notice the process
includes a supply department intermediary, which
performs specialized purchasing activities on behalf of
diverse users (e.g., engineering, marketing or
manufacturing personnel) in the organization; that is, the
"buyer" in this process is comprised of two organizations:
the user (e.g., from Engineering, Marketing,
Manufacturing) and the supply department (i.e., the
intermediary). Experience indicates this internalintermediation arrangement is in no way unique to the
government organization studied in this investigation.
Exchanges internal to the buyer organization are
differentiated from their inter-organizational counterparts
by the prime symbol (e.g., X2', X5').
The enterprise process depicted here includes a
relatively high-level delineation of activities and
commercial exchanges. For instance, they account for a
number of "upstream" process activities and exchanges
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
3
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
that take place between the user, supply department and
contractor (e.g., conduct market survey (X2); complete
purchase request (PR) form (X2'), research sources; issue
requests for quotation (X3)). Although this high-level
diagram provides an essential enterprise view of the
supply chain process, which helps guide agent design, it
cannot fully represent how such activities are performed
and exchanges are made. Agent design requires much
lower-level process decomposition to acquire the
knowledge necessary for effective supply chain agent
performance. Similarly, "downstream" process activities
and exchanges (e.g., analyze quotations; select source
(X5'); issue order, receive goods and make payment (X5))
are also represented at a relatively high level and require
comparable process decomposition and knowledge
acquisition for agent development.
Drawing from [12], we initially designate seven of
these supply chain process activities for performance by
intelligent agents. For reference, they include: 1) complete
the PR form; 2) verify the PR form; 3) research sources;
4) issue RFQs; 5) prepare quotations; 6) analyze
quotations; and 7) issue purchase order. Such factors are
noted in the prior research as conducive to an agent-based
technological approach, which established two criteria for
evaluating the potential of agent technology in an
enterprise supply chain: 1) association of process
activities with commercial exchange, and 2) requirement
to apply process knowledge for effective work
performance. In the case of the present enterprise supply
chain, all seven of these activities are either associated
with supply chain exchanges, or their effective
performance
requires
considerable
process-level
knowledge by the people (or agents) assigned to them.
Performance of such knowledge work represents a
primary capability possessed by intelligent agents that
remains unmatched by competing technologies employed
along the supply chain.
4. Supply chain agent design
In this section, we discuss the design of intelligent
agents for the enterprise supply chain from above. We
first outline key features of an agent development
environment developed specifically for such agent work
and describe the use of Grafcets for agent design. We then
discuss the structure and behavior of an agent federation
developed for this enterprise supply chain. The discussion
is purposefully presented at a relatively-high level. The
interested reader can refer to prior work (esp. [9, 12]), on
which the present research builds, for additional technical
details.
4.1. Agent development environment
Agent Development Environment (ADE) is a research
application used to design, develop, debug, simulate and
deploy the agents discussed in this paper. ADE supports
the development of multi-agent applications capable of
running on a single machine or on a distributed network.
ADE is built on G2, an object-oriented graphical
environment that offers a robust platform for the
development of intelligent real time systems. As a highlevel, graphical environment, ADE serves as something of
a “shell” tool—as are common (e.g., JESS, Exsys, ART)
for rapidly developing expert system applications—for
agent development. For instance, as with expert system
shells, the multi-agent application developer may not need
to have a Ph.D. to construct a robust, effective system.
This contrasts with the manner in which most agent
applications are developed today.
Figure 3. ADE screenshot
Figure 3 presents a screenshot of ADE. It shows four
windows for (counter-clockwise from top-left) 1) top-level
agent design (e.g., to define agents), 2) a drag-and-drop
Grafcet palette (e.g., to construct Grafcets), 3) a Grafcet
under construction (e.g., to specify agent behaviors
through objects and methods), and 4) a programmer
interface (e.g., to use a library of APIs). Again, ADE is
detailed in the prior work referenced above. The main
ADE components are Agent, Activity, Message, Host,
Environment and Grafcet. We briefly outline each in turn.
4.1.1. Agent. The agent represents an intermediate level
of abstraction, well below that of the enterprise process
and agent federation but well above that of its component
activities, objects, methods and rules. As noted above, a
key concept associated with the agent is autonomy. Once
a specific agent class has been designed and one or more
individual agents have been instantiated to reflect user
preferences, an agent can be developed to operate
autonomously and persistently; that is, each activated
agent can make its own decisions and persistently strive to
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
4
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
perform its assigned duties, without human input or
intervention. Another key concept associated with the
agent is agency. A fundamental role of the agent is to
represent a user or some other principal, for example
making decisions and performing activities on behalf of
the principal. In the case of the agents discussed in this
paper, the three principals—user, supply department and
contractor—each have a class of agents designed to
represent them in supply chain operations and
transactions.
ADE uses delegation based event handling similar to
the JavaBeans model, in which agents use messages to
generate and listen for events. Each agent has a
federation-wide
unique
name.
This
enables
communication among agents distributed across a network
to be independent of an agent's location. Agents refer to
each other by name in messages, and the name of an agent
cannot be changed during its entire “life.” ADE provides
specialized agents (i.e., the Host and Environment
described below) to support distributed processing (e.g.,
"White Pages," "Yellow Pages"). And agents can be
dynamically created, deleted, cloned and moved across
the network, without human input or intervention. ADE
provides a root agent class called AdeAgent. AdeAgent
can be specialized and augmented to create domain- and
application-specific agent types. As noted above,
example agents from this paper include those developed
to represent the user, supply department and vendor along
an enterprise supply chain.
4.1.2. Activity. Each activity defines a specific agent
behavior, and therefore represents a lower level of
abstraction than the agent. The AdeActivity class
facilitates the development of a multi-thread capability
without dealing with threads, stacks and priorities. With
this, agents can be designed to concurrently perform
multiple activities of the same type or of different types,
and within an activity, multiple threads may be active at
the same time. Messages sent to an agent can either
initiate a new activity or continue a dialog with an
ongoing activity. And during execution of an activity, the
agent can send and receive either synchronous or
asynchronous messages. Each activity maintains a queue
of received messages. And within each agent, an
AgentHandler defines the destination activity for every
message received. This handler is called when a message
does not identify a specific destination activity—for
example, when an agent first initiates communication with
another agent.
Activities are implemented using objects and methods,
generally with considerable rule-based logic for making
decisions and performing autonomously. Process-level
knowledge is first formalized through activities for each
agent class. Individual agent instances can then be
specialized to reflect various users' preferences. In ADE,
the activity represents the level of abstraction at which
agent development converges with software engineering.
Once the agents' activities are specified and defined,
familiar object-oriented practices are employed in a
manner similar to that in which they would on most
contemporary software projects.
4.1.3. Message. Messages are used for communication
between agents, as well as communication between agents
and external devices or processes. ADE provides a basic
direct addressing message service with some additional
functionality (e.g., guaranteed delivery, message
broadcast, subject-based addressing). ADE provides a
root level message class of type AdeMessage. Messages
are handled by agent activities and can be sent to a
specific activity of an agent. No acknowledgment is
required for messages, and the exchange of messages
between agents may be synchronous or asynchronous. A
synchronous message blocks the activity of the sending
agent until a reply is received from the recipient.
Alternatively, an agent can be specified to perform its
activity without blocking through the use of asynchronous
messaging. Messages take a finite amount of time to be
delivered, so it is possible for them to get delayed or lost
and for messages sent in opposite directions by different
agents to cross one another (e.g., both be in transit at the
same time). ADE supports two major subclasses of
AdeMessage: 1) AdeSolication is a message for which the
sending agent expects a reply, and 2) AdeAssertion is a
message for which the sending agent expects no reply.
4.1.4. Host. ADE provides a specialized agent class,
called AdeHost, which supports other agents in an
application. And one AdeHost is provided for every
software process on which a multi-agent application is
running. When an agent is created, it is assigned to a
specific host. The host then installs the agent, registers the
agent properties and, if requested, connects the agent to
databases, on-line control systems, or other networked
services. The hosts thus provide some agent services and
infrastructure on each machine. An AdeHost is also
responsible for delivering messages, as well as
dynamically initializing, moving, cloning and destroying
agents. The "Locator Service" of a host enables each
agent to locate all the other agents in the application.
When an agent moves (e.g., from one machine to another),
AdeHost forwards all subsequent messages to the new
address. Thus, a principal function of this specialized
agent class is to keep track of the properties, locations and
states of the other agents on a particular host machine.
4.1.5. Environment. ADE supports agent federations by
providing another specialized agent class called
AdeEnvironment. Agents belonging to a particular
environment (e.g., as part of a supply chain federation)
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
5
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
may reside on and move between different hosts.
AdeEnvironment represents something of a meta-host
(i.e., host-of-hosts) agent and provides distributed
"Yellow Pages" services. Although agents can move to
different hosts across a network, an agent may not move
outside its environment (e.g., federation). Agents within
an environment can communicate via message with agents
outside the federation, however, provided they are
suitably equipped for such "third party" communication
(e.g., share common ontology, representational formalism,
communication protocol). Notwithstanding advances in
each of these areas (e.g., through Ontolingua, Knowledge
Interchange Format, Knowledge Query Manipulation
Language), robust third party agent collaboration remains
a challenging problem in agent research.
and technologies (e.g., UML/XML) seen by many as
offering promise in the e-commerce domain. And it
enforces its own agent-development methodology, which
critics may argue is rigid and restrictive. Conceivably,
agent applications developed using ADE may lack the
flexibility and power enabled by other, more general
approaches (e.g., direct Java coding). Alternatively, ADE
flattens the steep learning curve associated with agent
development and provides a structured, graphical
approach that facilitates rapid development. A detailed
comparison of ADE with alternative developmental
approaches and tools, such as those noted above, is
beyond the scope of this paper. However, it represents a
natural topic for future research along these lines and is
noted as such in the final section.
4.1.6. Grafcet. ADE enforces the use of Grafcets to
design the structure and behavior of intelligent agents.
Grafcets are derived from work on Petri Nets (e.g., see
[10, 14]) and have been accepted as an international
standard (IEC 848 and IEC 1131-3) for specification of
programmable logic controllers [3, 4]. The Grafcet
formalism offers the same level of semantic specification
as the Petri Net, from which it is derived, along with
additional tailoring (e.g., direct access to an agent’s
software objects and methods) for agent development.
Grafcets are used to outline the key steps and
transitions associated with process performance, along
with primary internal rules and procedures, external
events and alternative system states anticipated to affect
reasoning, decisions and behaviors represented for a
process. This technique facilitates mapping between the
knowledge and activities required for effective enterprise
performance, at the process level, and the behaviors of an
agent federation, at the technology level. As a method
supporting abstraction and successive refinement, it
facilitates agent design by allowing the developer to
concentrate on high-level process knowledge and
activities before diving into details of objects, messages,
rules and code.
Using ADE, Grafcets can be represented and
developed graphically. This provides integration between
the activities and required knowledge captured from an
enterprise, at the process level, and the technology-level
transitions and steps that guide agent behaviors and
communications. These latter agent behaviors and
communications are in turn implemented through objects,
methods, messages and rules; that is, below the agent level
of abstraction, familiar object-oriented analysis, design
and programming approaches and techniques apply. ADE
provides its own environment for simulation and
execution of agents, and it contains a crude translation
mechanism for implementing agents in Java.
Regarding weaknesses and limitations of this tool,
ADE does not take advantage of some current approaches
4.2. Agent structure and behavior
Our agent-based supply chain implementation involves
three Grafcets—one each for the user, supply department
and contractor roles depicted in Figure 2. Each of the
corresponding agent classes inherits architectural, design
and communication properties and capabilities from a
common superclass (supply-chain-agent). As noted above,
the root of this class hierarchy is AdeAgent, developed to
provide a basic and extensible set of agent capabilities.
Each of our three supply chain agent classes is specialized
through process-level knowledge and designed to be
explicitly tailorable to reflect specific rules, priorities and
preferences within the context of each individual in the
organization; that is, we develop agents that are domainspecific but still highly tailorable. This allows for
commonality of design at the agent-federation and class
levels along with flexibility in the instantiation and usage
of individual agents.
Thus, different organizations of users, purchasing
departments and vendors can draw from these supply
chain agent classes to refine and specialize their own
agents according to local departmental and organizational
needs and preferences. And unlike most EDI solutions,
which are generally inflexible below the level of a specific
department or organization, such agents can be developed
and specialized to the level of each individual within the
department or organization. For instance, six different
users within an engineering group can each instantiate
supply chain agents—developed as a common subclass to
conform to enterprise purchasing rules—individually
specialized to each user's unique preferences and
practices. One such agent may reflect its principal's
concern for budget and focus on low-cost solutions to
satisfying requirements. Another engineer may be far
more concerned with power, technical sophistication or
compatibility of products than their cost. Yet another
person in the group may prefer products from a particular
vendor, and so forth.
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
6
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
Individual users in the organization can also specialize
unique agents to accommodate various vendors and other
trading partners. For instance, one set of agents (e.g., a
subclass) can be specialized to interface specifically with
the GSA Advantage Web site, which is used today to
support online credit-card purchases by federal
employees, whereas another set of agents can be
specialized to interface seamlessly with, and
accommodate changes to, some other online sources (e.g.,
automobile parts suppliers, computer chip manufacturers,
other service providers). And again, below such classlevel specialization, each individual user can further refine
agents to reflect his or her personal preferences (e.g.,
product selections based on budget, performance,
particular vendor), and such agents can be modified to
reflect changes in user preferences and practices through
time. Such flexibility and individual variation is simply
infeasible with current EDI technology. Yet the sociallyconforming agents closely integrate buyer and seller
supply chain processes, which is beyond the capabilities
of most extant Web-based supply chain applications.
The Grafcet presented in Figure 4 builds upon the
design of [12]. It depicts the behavior of a particular user
(e.g.,
software
engineer,
marketing
manager,
manufacturing planner) in the organization and maps
homomorphically to the integrated process flow from
Figure 2. Specifically, the Grafcet flow begins with the
user identifying his or her product need and determining
the preliminary procurement requirements. The Grafcet
shows a transition following this first step. Each such
transition includes rules to define the conditions required
for an agent to proceed to the next step or set of activities.
The other supply chain process activities are represented
in similar fashion, and two other Grafcets (not shown) are
used to design and develop corresponding activities for
the supply intermediary and vendor agents. The reader can
refer to [13] for additional detail pertaining to these
Grafcets and agents.
Figure 4. Grafcet for user behavior
To summarize, the process design calls for seven
supply chain activities to be performed by three classes of
agents—user,
supply
and
contractor—working
collaboratively in a proof-of-concept federation. Agents
are developed through Grafcets, which graphically depict,
and are used to outline and guide, the behaviors of agents
at each process step. One such Grafcet is developed for
each agent class, which inherits architectural, design and
communication properties from a common superclass.
Each of the three supply chain agent classes is then
specialized through process-level knowledge and designed
to be tailorable to the level of an individual in the
organization. This serves to demonstrate the manner in
which we integrate process and agent design for a specific
enterprise supply chain. Given the considerable similarity
between supply chains of diverse enterprises, we have no
reason to believe the techniques and tools discussed here
cannot be employed in enterprises beyond the specific
case examined in this paper.
5. Design results and implications
We begin this penultimate section by summarizing the
results of the integrated process and agent design
approach outlined above and discussing some key
implications in terms of agent-based e-commerce. We
then summarize preliminary implementation results to
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
7
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
convey a sense of how the agent federation designed
above is operating in the enterprise supply chain.
We first note the preliminary nature of implementation
results, for the work to date has taken us only through
proof-of-concept development of the supply chain agents
from above. To date, the three Grafcets noted above have
been designed and defined to capture and specify
behaviors required for integration of the enterprise supply
chain process. And each agent class—user, supply and
contractor—has been implemented to collaborate and
autonomously perform the seven designated process
activities identified above and activated on the local
networks of both the government customer and
commercial vendor integrated through this enterprise
supply chain. These agents have also demonstrated they
can move, in process, to alternate machines within each
local network and are mobile between remote hosts across
the Internet.
Regarding the agents' social conformance and efficacy
of process performance, we note this agent federation is
able to successfully accept procurement requirements and
market-survey information from a human user, complete
appropriate
decision,
planning,
communication,
processing and exchange steps correctly, and effectively
integrate this enterprise supply chain process through
seamless performance of all assigned buyer, intermediary
and seller activities. The agents also communicate
effectively in duplex with others along the supply chain,
and the agent federation has been allowed to execute for
several days without problems of system instability, agent
indecisiveness or other maladies that can affect such
distributed computing applications (e.g., see [18]).
Technically, this provides evidence that agent-based
supply chain integration is quite feasible. Also, our
distributed architecture, integrated process and agent
design and reliance on common network protocols (e.g.,
TCP/IP) suggest the approach offers good potential to
scale well. Further, this agent-based supply chain
approach appears to be broadly applicable to businesses,
universities, non-profit institutions and other government
agencies beyond the specific focus of the implementation
described in this paper. And operationally, this work
provides evidence that agents can be designed through
tight cohesion with a process-level design and
implemented to behave in a socially-conforming manner.
Particularly when compared with extant supply chain
technologies (e.g., Web, EDI, paper-based processes),
integrated supply chain process and agent design as
described above appears to offer excellent potential for
performance improvement.
6. Conclusions and future research
Supply chain management represents a critical
competency in today’s fast-paced, global business
environment. Despite over two decades of effective
supply chain integration and partial automation through
EDI, however, supply chain managers in the
hypercompetitive business environment of today can no
longer count on the kinds of stability or predictability
required for EDI. Partly in response, many firms are
moving to Web-based support for commercial
transactions, but much of the capability for supply chain
integration is being lost during the transition from EDI to
Web-based technologies. In contrast, a relatively novel
stream of research argues intelligent agents offer potential
and capability for buyer-seller integration and flexibility.
And early applications show great promise for supply
chain integration through agent technology.
However, agent technology remains relatively
immature, and we have yet to establish, test and verify
good design principles and techniques like those now well
established for more mature technological areas. This
technological immaturity is particularly perplexing with
intelligent agents, because they must be socially
conforming. The research described in this paper builds
upon recent work on agent-based supply chain integration
to propose and discuss a set of techniques and tools to
integrate process and agent design for the supply chain in
an e-commerce context.
Through the discussion above, we first provided some
background information pertaining to intelligent agents
and then described an integrated approach to supply chain
process and agent design. We then analyzed the supply
chain of an operational enterprise to demonstrate the use
and utility of what is emerging to become a methodology
for design and development of multi-agent systems—one
that may not require a Ph.D. to develop effective agent
applications.
Some preliminary results from design using these
techniques and tools include tight technical integration of
enterprise-level requirements and agent-specific behaviors
implemented through a shell-like tool. Preliminary results
from implementation include successful development of
the three supply chain agents discussed above and
effective performance in a socially-conforming manner
along the supply chain. This is in addition to agents
demonstrating correct process behaviors and relatively
long-lived operation without experiencing technical
problems or common maladies that can affect such
distributed computing applications.
Implications of this work with respect to the ecommerce context are many. For one, the agent-enabled
supply chain offers tight integration of buyer and seller
processes without the rigid inflexibility of EDI, and it
provides considerable process flexibility without suffering
the kinds of integration losses noted for Web-based
supply chain technologies. This combination of process
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
8
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
integration and system flexibility reflects some of the best
attributes associated with both EDI and Web-based
applications. However, empirical research is required to
determine the extent to which multi-agent systems may
outperform other emerging applications such as Webbased EDI. This represents a natural follow-on research
topic to the present investigation.
Another e-commerce implication is economic in
nature. The proof-of-concept agent federation examined in
this study was developed using an emerging methodology
that integrates supply chain process and agent design,
which we note offers a number of technical and other
advantages over many current approaches. We also note
the graphical, Grafcet interface provided by ADE may
support agent development at a relatively low level of
expertise—operationalized as agent development by
business managers and professionals, as opposed to
computer science Ph.D.s. If we are beginning to uncover,
define and refine a technically-sound methodology that
can be used to deliver superior supply chain functionality
at relatively low cost and cycle time, this may have
profound impact on the manner in which e-commerce
applications are designed and developed in the near
future.
Alternatively, we also note the agents developed using
ADE do not take advantage of some current approaches
and technologies (e.g., UML/XML) seen by many as
offering promise in the e-commerce domain. When agent
applications developed through these alternative
approaches become manifest and can match the process
integration and flexibility of the agents described above,
empirical analysis and testing of such competing
developmental approaches and technologies will make for
useful research to build upon this investigation.
In summary, considerable research is required to
further exposit, test and refine the work described in this
paper, and the present results are notably preliminary in
nature. But we hope to have made a contribution to the
agents and e-commerce research communities, and we
look forward to continued research along the lines of this
investigation.
7. References
[1] Barbuceanu, M. and Fox, M.S., "The Design of COOL: A
Language for Representing Cooperation Knowledge in MultiAgent Systems," WWW: http://www.ie.utoronto.ca/EIL/ABSpage/ABS-intro.html (1993).
[2] Collins, J., Youngdahl, B., Jamison, Sc., Mobasher, B. and
Gini, M., "A Market Architecture for Multi-Agent Contracting,"
in: K. Sycara and M. Wooldridge (Eds.), Proceedings of the
Second International Conference on Autonomous Agents,
Minneapolis, MN (1998), pp. 285-292.
[3] David, R. and Alla, H. Petri Nets and Grafcet: Tools for
Modeling Discrete Events Systems. Prentice-Hall International:
UK (1992).
[4] David, R. “Grafcet: A Powerful Toll for Specification of
Logic Controllers,” IEEE Transactions on Control Systems
Technology 3:3 (September 1995), pp. 253-268.
[5] Franklin, S. and Graesser, A. “Is It an Agent or Just a
Program? A Taxonomy for Autonomous Agents,” in
Proceedings of the Third International Workshop on Agent
Theories, Architectures, and Languages Springer-Verlag: New
York, NY (1996).
[6] Gilbert, D., Aparicio, M., Atkinson, B., Brady, S., Ciccarino,
J., Grosof, B., O’Connor, P., Osisek, D., Pritko, S., Spagna, R.,
and Wilson, L. “IBM Intelligent Agent Strategy,” working
paper, IBM Corporation (1995).
[7] Gini, M. and Boddy, M., Workshop on Agent-Based
Manufacturing," conducted at the Autonomous Agents '98
Conference, Minneapolis, MN (1998).
[8] Jennings, N.R., Sycara, K. and Wooldridge, M. "A
Roadmap of Agent Research and Development," Autonomous
Agents and Multi-Agent Systems 1:1 (1998), pp. 7-38.
[9] Mehra, A. and Nissen, M.E. " Case Study: Intelligent Software
Supply Chain Agents Using ADE," Proceedings from the AAAI
Workshop on Software Tools for Developing Agents (1998).
[10] Murata, T. "Petri Nets: Properties, Analysis and
Applications," Proceedings of IEEE 77:4 (1989), pp. 541-580.
[11] Nissen, M.E. "The Commerce Model for Electronic
Redesign," Journal of Internet Purchasing WWW:
http://www.arraydev.com/commerce/JIP/9702-01.htm, (July
1997b).
[12] Nissen, M.E. and Mehra, A. "Redesigning Software
Procurement through Intelligent Agents," Proceedings from the
AAAI Workshop on AI in Reengineering and Knowledge
Management (1998).
[13] Nissen, M.E. "Agent-Based Supply Chain Integration,"
Journal of Information Technology Management Special Issue on
E-Commerce in Procurement and the Supply Chain (forthcoming
1999).
[14] Peterson, J.L. Petri Net Theory and the Modelling of Systems
Printice-Hall: Englewood Cliffs, NJ (1981).
[15] Rodriguez-Aguilar, J.A., Martin, F.J., Noriega, P., Garcia,
P. and Sierra, C., "Competitive Scenarios for Heterogeneous
Trading Agents," in: K. Sycara and M. Wooldridge (Eds.),
Proceedings of the Second International Conference on
Autonomous Agents, Minneapolis, MN (1998), pp. 293-300.
[16] Sokol, P. From EDI to Electronic Commerce: A Business
Initiative McGraw-Hill: New York, NY (1996).
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
9
Proceedings of the 33rd Hawaii International Conference on System Sciences - 2000
[17] Walsh, W.E., Wellman, M.P., Wurman, P.R. and MacKieMason, J.K. “Some Economics of Market-based Distributed
Scheduling, Submitted for publication (1997).
[18] Wooldridge, M., "Pitfalls of Agent-Oriented
Development," in: K. Sycara and M. Wooldridge (Eds.),
Proceedings of the Second International Conference on
Autonomous Agents, Minneapolis, MN (1998), pp. 385-391.
[19] Wooldridge, M., Jennings, N and Kinny, D. “A
Methodology for Agent-Oriented Analysis and Design,”
Proceedings Third Annual Conference on Autonomous Agents,
Seattle, WA (1999), pp. 69-76.
0-7695-0493-0/00 $10.00 (c) 2000 IEEE
10