Lawrence Cabac

Formal semantics for AUML agent interaction protocol diagrams

In this paper we introduce an approach for defining semantics for AUML agent interaction protocol diagrams using Petri net code structures. This approach is based on the usage of net components which provide basic tasks and the structure for Petri nets. Agent interaction protocol diagrams are used to model agent conversations on an abstract level. By mapping elements of the diagrams to net components we are able to translate the diagrams into Petri nets, i.e to generate code structures from the drawings. We provide tool support for this approach by combining a tool for net components with a tool for drawing agent interaction protocol diagrams. This combined tool is available as a plug-in for Renew (Reference Net Workshop).

A proposal for structuring Petri net-based agent interaction protocols

In this paper we introduce net components as means for structuring Petri net-based agent interaction protocols. We provide a tool for effortless application of net components to nets. Thus we facilitate the construction of nets and unify their appearance. Net components can be used to derive code for interaction protocols from a subset of extended AUML (Agent Unified Modeling Language) interaction protocol diagrams. This allows for a smooth integration of some traditional software development specification approaches with high-level Petri nets. By using net components we do not only unify the structure of Mulan agent protocols but also succeed to build a common language within a community of developers who share the net components.

Multi-Agent System: A Guiding Metaphor for the Organization of Software Development Projects

In this work we propose the introduction of multi-agent concepts for the organization of software development projects of (especially multi-agent) application design and implementation. This is expressed by the guiding metaphor (German: Leitbild) of a multi-agent system of developers. Team orientation and concurrent development are two aspects that are crucial in every large development project. Consequently, the organizational structure of the programming team has to take account for both. If the developed application is distributed, concurrent and team-oriented --- e.g. a multi-agent application --- one approach is to aim for a comparable (homomorphic) structure of a developed system and development team. We achieve this by reintroducing the multi-agent system: metaphor into the organizational structure of the development team. Agent attributes such as autonomy, communication, cooperation, self-organization and the capacity for teamwork are transferred by the guiding metaphor back to team members. Concurrency and distribution of resources and processes is naturally supported by the guiding metaphor. This guiding metaphor can be applied to any project organization. However, it is best suited for the organization of multi-agent application development, due to the similarity in structure.

Renew 2.5 – Towards a Comprehensive Integrated Development Environment for Petri Net-Based Applications

Renew (The Reference Net Workshop) is an extensible Petri net IDE that supports the development and execution of high-level Petri nets and other modeling techniques. The Reference net formalism – the major formalism for Renew – includes concepts such as net instances, synchronous channels and seamless Java integration. It combines the advantages of Petri nets and object-oriented programming for the development of concurrent and distributed software systems. Modeling support of Renew focuses on convenience and ease for Petri net development. An outstanding feature is the support for multi-formalism simulation. The plugin architecture of Renew enables the developers to extend the IDE for instance with additional formalisms. Alternatively to the inline mode – within the graphical user interface – the Simulator can also be run in a headless server fashion. Several configurations of Renew are available, which are constituted through selections of plugins providing specialized functionality for multiple platforms. In this manner the Renew family constitutes a product line architecture. Renew is available free of charge including the Java source code. In this contribution we provide information about Renew’s functionality and architecture as well as the development of the tool set over the last decade.

Gateway architecture for web-based agent services

Many publications in the last years point out the benefit of combining software agents and Web services. These approaches are mainly based on W3C compliant Web services and try to integrate them into FIPA compliant agent systems. The major obstacles are mismatches in service description and communication. This paper presents a Gateway architecture for connecting software agents and RESTful Web services based on JSON communication. To keep the communication transparent the Gateway translates the message encodings in both ways without any restrictions for the participating platforms. Instead of translating and offering machine-readable service descriptions, this approach puts the focus on human-machine interactions with software agent services. For this purpose we provide a Javascript framework to support the developer to create dynamicWeb pages that act as human-readable service descriptions and also as service invocation application. Moreover, with the help of this approach it is possible to create a Web-based and agent-oriented graphical user interface.

