Matthias Wester-Ebbinghaus

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).

From Multi-Agent to Multi-Organization Systems: Utilizing Middleware Approaches

Modern software systems share with social organizations the attributes of being large-scale, distributed and heterogeneous systems of systems. The organizational metaphor for software engineering has particularly been adopted in the field of multi-agent systems but not entirely exploited due to an inherent lack of collective levels of action. We propagate a shift from multi-agent to multi-organization systems that we rest upon an organization theoretically inspired reference architecture. We further suggest to utilize agent-oriented technology as a means for realization. We draw upon the wide variety of organizational modelling and middleware approaches and establish a best fit between different approaches and requirements for different architectural levels.

Closing the Gap Between Organizational Models and Multi-Agent System Deployment

Multi-agent system research deals with organization theoretical concepts in order to analyse and control supra-individual phenomena. However, there exists a conceptual gap between organizational specifications and their multi-agent implementation. We address this problem by presenting an integrated approach for the specification and deployment of organizational models based on Petri nets.

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.

Generating executable multi-agent system prototypes from SONAR specifications

This contribution presents the Mulan4Sonar middleware and its prototypical implementation for a comprehensive support of organisational teamwork, including aspects like team formation, negotiation, team planning, coordination, and transformation. Organisations are modelled in Sonar, a Petri net-based specification formalism for multiagent organisations. Sonar models are rich and elaborated enough to automatically generate all necessary configuration information for the Mulan4Sonar middleware.

Modeling Organizational Structures and Agent Knowledge for Mulan Applications

In software engineering the initial setup of a system, as well as the self-adaptation processes within a system are challenging tasks. We address these challenges by providing explications of organizational structures through modeling. In this paper we present a service-oriented perspective on the organizational structure of MAS and we present modeling techniques and tools for supporting this perspective. We pursue a model-driven approach and a tight integration between various models on the one hand and between the models and the generated code on the other hand. In particular, we use ontologies to define a meta-model for organizational structures in a way that we can easily generate the initial content of agent knowledge bases in the form of FIPA semantic language (SL) fragments, depending on the positions the agents occupy in the context of the organizational structure. This allows the agents to reason and to communicate about their organizational embedding, which is a prerequisite for self-adaptation in multi-agent systems.

SONAR: a multi-agent infrastructure for active application architectures and inter-organisational information systems

Whenever the IT infrastructure is managed by different organisational units the software architecture has to balance the conflicting aims of local autonomy and global coherence. Self aware organisational models help to achieve this goal. In this paper we describe the architecture of a generic organisational agent, called GOPA. This agent is used as the target platform for Sonarmodels. Sonar is a formal framework for the specification of multi-agent organisations. Sonar-models are semantically rich enough to compile a GOPA network from the model in an automatic way.

Introducing a Process Infrastructure for Agent Systems

Within open distributed systems the realization of a spanning application is an open problem. While the local functionality can be implemented based on established approaches, the overall control of the processes to form a consistent and correct application remains difficult. Workflow management systems (WFMS) are one solution for process control. In combination with distributed systems further issues have to be solved and are investigated here under different perspectives like Petri nets (to provide a true concurrency semantics of the concepts) and agents (to provide a powerful middleware and a more abstract modeling paradigm than objects or components). In this paper we coin the phrase process infrastructure. The idea is to provide all means to model, build, control and maintain the processes within open agent networks as special distributed systems by combining the above mentioned concepts and techniques. To gain such a powerful process infrastructure, we started to build prototypes, which stepwise introduce some implementations of the advanced concepts. The potential of our proposed solution lies in its flexibility and rigorous formal precision. Thanks to the latter the models are directly executable. The approach introduces autonomous and adaptive handling of processes in specific units (agents), which use and produce the necessary infrastructure to handle processes in different contexts on all levels.

Modeling organizational units as modular components of systems of systems

Modern software systems are frequently characterized as systems of systems. Agent-orientation as a software engineering paradigm exhibits a high degree of qualification for addressing many of the accompanying challenges. However, when it comes to a hierarchical/recursive system decomposition, classical agent orientation reaches its limits. We propose the concept of an organizational unit that both embeds actors and is itself embedded as a collective actor in surrounding organizational units. Building upon previous publications that feature an abstract model of organizational units, we supply it with a precise operational semantics in this paper.