Home Overview Introduction
Introduction to Agent.GUI Print option in slimbox / lytebox? (info) E-mail
Article Index
Introduction to Agent.GUI
Relation between IDE and end-user application
Application functionalities for Developer
Application functionalities for End user
All Pages

For those who want to understand our system in more detail we would like to introduce some basic concepts first. Naturally and hopefully this will result in the question, “Can we realize our ides with this system?” or “Is it possible to create a system, that … ?”. We would like to claim and simply say "Yes", which may, however, not always be true at this point in time, but it describes quite well our goal. It is also to understand as an invitation for you to join our group, with your experience or your requirements.

What is Agent.GUI good for?

It seems to be hard to understand what a “multi-agent system” is or can be, but it, actually, is not. Understanding this concept as an easy way for the division (decomposition) of a problem might help here as a first step. This division results to systems, which are consisting of independent units, which are embedded in an overall system, that we call “Environment”.

To be a little more exemplary: Assume an overall system, where 22 entities are trying to get a small thing called ball, then you can imagine the overall system (or “Environment”) as a football field. Here the single player is called “Agent”, which has naturally different qualities and skills - the teams (with all players) can be titled as “Multi-Agent System” (MAS).

This results in the fact, that we already have understood the basic concept of “Agents”, “MAS” and “Environment” now.

Looking out of our window, we have to realize that most of the real world out there is like this: complex, distributed and depending on the interaction of independent participants. Examples can be found everywhere like in logistics, traffic, crisis management, in the energy market and so on. If you would like to build a system or a simulation, which addresses such (complex) correlations, we think that you are at the right place here.

Because agent systems can be complex on their own, we don’t assume an expert from the logistics- or from the energy-domain will in-depth understand the underlying technology. Therefore Agent.GUI addresses especially the usage of distributed Multi-Agent Systems by using and extending the frameworks integrated graphical user interface.


Relation between IDE and end-user application

The image below shows in which context Agent.GUI can be used for your individual agent project.

Starting form the developer’s perspective (blue arrows), which means starting from a project in your IDE, you just have to bind the file AgentGui.jar to your project. Herewith all used resources of Agent.GUI will be also available in your own project, including JADE, Hyperic-SIGAR, JUNG, BATIC and so on. If necessary, you can add further jar-archives to your project as well and start with your developments. The final output of your project should be a jar-file, which can be added later on into Agent.GUI as an external resource.

The second important step for using your agent-project with Agent.GUI is to start the end-user application (by executing the AgentGui.jar) and create a new project (see menu: 'Projects' => 'New project'). Doing this, the project window with its four main tabs will appear which allows at first the general project configuration and later on the usage of your agent system by the end user. To not explain everything here, we would like to point to the tab "Configuration" => "Resources". Among other, external resources can be configured there.

Going back to the IDE and notwithstanding the drawing above, Agent.GUI allows not only the usage of external jar-files during its runtime. Furthermore it’s allows also the binding of a project bin-Folder of your IDE. The image on the left shows exemplary a folder structure of a JAVA project called “Game of Life”. If set (in Eclipse it is "Project" "Build Automatically"), all necessary .class-files, which has to be created from your source code, will be build and placed here.

Such a bin-folder can just be selected as “External jar resource” as well, which simplifies the switching between IDE and a running agent system for testing and debugging tasks. In order to do such testing by using Agent.GUI, you have to configure a new “Java Application” in the “Run Configurations” of your IDE and set  agentgui.core.application.Application as the Main class of your project. Additionally you can set "Program arguments" in the "Arguments"-tab. Here the setting "-project myproject" will directly open your project in the application window.

The development of an agent project ends up with the final export of your projects jar-archive and a final configuration of your agent project in the application window of Agent.GUI. This will be described in the next section.


Application functionalities for Developer

These kinds of functionalities are designed in order to pre-configure the visual application of Agent.GUI, so that developed Multi-Agent systems can be executed and used by end users. In detail, the following configurations can be defined in the main tab ‘Configuration’ of the projects front-end (see also the image gallery below):

  • Tab 'Resources' (top): One of the predefined environment types can be selected. At present a model for a continuous two-dimensional environments and a model for grid environments are available.
  • Tab 'Resources' (center): As described before Agent.GUI allows the usage of external libraries, which are available as a Java jar-archive. Such files can be selected from the local file system and will be dynamically added to the Classpath of the running JVM.
  • Tab 'Resources' (bottom): Plugin-classes can be selected and loaded out of the available classes of the running JVM. To write your own Agent.GUI-Plugin you can create a class, which extends the class agentgui.core.plugin.PlugIn.
  • Tab 'Ontologies': In order to later on configure start-arguments for agents, the ontologies that are used in the MAS can be selected and displayed here. The ontologies have to be created by using Protégé and the OntologyBeanGenerator (see Tools for the development of tailored Ontologies).
  • Tab 'Agents': This tab shows first of all the available agents of the current project. In order to define the Object-array, which will be transferred to an agent type during its initialization as start-argument, just select a class out of the ‘Project ontology’ (bottom right) and move it to the list ‘Start-up objects from project-ontology’ (top right). Such a configuration will be used later on in the ‘Simulation-Setup’ or in case that you press the OK button above the list of start-arguments.
  • Tab 'JADE': In this tab the main port of JADE and the services to use, like the NotificationService, can be configured. If you have built your own extended JADE-Service, it will be made selectable here as well. 
    As a supplement to JADE, Agent.GUI comes with four further services, which are providing for example synchronized time over distributed containers by using the SimulationService. Further examples are the DebugService (see selection in the gallery image below), which allows the redirection of remote console outputs to the main application window or the LoadService, which allows distributed load measurements.
  • Tab 'Distribution + Thresholds': Here the (static or dynamic) load balancing can be activated and the threshold levels for the load can be set. Furthermore you can select and apply your own load balancing approach.

01_resources02_ontologies03_agent_config04_jade_config05_distribution06_viewselection

Running through several cycles of testing, the above described functionalities will be - naturally - already used during the development phase of an agent project. If this testing and development is over, the agent project can be finalized and packed for end users, which can be done as follows

  1. Export your final jar-file out of your IDE to the intended project folder in Agent.GUI (e.g. ./AgentGUI/projects/myproject).
  2. Do your final configuration, especially in the project resources
  3. Set the view to your agent project to ‘End user view’ (see last image in the gallery above)

Your Multi-Agent system can now be used by end users.


Application functionalities for End user

For the end user, the project will appear now as shown in the next image gallery below (1st image). The ‘Configuration’ tab will be removed and only a 'Simulation-Setup' can be done.

01_simsetup02_agent_in_simsetup03_agent_configuration04_example_network05_example_2d_environment

As the image shows, Agent.GUI provides the possibility to define several setups based on one available MAS-project. That means that the user can setup a number of agents now, which have to do their tasks during one execution. For this purpose agents can be selected out of the list of available agents and be added to the 'Start list' on the left.

If the start arguments for an agent were configured before (see the description of the tab 'Agents' in the previous section and image no. 2 in the following image gallery), these start arguments can now be used within a simulation setup. With the selection of an agent, a form will be displayed that allows those configurations.
Important: Do not forget to press the Save-Button on the top right, if you want to use the current settings.

Depending on the selected environment model, the main tab 'Simulation-Setup' will appear with a further tab called 'Simulation-Environment', which enables the user to configure an environment for a simulation setup. The images 4 and 5 are showing, examples of the environments for 'Graph or Network' and the 'Continuous 2D environment model'. The usage of such environment models can be configured in the Resource tab of the Configuration.

 
Joomla templates by a4joomla