This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.
1.1 Background and Motivation
Agent Technology represents a new paradigm of software engineering (1). It provides a new means of analyzing, designing and building complex software systems (2). It finds uses in various application domains such as e-learning, e-business, grid computing and financial analysis. Most of the design tools catering to Agent technology are catered at users who are highly competent at programming and software design. Goal Net Designer is an automated goal oriented modeling and design tool catering to people who have little or no knowledge of agent development technology.
The goal net methodology covers the entire life cycle of agent system development (3).It has a practical implementation called the Multi- Agent Development Environment (MADE).However the current version of the designer requires the goal nets to be organized into a project based structure to facilitate the reuse of goal nets, deeper level of decomposition and the ability to create more complex agent mental state designs with interacting goal nets.
To organize the goal nets into a project based structure to facilitate the reuse of goal nets, deeper level of decomposition and more complex agent mental state designs with interacting goal nets.
- Change the current goal net database to make it project view compatible
- Come up with flow design for developing projects
- Implement the changes in the goal net designer
- Research on various ways goal nets within the project may interact, giving a few examples
The project view implementation should continue to be suitable for less technically inclined people and it follows the same structure found in many of the current generations of Integrated Development Environments (IDE) such as 'Visual Studio' by Microsoft.
Also the project also looks at various issues with the designer operating at a deeper level of decomposition.
1.3 Project Schedule
Figure 1.1 shows the project schedule. Start of the project essentially involved review of agent technology, goal net methodology and the underlying architecture. The basic understanding was followed by implementation on both the database and the goal net designer.
1.4 Report Organization
The report is divided into eight chapters.
- The first chapter is the introduction to the project, general background of the system, the main objectives and the project schedule.
- Chapter 2 deals with the theoretical background and research on the related work.
- Chapter 3 is concerned with the Agent System Architecture.
- Chapter 4 deals with Goal Net Designer
- Chapter 5 gives the implementation of the project view functionality in the system
- Chapter 6 deals with the database component of the system
- Chapter 7 gives the improved design experience with the project view implementation
- Chapter 8 gives the conclusion and is followed by references
1.5 Technologies and Tools Used
Project Component Technologies and Tools Used
This chapter gives the background to the theoretical research done by the author. The chapter contains existing work related to the goal net methodology
2.1 Agent and Multi Agents
The term 'Agent' is rather used in a vague way. Common attributes of agents include being reactive, autonomous, goal oriented, communicative, learning, mobile, and emotional and so on (4).
Jacques Ferber describes agents as (5)
- Which is capable of acting in an environment,
- Which can communicate directly with other agents,
- Which is driven by a set of tendencies (in the form of individual objectives or of a satisfaction/survival function which it tries to optimize),
- Which possesses resources of its own,
- Which is capable of perceiving its environment (but to a limited extent)
- Which has only a partial representation of this environment (and perhaps none at all),
- Which possesses skills and can offer services,
- Which may be able to reproduce itself,
- Whose behavior tends towards satisfying its objectives, taking account of the resources and skills available to it and depending on its perception, its representations and communications it receives.
Wooldridge and Jennings distinguished agents into a weak notion and a strong notion (1). The weak notion of agents is identified by four properties: autonomy, social ability, reactivity and pro-activeness.
An agent is capable of operating operate without direct interaction of humans and can control its actions and internal states
• Social Ability
An agent can interact with other agents through an agent communication language (6).
An agent can respond to the changes in the environment and react accordingly.
• Pro- Activeness
An agent can actively take initiative in displaying goal-oriented behaviors instead of just responding to the environment changes.
Autonomy is one of the important characteristics of an agent. Being autonomous makes it possible for an agent to dynamically select and carry out appropriate action while responding to the changes in its environment pursuing its goal.
2.2 Goal Oriented Agent
A goal oriented agent is a pro-active agent who does not simply act in response to the environment but is able to select and appropriate goal based on its environment and executes the actions required to achieve the goal (3).Table 2.1 lists the several attributes of a goal (9).
2.3 Goal Net Methodology
Goal net is a composite goal hierarchy which consists of states (goals) and transitions (10). A complete development cycle is covered by the goal net methodology.
- Initial Analysis Phase - primary goal net derived consists of
- Possible tasks for achieving the goals
- Environment affecting the goals
- Architectural design - which enables a multi system to be developed. Complex goals are decomposed to sub goals and sub- goals net, the system can be modeled and simplified. The communication protocols also defined in this state.
- Detailed Design - this is the third phase of agent development. In the detailed design stage more design details such as task details, goal properties, and agent communication protocols are added.
- System Implementation - this is the final stage in which all design and specification are mapped to the platform dependent concept. This includes task communication handling, development, and reaction development (11).
2.4 Goal Net Model and Structure
Goal Net is a tool proposed by Shen for goal oriented agent development from requirement analysis, design to implementation (3; 9).
Goal Net is a composite goal hierarchy which is consists of states (goals) and transitions. It is composed of a few entities; states, transition, arcs. A goal net example is shown in Figure 2.2
A state represents the goal (alternatively known as state) that an agent needs to go through in order to achieve its final goal. It is represented by a circle. The state may further be
a. Atomic state
Represents a single state that cannot be decomposed further
b. Composite state
Is a high level representation of a sub goal net.
A transition connects one state to another and represents the actions in order to progress in the goal net. Each transition is associated with a task list which contains possible tasks that the agent can perform. Each task can contain multiple functions for the agent to execute.
Hence, a goal net must complete a set of tasks to change states (goals). This may change the environment the goal net exists in.
Arcs connect the states and transitions. It is represented by an arrow line.
2.5 Agent Development Environment - Related work
An agent development environment provides a basic agent running environment, at the same time it saves the agent developers from developing agent from scratch. One of the most popular tools for intelligent agent development is the Java Agent Development Framework (JADE).JADE provides a graphical user interface for configuring the system running and controlling agent life cycle. The key and principle of JADE is the concept of container which is a runtime instance of a Java Virtual Machine (JVM). It allows several agents to concurrently run by providing a multi-threaded execution environment composed of a single thread per agent (12). Hence, the JADE agent platform makes it possible for agents to run on multiple machines across a computer network. This is more of an Application Programming Interface (API) (13) then a tool for conceptual design.
In order to create an agent in JADE, one has to be familiar with both the Java programming language as well as the agent oriented programming paradigm. This is something which goal net aims to change.
In this chapter, we looked at the various aspects of goal oriented agents and its development environment. Although the field has exciting opportunities for people in various fields, there seems to be a gap between the development methodology of agents and the current platform for developing agent systems. The development systems are tiring even for those people who are good in programming. Hence, there stems a need for a development environment that can bridge this gap and assist developers in creating goal oriented agents. There is also a need for a system that can reuse existing designs so as to simplify complex projects to manageable ones.
Multi-Agent Development Environment, MADE, is intended to be an all-inclusive environment for agent development. The MADE environment helps developers in creating agent mental state design making use of an agent development model and at the same time automatically translating this design into useful agent implementation.
3.1 System Architecture overview
MADE is the complimentary toolkit for Goal Net development methodology (11). Underlying technology for MADE is C++ and encapsulated in DLL files.
MADE architecture is based on distributed model. Once an agent is created, it is allocated a goal net to process.
The three main modules in the architecture are:
- Goal Net Designer
- Goal Net Storage
- Agent Framework
The Goal Net Designer is a tool that allows the developers to design and validate a goal net. It is the GUI the developer will see and interact with. The Goal Net Storage is used to store the designed goal net. Each of the agents chases one or the more sub- goals; once the goal net has been loaded in them from the goal net storage they will start to run.
3.2 Goal Net Management and Storage
To describe a goal net numerous C++ classes are used. A number of properties like name, ID, starting and end state, root state and so on are encapsulated in the class for goal net.
State class maintains attributes like ID, name, parent ID input and output transition etc.
The information about each transition and state is supplied by the transition class.
The goal net is wholly described by TaskList and Task. Each transition is associated with a task list and each task list has a list of tasks. These tasks have to be completed by the agent in order for the transition to be completed.
3.3 Overall Architecture
The following units are present in the design of MADE and Figure 3.2 (11) shows the overall design of the agent architecture:
§ Control Unit
Processes the goal net, coordinates with other units and manages overall work for the agent
§ Process Unit
Processes the loosely coupled goal net data to restore the goal net, also works as the goal net storage when the agent is working
§ Knowledge Unit
Currently not implemented in the MADE , but the unit is there to interact with knowledge base and process the knowledge level information such as agent's learning.
§ Data Unit
This is the physical connection between the data and the database, the connection allows for goal net data and other essential information to be loaded into the agent.
§ Compute Unit
In the current design used for task selection and goal selection
§ Communication Unit
Handles the interaction between agent and other agents, it also controls the message sending, receiving and handling
§ Perception Unit
Monitors the variations in the agents' environment
§ Action Unit
Has two roles, firstly used for tasks execution and secondly to react to the changes in the environment
There are 5 threads running simultaneously
- First is taken by the perception unit
- Second by the communication unit
- Third is used by the control unit - protects the agent from no response situation
- Process and Data unit are the passive units only evoked at the control unit's request.
3.4 MADE Work Flow
Currently the two modules interacting with the agent developers are
1. Goal Net designer
Arranges for with the graphical interface to help withthe Goal Net design
2. Agent Creator
Interprets the design into operation by creating agents and loading the goal net into these agents
3.4.1 Goal Net Designer
The Goal Net Designer is the GUI that is presented to the end users simplifying the process of goal creation.
3.4.2 Agent Creator
The process steps are summarized in in the figure above (11).
- The data unit requests the database as the agent starts running to load its goal net and the process unit reforms the goal net.
- The process unit is then prompted by the control unit for the next goal/goals.
- The control then sends these goals sent to it by the process unit to compute unit which does the calculation agreeing to the goal selection algorithms.
- The control unit acquires information about the transition that can reach the selection goal from the process unit.
- The above information is sent to the compute unit for action selection
- The compute unit then calculates the best action to execute and sends that information to the control unit.
- The task is carefully chosen and guided to the action unit for implementation which in turn notifies the control unit once the task is accomplished
- The process is then again continued when the control unit enquires the next task from the process unit.
All agents share a common communication system. An agent can network with another agent by stationing a message into the system. The agents check the communication frequently to collect the message and then delete the same from the message board. The communication model of the agent framework is implemented using windows socket and the messages are represented in XML format.
MADE simplifies the agent development process. The main modules at work are the goal net designer which is a GUI tool and simplifies the designing process and agent creator which simplifies the implementation of goal oriented agents.
As discussed before one of the major components of MADE is the Goal Net Designer. It works as an Integrated Development Environment for developers to model goal based agents based on the Goal Net Methodology. As an IDE it streamlines the design process and produces design data automatically. This data is then used by MADE to create intelligent agents (14).
4.1 Architectural Design Pattern
4.1.1 Model - View Controller
Using a Model-View-Controller design pattern allows for a greater reusability of business logic and helps to decouple it from the user interface as well as data access parts.
The classes necessary to efficiently describe a goal net which enables them to be graphically rendered are contained in the Model Layer. The View Layer i.e. the Graphical User Interface is required to track and monitor the status of the goal and respond accordingly. This GUI is transparent to the Model layer. A delegation pattern is used to create an event for each status variable in The Model Layer and it is triggered upon the update of the variable (15). Events are raised when the value of the variable changes, hence polling s prevented. Implementation of the responses by the view Layer makes it possible to use different technology by the View Layer.
The interface of Goal Net Designer is centered on Windows Forms; hence the View and Controller are closely related to each other. The designed goal net is displayed by the View Layer, which also generates the events in response to the developer's actions which are processed by the Controller layer by allotting them to the Model Layer.
To make provision for distributed deployment of the goal net designer, the Client Server Architecture is selected. This helps the developers to work in collaboration. The client has the graphical representation of the goal net while the central data storage required for shared development as entities like functions and web services are accomplished at the server. The relevant data structures as well as the business logic is contained in the custom created GoalNet class which is sent to the client by the server, hence allowing the processing to be done locally.
Upon user request, the design is encapsulated into the GoalNet object and sent to the server for storage into the database. By creating a Remote Proxy for the Data Access layer, The Data Access Layer publishes a list of functions for remote access from the clients and itself is marshaled to each client as a reference (16).
4.2 System Components
The Goal Net Designer has three constituents:
This is a client-side application which permits users to design goal nets at their end
This is the server-side application, manages the clients and it encompasses the data access layer
This is a dynamic link library which provides functionalities like drawing, remoting to the server and the client
We will now discuss these components in a greater detail
This is the client application for Goal Net Designer developed on Microsoft .NET framework.
Since GNetClient is designed on Windows Forms, the main form acts as a container for all other forms. It also manages the message passing between sub- forms, while maintaining the interaction with the server. The main form also replies to the messages from the server by parsing and interpreting them. The Goal Nets are drawn on a canvas. Multiple Goal Nets can be opened at the same time. By means of mouse events the drawing operations are recorded and inferred.
The GNetClient takes a lot of inspiration from current generation of IDE's in terms of looks and feel. This makes it easier for the developer to get used to it. To further aid the user for drawing in the canvas, toolbar functionality is provided. The toolbar contains buttons which when pressed will allow users to place entities like state, transactions and arcs anywhere on the canvas. The buttons to edit and delete allow the designer to easily create and edit the goal net design layout using a mouse.
The property grid provides a highly structured view of the properties of the object selected by the user on the canvas when she/he right clicks on it. These properties such as name, description etc. can be changed in the property grid. Few read only properties are like ID, parent ID etc.
For each transition it is mandatory to have one function associated to it. On reaching the transition the function is executed. The functions are organized as a DLL written in C++.This DLL is submitted to the server administrator, included along with the function is a short description about what the function does. The administrator then uses a server function to update the database with all the new available functions. Hence the new functions are then available to everybody using the Client. The users are then able to associate the function with goals and transitions in the goal net designs by dragging on the function names and dropping them on the desired target (14). The transitions themselves have a default task list to which the user created functions can be added.
The client also has a log from which the developer can see the communications taking place amid the client and the server. The user can clear or save this log
For designing the multi agent system, when a group of designers each working on sub set of agents. It is very much possible that they may be located at different physical location, for this purpose a messaging tool to communicate is developed inside the system.
HTTP is used for remoting the connection between client and server. The messages amongst clients are sent via server. When a prevailing goal net design is requested by a client, the essential data is pulled from the server and briefly stored in client's local memory. The user actually modifies only their local copy of data and when the design is complete, the local copy is pushed back to the server. An exclusive locking technique is used to allow only one user to edit a goal net at one point of time for mutual exclusion (4).
Figure 4.2.3 shows the Goal Net Server. Like the Goal Net Designer, the Goal Net Server is also developed on the Microsoft .Net framework.
The server has similar Graphical User Interface as the client, which makes it easier for the user to operate the system. The interface has a very flexible layout and based on the windows form ServerMain is the entry class which contains all other sub forms and passes messages among clients.
When a new client is added, it registers itself with the server. The server log is updated. Connected clients are informed to reload the list of active clients. This new client is also added to the lifetime monitoring list to detect if the client has been abnormally shut down and respond to changes in case an event does happen (4). The GUI is also updated when the new client connects to the server. When a client de- registers from the server it can be considered as an inverse process to the registration of the client, the updating in this case is also done in the same order.
The client manager form (Figure 4.2.4) provides the user interface to cope with all aspects of the client interactions. A terminate message is sent by the stop client button which forces the client to terminate.
The client is informed that it's about to shut down via a pop up message and thus saves all the data to the server and closes in a controlled manner.
Message passing - the message passing is handled by the server. On receiving a message the server looks at the header of the message to find the sender and the recipient. The message is then relayed to the intended recipient or the server responds back.
Transitions contain tasks which contain the functions to be run. These are defined by users and server administrators as C++ functions in dynamic linked libraries (DLL). The DLL files are passed to the server for storage. For loading the function the server administrator needs to press the Update Function button, this also allows the server administrator to browse to the target DLL files.
The Multi- Agent Development Environment (MADE) later executes the functions that were added to the transitions, when the agents based on the goal net design are created. The database stores the functions extracted from the DLL files with ID's, default alias and default description assigned. When these new functions are added, the clients are informed to reload the list of functions.
The functions to be called in the states and transitions can be defined via web services too. The details of the same can be entered by the users using the online developmental portal. Universal Description Discovery and Integration (UDDI) server allows implementation of web service support as well as to work out a process for the users of the Goal Net Designer to supply their own web services which can be incorporated into functions to be used in the final multi-agent systems they build (15). The information from the web service is saved in the database in the same table as other functions.
The program logic is decoupled from the user interface in Goal Net Designer. This has an added advantage; future work on the GUI can be done without making any changes to the program logic. The program or the business logic is compiled into a dynamic link library file.
The drawing operation of the Goal Net Designer is handled by this component. It makes it possible to draw on the canvas as well as makes the drawings of Goal Net printable.
Hash tables are used to store all arcs, states and transitions with their respective IDs which are auto-numbers generated from the database as indices. Hence they can be accessed both sequentially and dynamically in an efficient manner (15). The database system used is MySQL and the entire goal net is loaded into memory each time a goal net is to be edited. Open Database Connectivity (ODBC) is used for data access from MySQL. ODBC allows accessing data in a heterogeneous environment of database management systems (17).
Through its OdbcDB class, GNetRemotingDll provides data access interface to the client and the server. It also passes the data acquired over the network to remote clients.
The Goal Net Designer provides a well automated user interface for both the end user using the client and the server administrators. This helps in simplifying the process of agent development. The decoupling of the business logic helps in making changes to the GUI as and when required. Hence the system can be built upon. With the help of MADE and the Goal Net Designer the users need not have a very in depth knowledge about of intelligent system design. They need not be proficient in programming as such; hence it fulfills its basic requirements and reduces the time and cost of developing agent oriented system.
The current Goal Net Designer lacks the functionality of creating projects. This makes it very troublesome for the user to create complex goal nets and the user is not able to reuse the existing goal net.
Hence the Project View functionality will help to organize the goal nets into a project based structure to facilitate the reuse of goal nets, deeper level of decomposition and more complex agent mental state designs with interacting goal nets.
The current structure of having a single goal net as the basic structure will have to be changed in order to add the project view into the system. After the project feature is added to the current design a user will be able to create projects with multiple goal nets.
Goal Net Designer is specially designed for users with little or no familiarity about intelligent software agents or multi agent systems. The aim is to give them easy to use tools to design goal oriented agents.
In this view the project view structure has to be intuitive and should make the designers' goal of creating multiple agents easier. Hence, an automated solution for creating projects of Goal Nets and a way to save the same in the database need to be found.
From the above requirements, a detailed analysis to address the primary purposes of these requirements is given below.
New tools will be required for the user to make the projects without changing a lot in the Designer Client.
The project will consists of the following entities
- Goal Nets
To keep the association simple we start with Goal Nets only. Each Goal Net has its properties such as tasks, ID's etc. which are associated with it. There should be sufficient tractability for the user to keep this the same as the current version.
The Project View form should be able to showcase the individual goal nets in the same. Hence the important use cases for the Project View Functionality will be.
The Project View part of Goal Net Designer is developed using the Microsoft .Net Framework.
The implementation based on the study of the above requirements of the features of Project View in the Goal Net designer is discussed in the following sections.
5.5.1 Creating a project
The primary task of creating a Project View is to create a new project with multiple goal oriented agent goal nets. To create a project, the user opens the goal net designer and opens the drop down file menu as shone in Figure 5.5.1 .
5.5.2 Drawing a Goal Net
The drawing of a Goal Net remains a drag drop feature in the Goal Net Designer. The designer can use the menu strip Figure 5.5.5, to add various states and transitions in the goal net.
5.5.3 Project View
The Goal Net Designer allows for the designer different views regarding the goal net. These being as shown in the figure the
- Arc Tree
- Function tree
- State Tree
- Transition Tree
- Task Tress
5.5.4 Saving the project
The Goal Net designer allows you to save a project, the same way as individual goal nets. The developer can save a design on his local system as an image file.
The Goal Net designer simplifies the process of creating agents. It makes the process of designing intelligent agents less tedious and possible for people with little or no background in programming. The project view features help the designer to reuse the goal nets in such a way that helps designing more complex agents, which breaking down the original complex design in manageable parts.
As discussed in the previous chapters, the Goal Net is based on model - view - controller architecture; hence the business logic and the data are decoupled from the user interface and the GUI. Hence in order to implement the project view structure changes are required in the database as well is the GNetRemotingDll functions.
All the classes required for querying and accessing the database are contained in the GNETRemotingDll C#.Net assembly.
While designing of the project view structure it is important that we are able to create a deeper level of organization while maintaining the existing structure of the relationships of goal nets.
ID and GoalList are the attributes of the Project class. It contains the list of Goal Nets with a said ID. GoalList is the list of goal net ID's
We will also have to modify the OdbcDB class; this is done to handle queries related to Projects and corresponding Goal Nets.
Project class is a simple class with attributes - ID and GoalList (a linked list of goals) and get and set methods associated with the attributes
6.3.1 Data Access
MySQL is the database system for the project.
The figure above shows the relationship diagram of the tables in the database. The Project table has two attributes ID and GoalList. ProjectID is the additional field added to the GNet. Hence to query a particular GoalList related to a particular project we just need to us the following SQL
Where GNet.ProjectID = Project.ID"
Hence Goallist can be found and saved accordingly. On saving a project the ProjectID of the GNet is saved as the ProjectID. This can be a number or a text in the database. Hence we have a 1- many relationship regarding projects and goal nets.
Similarly to get a tree view of the Project we just need to query for the the GoalList.
In this chapter we discussed the background changes to the OdbcDB class in the GNetRemotingDll. The database allows us to form the structure for the projects and retrieve data correspondingly. This is an important part and the backbone of the project.
It is important to see how the project view helps the designing process taking a design problem in consideration.
The problem - imagine an agent that need to go from place and take a taxi. The taxi has a punctured tire and need a repairman for fixing and a repairman fixes the tire. We will now dram the agents very intuitively showing states only. Since transitions and tasks will be the same in both cases whether we design a composite state or make a project.
7.2 Current Development
The figure 7.2.1 shows the current development process in a very crude state. The designer need to think of the complete design and is unable to break the problem into parts. This is a simple problem but when we are dealing with scale, there is little reusability here.
Say the states where we used the taxi where 276, 277 and 278. Now in the best possible case we would like to reuse the taxi for say another problem but we cannot. Hence the designer has a constraint here. Reusability and a deeper level of decomposition is required to help the designer over this constraint.
7.3 Improved Process
Designing the same problem as a project is sort of an object oriented way to design an agent. We can say divide the problem into three parts, designing from bottom up.
- The Helper
- The taxi
- The person
The helper will be drawn as a separate goal net hence it can be shown as that in figure 7.3.1. Note that helper, taxi and person are used to get a better mental picture about the states.
We saw how implementing the project view makes it easier for the designer to model agents. The new model improves reusability and makes designing bigger agents possible.
Agent Creator .Net helps in creating goal oriented agents in a very intuitive and simple manner. The goal net designer allows designers to design goal oriented agents with little or no programming knowledge. This report presents the implementation of Project View in the Goal Net Designer.
Adding the project view component makes it easier for the designer to draw more complex agents while adding to better organization of goal nets. Organizing the goal nets into a project based structure facilitates the reuse of goal nets, deepens the level of decomposition and makes more complex agent mental state designs with interacting goal nets possible.
The results of such a system are clearer with the examples shown the report. The designers don't need an in depth knowledge of agent systems to implement the system and the project view component furthers this. The implementation requires changes to be made in the GUI and the database.
The project view implementation makes it easier for the designer to reuse the goal nets and scale them better but their there is still much that cab be implemented.
§ Adding the dock for projects in the Goal net Designer is one good idea. This will make the addition part of the original system and give the viewer a better view of the designed goals
- Adding drag and drop functionalities for projects is another function that can be implemented over the current functionality
- Creating a properties dock for the projects is also a good idea. Having the properties listed makes it easier to work for the designer.
- Finding a way to draw the whole structure of goal net rather than just have a project symbol on the designer, hence improving the canvas is another suggestion
- R.Jennings, N., and Wooldridge, M. Agent Technology: Foundations, Applications, and Markets. s.l.: Springer, 1997.
- S.Nwana, H., and T.Ndumu, D. A perspective on software agent research. Knowledge Engieering Review. 1999, 14.
- Shen, Z., Miao, C., Tao, X., and Gay, R. Goal oriented modeling for intelligent software agents. In International Conference on Intelligent Agent Technology. 2004, pp. 540-543.
- Soni, Sneha. Final Year Project Report, FCG Maps. s.l.: Nanyang Technological University, 2009.
- Ferber, Jacques. Multi- Agents Systems An Introduction to Distributed Artificial Intelligence. s.l.: Addisen - Wesley, 1999. pp. 9-15. 0-201-36048-9.
- Genesereth, M. R., and Ketchpel, S. P. Software agents. . s.l.: Association for Computing Machinery, 1994. pp. 48-53.
- Bdi agents: From theory to practice. Rao, A. S., and Georgeff, M. P. 1995. International Conference on Multiagent Systems.
- "Multi-Agent Systems". Sycara, K. P. s.l.: AI Magazine, 1998, Vol. 19, pp. 79-92.
- Shen, Z. Goal-Oriented Modeling for Intelligent Agents and Their Applications,PhD Thesis. Singapore: School of Electrical and Electronic Engineering, Nanyang Technological University, 2005.
- Goal-oriented Methodology for Agent. Shen, Z., et al., et al. s.l.: IEEE/WIC/ACM, 2005. International Conference on Intelligent Agent Technology.
- Dongtao, Li. Goal Oriented Software Agent Development.A First Year Report. Singapore: School of Computer Engineering, Nanyang Technological University, 2005.
- Measurement Study of the Mobile Agent JADE Platform. Lo Piccolo, F., Bianchi, G., and Salsano, S. 2006. international Symposium on World of Wireless, Mobile and Multimedia Networks.
- F. Bellifemine, G. Caire, T. Trucco, (TILAB) G. Rimassa (University of Parma),. JADE Programmer's Guide.
- Intelligent Software Agent Design Tool Using Goal Net Methodology. Yu, H., Shen, Z., and Miao, C. s.l.: IAT, 2007. In international Conference on intelligent Agent Technology.
- A Goal Oriented Intelligent Agent Modeling and Design Tool,A Final Year Project Report. Yu, H. Singapore: School of Computer Engineering, Nanyang Technological University, 2005.
- Yu, H., Shen, Z., and Miao, C. A goal-oriented development tool to automate the incorporation of intelligent agents into interactive digital media applications. s.l.: Comput. Entertain, 2008. Vol. 6.
- ODBC, Microsoft. "Open Database Connectivity Overview".[Online],. s.l.: http://support.microsoft.com/kb/110093.
- DLL, Wikipedia Article on. http://en.wikipedia.org/wiki/Dynamic-link_library.
- Wikipedia Artile on the Asian Crisis. http://en.wikipedia.org/wiki/1997_Asian_Financial_Crisis.