I’ve been working with Mohammed Mastan on a team based software engineering project that involves designing and implementing an agent oriented game. The game is required to use techniques from agent oriented software engineering (AOSE). One of the goals of this project is to learn about AOSE techniques and applying some of them within a small software project. Another goal is to teach mathematics to Year 10 students within Victoria, Australia, although I doubt that others will seriously use it for that purpose.
Today, Mohammed and I delivered a presentation on an early prototype of our project. During the presentation, I used a set of notes and visuals to elucidate and elaborate on our ideas, and to give some sense of direction of where we’re going with the final version. Mohammed talked about the database aspect of our project. I’m not sure he has prepared presentation slides to distribute to anyone who’s interested in getting them, since he’s a very busy person. So far, working with Mohammed has been a positive experience. He has humbled me with his professional knowledge of database and database management.
There are various open source projects that concentrate on developing a set of libraries and APIs for building applications using agent oriented techniques. JADE and Jadex both use Java in developing their respective functionalities. Both of these packages are pretty functional at the moment, while it should be stressed that Jadex was originally (and still is) a research project.
Currently, we’re using Python to implement our game. I’m trying to integrate Brent Burley’s Python implementation of reversi into our game. Burley’s Python implementation is useful for what we’re doing, and its basic artificial intelligence for the computer player is sufficient for our small project. Being a database expert, Mohammed is concentrating on the database aspect of our project, in addition to doing many of the design work. He has looked into using Python’s interface to SQLite. From our discussion on this issue, it looks like we’re going ahead with using this library for our database engine. Before version 2.5, Python didn’t have support for SQLite. With the release of Python 2.5.x, and version 2.6.x, it’s now rather painless to get a Python program to communicate with a lightweight database engine.
Our project code name is “Magent”. The “agent” part serves to remind us that we should use agent oriented techniques. The capital letter “M” can stand for many things: multi-agent system, mathematics, magnificent 😉 , etc. Fingers crossed for our final version, everyone.
In developing a multi-agent system (MAS), we refer to relevant research papers for theoretical foundation. When it comes to actually implementing the MAS, we can use various frameworks to code the MAS. The Java Agent and DEvelopment Framework (JADE) is a FIPA compliant software framework implemented using the Java programming language. The source code is released under the GNU Lesser General Public License (LGPL) Version 2. Agents can be conceptualized in terms of the belief-desire-intention (BDI) model. The Jadex reasoning engine is a Java implementation of BDI for constructing intelligent software agents using Java and XML. Jadex can be integrated with JADE to endow software agents with artificial intelligence. Like JADE, the Jadex source code is released under the GNU LGPL. The Jadex project web site has a page containing a list of related frameworks and tools for agent construction.
This post collects together a number of Australian research units on intelligent agents. The research units are primarily Australian universities.
- RMIT University — Agent Group
- Swinburne University of Technology — Research Program for Intelligent Agents and Multi-Agent Systems (IAMAS)
- University of Canberra — research staffs within the Faculty of Information Sciences and Engineering conduct research into AOSE
- University of Melbourne — Intelligent Agent Laboratory, otherwise known as Agentlab
- University of New South Wales — the School of Computer Science and Engineering offers a unit called COMP3431 An Introduction to Intelligent Agent Architectures
Leon Sterling of the Department of Computer Science and Software Engineering, University of Melbourne, maintains the page Intelligent Agent Resource Links.
Paradigms of software engineering
Classical software engineering is roughly based upon the waterfall life-cycle model, which consists of the following major stages: requirements, analysis, design, implementation, and maintenance . Starting from the requirements phase, we consider a high-level specification of the software product, its core functionalities, and what we want to accomplish with the software. Our investigation during this stage is also referred to as analyzing the business requirements, since we are considering the software’s functionalities from the perspective of an end-user. Based upon the results of our investigation from the requirements stage, we analyze the software requirements at a lower level from the perspective of a software engineer. The design phase is where we specify in low-level details the software architecture, its major components, and pseudocode of core algorithms and data structures. In this stage, we specify the software in such a way and with sufficient details that it is amenable to implementation by programmers during the implementation phase. The maintenance stage consists of bug hunting, bug fixing, adding features, and updating the software. The progression of stages flows linearly from one to another as shown in Figure 1.
Modern software development processes are based on the classical waterfall model with various degrees of refinements, such as iterating through development stages and incremental development of software . Alternatives to the waterfall model that incorporate iteration and incrementation include various evolutionary models, the spiral model, extreme programming, and open source software development. Many of these modern software development processes view software as comprised of objects, each encapsulating both data and operations on those data. An object is thus a computational unit that conforms to Booch’s principles of decomposition, abstraction, and hierarchy (or organization) . The object oriented approach to software engineering was introduced as a replacement to the procedural oriented approach. A pragmatic motivation of the object oriented approach was to address the “software crisis”, which contends that a disproportionate number of software projects was (and are) delivered late, exceeded budgets, or did not adequately address user requirements.
Agent oriented software engineering
The agent oriented approach to software engineering (AOSE) is one of the latest contenders in the historic development of programming paradigms . AOSE promises to be an exciting new software engineering approach with techniques more suited to the construction of large, complex software systems than those techniques belonging to the object oriented approach. To be a viable concept, there is a need for a uniform approach throughout the development life cycle of an agent oriented system, analogous to the unified process  for object oriented analysis and design.
Techniques for AOSE
Burmeister  extends object oriented analysis techniques to the specific case of the analysis of agent oriented systems. Throughout the object oriented analysis phase, various models are developed including the basic model, static model, and dynamic model. Agent oriented analysis counterparts to these models include the agent model, the organizational model, and the cooperation model. The agent model describes the architecture of an agent and its internal structure. The organizational model is used for specifying the relationships among agents; for example, whether agents are organized in hierarchical relationships similar to object oriented inheritance, or some other multi-agent organizational structures. Finally, the cooperation model specifies the means by which agents interact and cooperate with each other.
However, it should be noted that Burmeister  focuses more on the analysis phase of agent oriented systems, with little discussion on other phases of the software development life cycle. One of the early work devoted to the specification, implementation, and verification of agent systems is Wooldridge . Using the belief-desire-intention model of an agent , Wooldridge discusses formal methods applicable during the specification, implementation, and verification of agent systems. A review of various techniques for engineering agent based systems is contained in . That paper reviews the AAII methodology , the Gaia methodology , an extension of the Unified Modelling Language (UML) for modelling agent based systems , the DESIRE framework [3, 6], the Cassiopeia method , and an agent specification framework in the Z language .
Modelling agents with UML
In , Bergenti and Poggi use UML based notation to model the architecture of a multiagent system, its ontology, and agent interaction protocols. As a modelling language, UML lacks security features useful for developing secure systems. This shortcoming is particularly pronounced when one considers the use of UML for modelling mobile agents, one of whose characteristics is migrating from systems to systems with uncertain security implications. Thus in the case of modelling mobile agents, Jurjens’ security extension to UML, abbreviated as UMLsec , offers a promising means of securing agents at the design level.
- F. Bergenti and A. Poggi. Agent-oriented software construction with UML. In S. K. Chang, editor, Handbook of Software Engineering & Knowledge Engineering Vol. 2: Emerging Technologies, pages 757-769, Farrer Road, Singapore, 2002. World Scientific.
- G. Booch. Object-Oriented Analysis and Design with Applications. Addison-Wesley, Reading, MA, USA, 1994.
- F. Brazier, B. Dunin-Keplicz, N. R. Jennings, and J. Treur. Formal specification of multiagent systems: A real-world case. In Proceedings of the First International Conference on Multi-Agent Systems (ICMAS-95), pages 25-32, San Francisco, CA, USA, 1995.
- B. Burmeister. Models and methodology for agent-oriented analysis and design. In K. Fischer, editor, Working Notes of the KI’96 Workshop on Agent-Oriented Programming and Distributed Systems, Saarbrucken, Germany, 1996. DFKI Document D-96-06.
- A. Collinot, A. Drogoul, and P. Benhamou. Agent oriented design of a soccer robot team. In Proceedings of the Second International Conference on Multi-Agent Systems (ICMAS96), pages 41-47, Kyoto, Japan, 1996.
- B. Dunin-Keplicz and J. Treur. Compositional formal specification of multi-agent systems. In M. Wooldridge and N. R. Jennings, editors, Intelligent Agents: Theories, Architectures, and Languages, volume 890 of LNAI, pages 102-117, Berlin, Germany, January 1995. Springer-Verlag.
- J. Jurjens. Secure Systems Development with UML. Springer, 2004.
- D. Kinny, M. Georgeff, and A. Rao. A methodology and modelling technique for systems of BDI agents. In W. Van de Velde and J. W. Perram, editors, Agents Breaking Away: Proceedings of the Seventh European Workshop on Modelling Autonomous Agents in a Multi-Agent World, volume 1038 of LNAI, pages 56-71, Berlin, Germany, 1996. SpringerVerlag.
- J. Lind. Issues in agent-oriented software engineering. In P. Ciancarini and M. Wooldridge, editors, AOSE, volume 1957 of LNCS, pages 45-58. Springer, 2000.
- M. Luck and M. d’Inverno. A formal framework for agency and autonomy. In Proceedings of the First International Conference on Multi-Agent Systems (ICMAS-95), pages 254-260, San Francisco, CA, USA, June 1995.
- J. Odell, H. Van Dyke Parunak, and B. Bauer. Representing agent interaction protocols in UML. In P. Ciancarini and M. Wooldridge, editors, Agent-Oriented Software Engineering – Proceedings of the First International Workshop (AOSE-2000), Berlin, Germany, 2000. Springer-Verlag.
- M. Priestley. Practical Object-Oriented Design with UML. McGraw-Hill Education, Berkshire, UK, 2nd edition, 2003.
- A. S. Rao and M. P. Georgeff. Modeling rational agents within a BDI-architecture. In R. Fikes and E. Sandewall, editors, Proceedings of Knowledge Representation and Reasoning (KR&R-91), pages 473-484, San Mateo, CA, USA, April 1991. Morgan Kaufmann Publishers.
- S. R. Schach. Object-Oriented and Classical Software Engineering. McGraw-Hill, New York, NY, USA, 6th edition, 2005.
- M. Wooldridge. Issues in agent-based software engineering. In P. Kandzia and M. Klusch, editors, Cooperative Information Agents, volume 1202 of LNCS, pages 1-18. Springer, 1997.
- M. Wooldridge and P. Ciancarini. Agent-oriented software engineering: The state of the art. In P. Ciancarini and M. Wooldridge, editors, AOSE, volume 1957 of LNCS, pages 1-28. Springer, 2000.
- F. Zambonelli, N. R. Jennings, and M. Wooldridge. Developing multiagent systems: The gaia methodology. ACM Transactions on Software Engineering and Methodology, 12(3):317-370, 2003.
Properties of an intelligent agent
An intelligent agent (IA or agent) can be considered as an autonomous decision making system situated within some environment and capable of sensing and acting within its environment . This environment may be populated with other agents, computational entities, or processes that interface with humans. Thus an agent is endowed with the properties of autonomy, reactivity, proactivity and social ability [3, 7].
Autonomy refers to an agent’s capacity to make decisions without direct intervention from humans or others. The environment within which an agent inhabits is repleted with stimuli, a subset of which the agent perceives and reacts to. The property of proactivity refers to an agent’s capacity for goal-directed behaviour, undertaken on its own initiative. An agent’s social ability is its communication with other agents and possibly humans via some protocol in order to engage in cooperative problem solving, negotiation or other social activities.
To conceptualize and reason about agents, we consider agents as intentional systems that have beliefs, desires, and intentions . The belief base of an agent can be specified in terms of some logic say a multi-modal, higher-order logic  that admits of rules for reasoning about the agent’s beliefs.
Agents with artificial intelligence
Artificial intelligence techniques can be used in designing and implementing agents . The level of intelligence that an agent requires depends on its degree of autonomy, mobility, longevity, and the level of uncertainty of its problem domain or within its environment. An agent that is required to deal with a wide range of situations needs to have a sufficiently broad knowledge base and a flexible inference engine. For mobile agents, it is advantageous to have small code size, which places restrictions upon the size of the knowledge base and the inference engine. Information security can be an issue irrespective of an agent’s mobility. The if-then rules of an inference engine can be reverse engineered by observing its input and output, a technique that is not readily applicable to a neural network due to its black box nature.
As regards longevity, an agent that exists for a considerable amount of time within an environment might require some learning mechanism to improve its performance over time. An agent that is short-lived might not require such a mechanism to achieve its goal. Where a problem domain or environment exhibits a degree of uncertainty, an agent needs to be sufficiently flexible to handle the uncertainty. This requirement could be achieved by using techniques such as Bayesian networks, if-then rules with certainty factors, or fuzzy logic .
Why intelligent agents?
A motivating factor for introducing intelligent agents is to help human users understand and manage complexities arising from information and communications technology (ICT) . As ICT systems grow in size and complexity, we require techniques for coping with this complexity. For example, problem solving can be delegated to an organization of agents, each of which is an autonomous computational entity that addresses an aspect of the problem under consideration. Such an organization of computational entities is composed of heterogeneous agents that communicate via a standard protocol such as the agent communication language (ACL) .
Applications of agents
Green et al.  survey a number of applications of intelligent agents: intelligent user interfaces, distributed agent problem solving, and mobile agents. An intelligent user interface is a user-centric system that adapts its behaviour in order to maximize the productivity of the current user’s interaction with the system. An agent comprising an intelligent user interface is thus expected to draw a substantial number of techniques from the discipline of artificial intelligence. In particular, such an agent is composed of a knowledge base, an inference engine, and a learning component.
In distributed agent problem solving, we implement a network of agents that solve a common problem and where communication within the network is accomplished via, say, ACL. Such a network of agents is called a multi-agent system (MAS). A MAS is thus a distributed problem solver in which agents communicate amongst themselves, coordinate their activities, and negotiate in the event of conflicts. A MAS can be organized in various manners; for example, the network of agents can be organized according to democratic principles, the organization can be hierarchical, or open ended like a bazaar.
In contrast to an agent that comprises a MAS, a mobile agent is endowed with the capacity to migrate among a heterogeneous network of computer systems. A mobile agent is essentially an intelligent agent inhabiting a mobile agent environment, and is comprised of the following models: agent model, life-cycle model, computational model, security model, communication model, and navigation model.
Not a silver bullet
In a sense, a software agent is a conceptual tool to assist us in managing the complexity of software engineering. Booch’s principles of abstraction, organization and modularity allow software engineers to conceptualize and decompose software systems in terms of manageable units. An agent embodies these three principles and others such as concurrency and social ability, but it is not a silver bullet to all software engineering problems.
Tveit  summarizes the potential pitfalls of agent-oriented software engineering under five categories: political, conceptual, analysis and design, agent-level, and society-level. The danger of political pitfalls arises when the concept of agents is oversold as the ultimate solution to the complexity of software engineering. Conceptual pitfalls arise when developers forget that agents are multithreaded software. Where developers ignore other related software engineering methodologies, this is referred to as the analysis and design pitfall. Agent-level pitfalls occur when developers endow agents with too much or too few artificial intelligence. Similarly, society-level pitfalls occur when developers make use of too many or too few agents in an agent oriented system.
- J. P. Bigus and J. Bigus. Constructing Intelligent Agents with Java: A Programmer’s Guide to Smarter Applications. John Wiley & Sons, New York, NY, USA, 1998.
- M. R. Genesereth and S. P. Ketchpel. Software agents. Communications of the ACM, 37(7), 1997.
- S. Green, L. Hurst, B. Nangle, P. Cunningham, F. Somers, and R. Evans. Software agents: A review. Technical Report TCS-CS-1997-06, Trinity College Dublin, May 1997.
- J. W. Lloyd and T. D. Sears. An architecture for rational agents. In M. Baldoni, U. Endriss, A. Omicini, and P. Torroni, editors, DALT, volume 3904 of Lecture Notes in Computer Science, pages 51-71. Springer, 2005.
- M. Negnevitsky. Artificial Intelligent: A Guide to Intelligent Systems. Pearson Education, Harlow, Essex, England, 2002.
- A. Tveit. A survey of agent-oriented software engineering. In First NTNU CSGSC, 2001.
- M. Wooldridge. Agent-based software engineering. IEEE Proceedings — Software, 144(1):26-37, 1997.
This post collects together a list of publications on agent-oriented software engineering. The list is not meant to be comprehensive, but is intended to serve as a starting point for further research in the area. For a brief introduction to agent-oriented programming, you might find the Wikipedia article “Agent Oriented Programming” useful. Another introductory material is this article, but it’s rather terse in its presentation.
- A. Amin. Agent-Oriented Programming in Linear Logic. Honours Thesis, Department of Computer Science, RMIT, November, 1999.
- J. Dietrich, Alexander Kozlenkov, Michael Schroeder and Gerd Wagner. “Rule-based Agents for the Semantic Web.” Electronic Commerce Research and Applications, vol.2, no.4, 2003, pp.323–338
- S. Green, L. Hurst, B. Nangle, P. Cunningham, F. Somers and R. Evans. Software Agents: A Review. Technical Report TCS-CS-1997-06, Trinity College Dublin, 1997.
- J. Lind. “Issues in Agent-Oriented Software Engineering.” AOSE 2000: Agent-Oriented Software Engineering. Springer, 2001, pp.45–58.
- D. Sharma, W. Ma, D. Tran and M. Anderson. “A Novel Approach to Programming: Agent Based Software Engineering.” Knowledge-Based Intelligent Information and Engineering Systems. Springer, 2006, pp.1184–1191.
- A. Tveit. A survey of Agent-Oriented Software Engineering. Report, Norwegian University of Science and Technology, May 2000.
- R. K. Uhnel. Agent Oriented Programming with Java. 1997.