Daniel Moldt

Goal representation for BDI agent systems

Agent-oriented system development aims to simplify the construction of complex systems by introducing a natural abstraction layer on top of the object-oriented paradigm composed of autonomous interacting actors. One main advantage of the agent metaphor is that an agent can be described similar to the characteristics of the human mind consisting of several interrelated concepts which constitute the internal agent structure. General consensus exists that the Belief-Desire-Intention (BDI) model is well suited for describing an agents mental state. The desires (goals) of an agent represent its motivational stance and are the main source for the agents actions. Therefore, the representation and handling of goals play a central role in goal-oriented requirements analysis and modelling techniques. Nevertheless, currently available BDI agent platforms mostly abstract from goals and do not represent them explicitly. This leads to a gap between design and implementation with respect to the available concepts. In this paper a generic representation of goal types, properties, and lifecycles is developed in consideration of existing goal-oriented requirements engineering and modelling techniques. The objective of this proposal is to bridge the gap between agent specification and implementation of goals and is backed by experiences gained from developing a generic agent framework.

An Extensible Editor and Simulation Engine for Petri Nets: Renew

Renew is a computer tool that supports the development and execution of object-oriented Petri nets, which include net instances, synchronous channels, and seamless Java integration for easy modelling. Renew is available free of charge including the Java source code. Due to the growing application area more and more requirements had to be fulfilled by the tool set. Therefore, the architecture of the tool has been refactored to gain more flexibility. Now new features allow for plug-ins on the level of concepts (net formalisms) and on the level of applications (e.g. workflow or agents).

Multi-Agent-Systems Based on Coloured Petri Nets

Based on Y. Shohams paradigm, called Agent-Oriented Programming (AOP), multi-agent-systems are presented as a specialization of distributed, Object-Oriented systems. Equipped with knowledge, general concurrent inference mechanisms dealing with this knowledge, and a declarative agent program, these multi-agent-systems are intended to be a foundation of a new approach uniting advantages of many contributing areas: The precise semantics of Petri nets, the abstraction and encapsulation proposed in Object-Oriented approaches, and the power of logic programming, making it easy to adopt well-known AI-methods. As an example, an urban traffic information system will be designed which solves path searching problems in a distributed graph.

Concurrent architecture for a multi-agent platform

A multi-agent system has a high degree of concurrency. Petri nets are a well-established means for the description of concurrent systems. Reference nets are higher level, object-oriented Petri nets. With Renew (REference NEt Workshop), there exists a tool to model and execute reference nets with seamless Java integration. So, reference nets can be used to design executable multi-agent systems while hiding the sometimes annoying details of concurrent implementations in traditional programming languages. The technique is currently used to implement a FIPA-compliant agent platform for multi-agent systems (called CAPA) focused on retaining a maximum level of concurrency in the system.

Modelling the Structure and Behaviour of Petri Net Agents

This work proposes a way to model the structure and behaviour of agents in terms of executable coloured Petri net protocols. Structure and behaviour are not all aspects of agent based computing: agents need a world to live in (mostly divided into platforms), they need a general structure (e.g. including a standard interface for communication) and their own special behaviour. Our approach tackles all three parts in terms of Petri nets. This paper skips the topic of agent platforms and handles the agent structure briefly to introduce a key concept of our work: the graphical modelling of the behaviour of autonomous and adaptive agents. A special kind of coloured Petri nets is being used throughout the work: reference nets. Complex agent behaviour is achieved via dynamic composition of simpler sub-protocols, a task that reference nets are especially well suited for. The inherent concurrency of Petri nets is another point that makes it easy to model agents: multiple threads of control are (nearly) automatically implied in Petri nets.

Regulated Agent-Based Social Systems

There is a certain style of paper which has become traditional in MAS – one where a formal logic is introduced to express some ideas, or where a logic is extended on the basis that it then covers certain particular cases, but where the logic is not actually used to make any substantial inferences and no application of the logic demonstrated. I argue that although these papers do follow a certain tradition, that they are not useful given the state of MAS and should, in future, be rejected as premature (just as if one had simulation but never run it). I counter the argument that theory is necessary by denying that the theory has to be so abstract. I counter the argument that logic helps communication on the simple grounds that for most people it doesn’t. I argue that the type of logic that tends to be used in these papers is inappropriate. I finish with some suggestions as to useful ways forward.

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.

Emotion-based norm enforcement and maintenance in multi-agent systems: foundations and petri net modeling

A review of recent theories of emotion indicates close interconnections between emotion and social norms in human societies. We consider the possibility of implementing these mutual influences in a multi-agent system in order to establish dynamic and flexible control structures. According to some theories, emotion plays a key role in establishing and maintaining these structures by fostering the internalization of and compliance with social norms. Here we introduce a Petri Net based approach to modeling the emergence and maintenance of social norms in multi-agent systems.

Pattern based workflow design using reference nets

The development of workflow applications requires satisfactory concepts and tools. Workflow patterns cover the conceptual part. To base the patterns on high-level Petri nets allows for the tight integration of the modelling editor with the actual execution engine.The development process of workflow applications gains from this. We propose to use Reference nets as the modelling technique, Renew as the basic execution engine, and our workflow modelling tool for the design of workflows.The latter is a plug-in for the Renew editor, which is based on the use of workflow patterns. The development process is based on prototyping.