Home > artificial intelligence, software engineering > Agent oriented software engineering

Agent oriented software engineering

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 [14]. 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.

The waterfall model of classical software engineering.

The waterfall model of classical software engineering.

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 [12]. 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) [2]. 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 [9]. 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 [12] for object oriented analysis and design.

Techniques for AOSE

Burmeister [4] 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 [4] 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 [15]. Using the belief-desire-intention model of an agent [13], 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 [16]. That paper reviews the AAII methodology [8], the Gaia methodology [17], an extension of the Unified Modelling Language (UML) for modelling agent based systems [11], the DESIRE framework [3, 6], the Cassiopeia method [5], and an agent specification framework in the Z language [10].

Modelling agents with UML

In [1], 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 [7], offers a promising means of securing agents at the design level.


  1. 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.
  2. G. Booch. Object-Oriented Analysis and Design with Applications. Addison-Wesley, Reading, MA, USA, 1994.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. J. Jurjens. Secure Systems Development with UML. Springer, 2004.
  8. 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.
  9. 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.
  10. 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.
  11. 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.
  12. M. Priestley. Practical Object-Oriented Design with UML. McGraw-Hill Education, Berkshire, UK, 2nd edition, 2003.
  13. 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.
  14. S. R. Schach. Object-Oriented and Classical Software Engineering. McGraw-Hill, New York, NY, USA, 6th edition, 2005.
  15. 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.
  16. 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.
  17. 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.
  1. Farheen
    31 May 2009 at 4:39 pm

    I am student of MS(CS)and i am working on the following topic:
    “Towards the Implication of Agent Oriented approach to Software Engineering on specific design methodologies in Software Industry of Pakistan”
    Can you please guide me in this research as i have no research exposure.

  2. 31 May 2009 at 11:16 pm

    To get research experience, you need to start doing research. Well, you have to start somewhere, right? By the title “MS(CS)”, I assume you mean Masters of Science in Computer Science (if I’m wrong, then you need to explain to me what that acronym means). Your thesis adviser should be your first point of contact about research questions.

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: