Invitation to Audience: you are invited to send written questions for the panel to us (the panel moderators/organizers) either by e-mail before the conference starts, or during the panel in hard copy.

Following the success of NASA’s Deep Space One Remote Agent software and the plethora of agent-assisted network management products currently on the market, agents have received a lot of attention lately. In addition, the agent model has been compared and contrasted to the current object model on more than one occasion. Many agent building tools and agents themselves are written and implemented in such OO languages as Java and C++.

How will agents and objects "relate" in the future? Will it be a case of:

• Convergence: Will the development of software agents be embedded in (and/or an extension of) commonly accepted OO methods and practices?
• vs. Repulsion: Will they exist independently as separate and unrelated paradigms?
• vs. Compromise: Will they exist separately, but share common areas of patterns, reuse, inheritance, programming languages, etc.?

How will it be useful to implement agents using objects?
Similarly, how will it be useful to implement objects using agents?

Agents as a design concept, at a somewhat higher level than objects, are becoming increasingly important. What are the implications of this for how agents should use the maturing distributed object infrastructures such as CORBA, especially in regard to agent communication and interaction policies, protocols, and interfaces? What should be the shape and timing of agent industry standards, in regard to objects?

What are the strengths and weaknesses of agent and object models/techniques? How do they conflict? What are the most fruitful opportunities to combine or synthesize them?

Are there areas where there is perceived, as opposed to actual conflict, between the approaches? In what areas is there a problematic lack of understanding between the agent R&D community and the object R&D community?

More fundamentally, what exactly is an agent and what are the paradigm’s relationships to the object model?

In describing Shoham’s (1997) work on agent-oriented programming (AOP), Jeff Bradshaw of Boeing’s Intelligent Agent Technology program posits that: "Agent-oriented programming can be thought of as a specialization of object-oriented programming approach, with constraints on what kinds of state-defining parameters, message types, and methods are appropriate. From this perspective, an agent is essentially ‘an object with an attitude.’" He further describes an ‘agent’ as "an entity whose state is viewed as consisting of mental components such as beliefs, capabilities, choices, and commitments."
Bradshaw continues that: "… coming up with a once-and-for-all definition of agenthood is… difficult: one person’s "intelligent agent" is another person’s "smart object"; and today’s "smart object" is tomorrow’s "dumb program." The key distinction is in our expectations and our point of view. The claim of many agent proponents is that just as some algorithms can be more easily expressed and understood in an object-oriented representation than in a procedural one (Kaehler and Patterson 1986), so it sometimes may be easier for developers and users to interpret the behavior of their programs in terms of agents rather than as more run-of-the-mill sorts of objects (Dennett 1987)".

Much work has been done in attempting to reconcile the OO and agent models, and some of the primary individuals involved are appearing as panelists.

References:
Bradshaw, J. M.1999, An Introduction to Software Agents In Software Agents, ed J. M. Bradshaw. Menlo Park, Calif.: AAAI Press.
Dennett, D. C. 1987. The Intentional Stance. Cambridge, Mass.: MIT Press.
Kaehler, T., and Patterson, D. 1986. A Small Taste of SMALLTALK. BYTE, August, 145–159.
Shoham, Y. 1997. An Overview of Agent-oriented Programming. In Software Agents, ed J. M. Bradshaw. Menlo Park, Calif.: AAAI Press.

Intelligent agents (IA) typically constitute a conceptually higher-level design abstraction than objects. OO is very often useful to implement IA.

Communication between IA’s is a key area today, including both in research and in industry standards efforts, e.g., FIPA’s Agent Communication Language (ACL), OMG agent interfaces, and ANSI Knowledge Interchange Format (KIF). However, currently these standards are not well connected to distributed OO infrastructures and standards. Many IA techniques, and many IA standards efforts including FIPA ACL and ANSI KIF, could benefit from OO design and techniques, e.g., in typing, inheritance, and interface definition languages.

Opportunity areas for fruitful R&D in object-oriented intelligent agents will in the near-term be driven especially by e-commerce and network management applications. Some such opportunity areas include:

• rule-based techniques that are tightly embeddable in OO programming languages;
• reusable exchangeable OO business logic in the form of rules;
• OO-flavored knowledge representations such as description logics and frame-based systems; and
• inter-agent messaging interfaces and interaction protocols that are specified and implemented on top of distributed object infrastructures such as CORBA.

Biography: Benjamin Grosof is a senior research scientist at IBM T.J. Watson Research Center in Hawthorne, NY. He led design and productization of IBM's Agent Building Environment (in release 1996-98), a pioneering tool for practical OO rule-based intelligent agents embedded in OO applications, piloted in mail, news, customer service, and manufacturing workflow. He is a contributor to several industry standards efforts on agent communication and interaction. Currently, he leads the Business Rules for Electronic Commerce project, developing IBM CommonRules --- a library of OO techniques for business rules interoperability and conflict handling, including semantics and XML syntax for agent communication --- and its pilot OO intelligent agent applications in e-commerce, including EECOMS, a $29Million industry consortium project on inter-enterprise supply chain integration in manufacturing.

One of the key benefits of the agent paradigm is that is allows us to capture intention. The fact that an agent has goals means that we can build agents that have our goals. Software systems that capture intention are relatively rare in the computer industry today.

A second key benefit of agent technology is greater ease in combining pre-existing systems together. The reason for this is that the same publicly understandable and semantically rich messages that communicative cognitive agents use to negotiate with each other also make it easier to stitch together systems constructed and owned by different organizations. The key attributes of publicly understandable (i.e., standard in some way) and semantically rich (i.e., flexible) are precisely what is needed to ease the integration process. This is particularly true when integrating systems that belong to different people of organizations.

The OO community shares many of the same desires as the agent community; and it is also true that a great deal of the technology and infrastructure that has been developed and deployed in the OO community can be used to develop and deploy agent based solutions. At the same time, some of the ideas and technology developed in the agent community can also be usefully taken up by the OO community. In both cases, this process may involve change.

The future of OO and agents can be seen more clearly if we can be clear about the differences between objects and agents, and if we can be clear about the benefits of each.

Biography: Frank McCabe is a Senior Researcher in the Network Agent Research program at Fujitsu Labs of America in Sunnyvale, CA, is the chair of the Architecture Technical Committee at FIPA (the "Foundation for Intelligent Physical Agents" organization based in Geneva, Switzerland), and has written extensively about agent–based scheduling, and "April" (an agent programming language for the internet).