Agent Models for Concurrent Software Systems

In this work we present modeling techniques for the development of multi-agent applications within the reference architecture for multi-agent system Mulan . Our approach can be characterized as model driven development by using models in all stages and levels of abstraction regarding design, implementation and documentation. Both, standard techniques from software development as well as customized ones are used to satisfy the needs of multi-agent system development. To illustrate the techniques and models within this paper we use diagrams created during the development of an agent-based distributed Workflow Management System (WFMS).

Software Engineering with Petri Nets: A Web Service and Agent Perspective

The context of this paper is given through a software engineering approach that uses Petri nets as executable code. We apply the particular understanding that Petri nets are not only used to model systems for design purposes but also to implement system components. Following this approach, we develop complex Petri net-based software applications according to the multi-agent paradigm. Agent-internal as well as agent-spanning processes are implemented directly as (high-level) Petri nets. These nets are essential parts of the resulting software application – alongside other parts (operational and declarative ones), which are implemented using traditional ways of programming.

A Monitoring Toolset for Paose

Paose (Petri net-based Agent-Oriented Software Engineering) combines the paradigm of AOSE (Agent-Oriented Software Engineering, see [10]) with the expressive power of Petri nets - reference nets [12] to be more precise. While AOSE is a powerful approach when it comes to designing and developing distributed (agent) applications, it does not address the problems specific to debugging, monitoring, and testing of these applications, i.e. no global state of the system and very dynamic operating conditions. To tackle these problems, two tools have been developed in the context of Paose , which are presented in this work. Firstly, this paper will give a short overview over the interrelated set of tools, which exists already and supports Petri net-based AOSE. The tools are centered around the Petri net-based multi-agent system development and runtime environment Renew / Mulan / Capa . Secondly, Mulan -Viewer and Mulan -Sniffer will be presented in more detail --- two tools to address the issues encountered during debugging, monitoring, and testing agent applications. Both tools are first class members of the aforementioned family. The first tool, Mulan -Viewer, deals with the introspection of agents and agent behaviors, while it also offers rudimentary features for controlling the agent-system. The Mulan -Sniffer as the second tool places emphasis on tracing, visualizing, and analyzing communication between all parts of the multi-agent application and offers interfaces for more advanced methods of analysis, such as process mining. Both Mulan -Viewer and Mulan -Sniffer are realized as Renew plugins that can also be extended by other plugins.

Net Components for the Integration of Process Mining into Agent-Oriented Software Engineering

Process mining is increasingly used as an analysis technique to support the understanding of processes in software engineering. Due to the close relation to Petri nets as an underlying theory and representation technique, it can especially add to Petri net-based approaches. However, the complex analysis techniques are not straightforward to understand and handle for software developers with little data mining background. In this paper, we first discuss possibilities to integrate process mining into our Petri net-based agent-oriented software engineering approach. As the main contribution, we focus on enhancing its usability and introduce a technique and tool for visually modeling process mining algorithms with net components. These can be used to build new complex algorithms as a patch-work of existing procedures and new compositions. Furthermore, they allow for an easy integration with standard tools such as ProM.

Analysis of multi-agent interactions with process mining techniques

Process mining and multi-agent models are powerful techniques for the analysis of processes and organizations. However, the integration of both fields has seldom been considered due to the lack of common conceptual background. We propose to close this gap by using Petri nets as an operational semantics and consider process mining a useful addition to monitor and debug multi-agent systems in the development phase. Mining results can be represented in the formalized form of Petri nets that allows to validate or verify the actual behavior. On our way to mining complex interactions within (simulated) organizations, we present a plug-in extension of our Petri nets-based agent platform Mulan/Capa for recording interaction logs. Using process mining, the logs can be mapped by some intermediate steps to agent protocols e.g. represented as AgentUML interaction protocol diagrams. These diagrams are a descriptive representation form that combines organizational and control flow information. Furthermore, they can be mapped to executable Petri nets, thus allowing to feed mining results back into the design phase.