The next wave of technological innovation must integrate linked organizations and multiple application platforms. Developers must construct unified information management systems that use the world wide web and advanced software technologies. Software agents, one of the most exciting new developments in computer software technology, can be used to quickly and easily build integrated enterprise systems. The idea of having a software agent that can perform complex tasks on our behalf is intuitively appealing. The natural next step is to use multiple software agents that communicate and cooperate with each other to solve complex problems and implement complex systems. Software agents provide a powerful new method for implementing these next-generation information systems.
What is an Agent?
An agent is simply another kind of software abstraction, an abstraction in the same way that methods, functions, and objects are software abstractions. An object is a high-level abstraction that describes methods and attributes of a software component. An agent, however, is an extremely high-level software abstraction which provides a convenient and powerful way to describe a complex software entity. Rather than being defined in terms of methods and attributes, an agent is defined in terms of its behavior. This is important because programming an agent-based system is primarily a matter of specifying agent behavior instead of identifying classes, methods and attributes. It is much easier and more natural to specify behavior than to write code.
There is a minimum set of common features that typify a software agent. A software agent is autonomous; the agent is capable of operating as a standalone process and performing actions without user intervention. A software agent is communicative; it communicates with the user, other software agents, or other software processes. A software agent is perceptive; it is able to perceive and respond to changes in its environment.
Software agents, like people, can possess different levels of competence at performing a particular task. For example, one email software agent might be quite dumb and capable of only forwarding email to a few specified locations. A second, smarter email agent might have the ability to automatically detect and delete spam. While software agents must be autonomous, communicative, and perceptive, they can have different levels of competence (intelligence) as determined by their programs - i.e., their behavioral specifications.
What is an Agency?
Software agents, like people, can be most useful when they work with other software agents in performing a task. A collection of software agents that communicate and cooperate with each other is called an agency. System designers using agents must consider the capabilities of each individual agent and how multiple agents can work together. The agent-based approach allows the system designer to implement the system using multiple agents, with each agent specialized for a particular task. For example, an electronic commerce application might have buyer agents, seller agents, stocking agents, database agents, email agents, etc. All of these agents need to communicate with each other and must have the capability of working together to achieve a common set of goals.
Why are Agents important?
Software developers and system designers use high-level abstractions in building complex software for one reason - to manage complexity. An abstraction focuses on the important and essential properties of a problem and hides the incidental components of that problem. Agents provide a new way of managing complexity because they provide a new way of describing a complex system or process. Using agents, it is easy to define a system in terms of agent-mediated processes.
Consider, for example, the system design issues involved in building a loan approval application that ties together branch banks, the main bank, loan underwriting companies, and credit reporting companies, and automates much of the loan approval process. Building this system using current technology is a complex and difficult task because the system decomposition forces the developer to deal with relatively low-level concepts (e.g. loan applications, account balances, credit ratings) when defining the overall system architecture. In addition, significant design time must be dedicated to defining the communications protocol and interfaces that will allow the bank to exchange data with the credit reporting agencies and loan underwriters. In an agent-oriented system design, the system solution might include a customer service agent, a loan application analysis agent, an underwriter agent, etc. The focus is placed on the behavior of each of these agents and communication between agents. The problem is made much easier because the level of abstraction is much higher and the programming problem becomes one of specifying agent behavior.
Multiple Software Agents For Enterprise Applications
An agent-based solution is useful and attractive because the various agents used in the solution inherently know how to do many things. For example, agents know how to communicate with other agents. The system developer no longer has to design communication protocols and message formats. The agent provides this capability as part of the basic agent mechanism. Agents have the inherent capability to build models of their environment, monitor the state of that environment, reason and make decisions based on that state. All the software developer needs to do is simply specify what the agents are to do in any given situation.
When should I use Agents?
Software agents are suitable for use in a wide variety of applications. They can make it much easier to build many kinds of complex systems. However, the system designer must remember that agents are not the long-sought silver bullet that developers have been seeking. Software agents are appropriate for use in implementing certain kinds of applications; in other problem domains, other technologies will be more appropriate. The developer must carefully analyze system requirements to determine if agents are an appropriate implementation mechanism.
Agents are well-suited for use in applications that involve distributed computation or communication between components. Agent technology is well-suited for use in applications that reason about the messages or objects received over a network. This explains why agent-based approaches are so popular in applications that utilize the Internet. Multi-agent systems are also suited for applications that require distributed, concurrent processing capabilities.
Since agents maintain a description of their own processing state and the state of the world around them, they are ideally suited to automation applications. Autonomous agents are capable of operating without user input or intervention. These agents can be used in applications such as plant and process automation, workflow management, robotics, etc.
Agents are not restricted to use in applications where the individual agents communicate with each other over a LAN or the Internet. In some applications it makes sense to utilize multiple agents executing on one machine and communicating with each other using some form of interprocess communication (e.g., RMI). For example, an embedded factory controller might consist of a user interface agent, a database interface agent, a machine tool interface agent, and a process monitoring and control agent. All of these agents could run concurrently on the same processor or could be easily distributed across multiple processors.
Again, agents are most suited to applications that require communications between components, sensing or monitoring of the environment, or autonomous operation. Since agents have the ability to reason (i.e. draw inferences), they can easily perform sequences of complex operations based on messages they receive, their own internal beliefs, and their overall goals and objectives.
What kind of systems can I build using agents and agent technology?
Agents are ideally suited for a wide variety of applications. They are particularly well-suited to:
- process and workflow automation
- electronic commerce
- distributed problem solving
- Internet applications
If Agents are appropriate for use in implementing my system, then how many agents do I need?
To paraphrase Albert Einstein - a good agent-based design will utilize as many agents as are required and no more. Like traditional applications, agent-based applications require careful analysis and design. While it is tempting to have every processing function performed by an agent, this is generally a bad idea. The designer must consider issues such as communications data transfer requirements, available communications bandwidth, processing power, memory and other computer resource constraints when developing a system architecture.
How smart should agents be?
Agents can be constructed with a wide range of capabilities. One of the advantages of the agent-based approach is that many times a complex processing function can be broken into several smaller, simpler ones. Since each individual agent can be crafted to be an expert in solving a specific problem or performing a particular task, you can build systems that exhibit complex behaviors by using a collection of relatively simple agents.
Sometimes, however, we do need to build agents that are quite smart. With the agent-based approach, you can implement agents with sophisticated intellectual capabilities such as the ability to reason, learn, or plan. In addition, intelligent software agents can utilize extensive amounts of knowledge about their problem domain. This means that the underlying agent architecture must support sophisticated reasoning, learning, planning, and knowledge representation.
Can I use agents with legacy systems or legacy code?
Software agents provide an ideal mechanism for integrating legacy systems with new data systems. Agents are well-suited to implementing these middleware applications. Agents can be used to perform data translation and implement data systems interfaces that meet a wide variety of requirements.
In many applications, system developers have legacy code that performs some unique function which is needed in their new applications. A software agent can be used to invoke and execute this legacy code, leveraging the value of the existing code base. Note that the software agent implementation must provide the appropriate support to enable execution of native software and legacy code.
Are agents hard to build?
Sophisticated software agents can be very difficult to build if you are building them from scratch. You will need specialized skills and knowledge in a variety of areas including agent architecture, communications technology, reasoning systems, knowledge representation, agent communication languages and protocols. If you want to add machine learning or machine planning capabilities, you will also need skill in these areas as well. If you don't possess these specialized skills and knowledge, you should use an agent construction toolkit. Agent construction toolkits allow software developers without agent expertise to quickly and easily build software agents.
What kind of tools are available to help me build agents?
The best way to begin building an agent-based system is to use an integrated toolkit such as AgentBuilder. AgentBuilder provides all of the tools you need for constructing software agents. Using AgentBuilder, a software developer only needs problem domain expertise. AgentBuilder provides support for all phases of agent software development - from system analysis through system debug and test. AgentBuilder provides a graphical programming environment where you can quickly and easily define agencies and agents and then specify individual agent behavior. AgentBuilder is coded entirely in Java and produces Java-based software agents.