This course will provide an introduction to main motivation and concepts in the field of agents and multi-agent systems, spanning both the micro and macro level, including: basic concepts; agent architecture; interaction and multi-agent systems; applications; and future challenges.

Agents are well-suited for dynamic, constrained, and real-time environments such as electronic marketplaces. In such environments agents representing their users negotiate for goods and services following negotiation protocols. Bargaining and auctions are the principal negotiation protocols for buying and selling goods based upon competition among the interested parties. This tutorial will introduce participants to agent-based negotiations. The tutorial will start by introducing agent-based negotiation and negotiation protocols in general. Bargaining and auctions will then be described in detail. Essential concepts that are required for following the tutorial will be introduced along the way. The bargaining problem will be introduced and the principal non-cooperative bargaining protocol (Rubinstein's alternating-offers) will be discussed in detail. Variations and applications Rubinstein's protocol in computer science will be presented. The four single side auction protocols (English, Dutch, FPSB, Vickrey) will be discussed in depth along with their relative advantages and disadvantages. Double auctions and the M-th and (M+1)-st clearing rules will also be covered. A brief exposition into more advanced auction formats such as multi-attribute and combinatorial auctions will follow.

Multi-agent planning is a very efficient tool for coordinating autonomous systems (e.g. robots, drones, underwater autonomous vehicles, software agents).
In this tutorial, we propose a progressive introduction to multi-agent planning and its most important applications. This tutorial is directed to an audience without specific background on automated planning, but a basic background on multi-agent systems is recommended.

First of all, we will introduce the fundamental concepts of automated planning and the principal algorithms: state-space planning, plan-space planning, SAT planning and graph planning. We will explain how to use the corresponding planners and illustrate their respective advantages and drawbacks. In the second part, we will present the key mechanisms of distributed planning: plan merging, Partial Global Planning and coordination mechanisms.

This tutorial is concerned with engineering multi-agent systems which operate in open, dynamic, unpredictable and potentially hostile environments; whose speed and complexity of operation requires them to exhibit self-* properties (* = regulating, organising, etc.); whose components are heterogeneous entities which may act collaboratively or selfishly; and which are therefore required to adapt according to the prevailing environment conditions, the need for self-regulation or repair, or in response to anti-social (illegal, or invalid) behaviour of other components.

The idea of norm-governed systems has been proposed and used for specifying a system in which the behaviour of its components is regulated by norms, where norms are specific rules prescribing legal, social or organizational constructs. Recent research has focused on three aspects that are essential for software engineering norm-governed systems with self-* properties: the executable specification of norm-governed systems, proving properties of such systems, and adaptation mechanisms for norm-governed systems.

The tutorial will inform participants of the state-of-the-art in these three aspects and their application to open-multi-agent systems. Using a running example, we will survey knowledge representation for norm-governed systems, and analyse formalisms with a direct route to implementation for executable specification. Then we look at reasoning in norm-governed systems, and how executable specification can be used to prove properties and animate protocols. Finally, we examine adaptation in norm-governed systems, using specification spaces, dynamic argument systems and run-time specification change.

Multi-agent planning and scheduling has received a great amount of attention in AI and the agent community. Intuitively, a multi-agent planning problem refers to making a plan/schedule  for a set of activities for and by several agents.

Usually, due to constraint specifications for these activities, it is not possible for these agents to make these plans/schedules completely independently from the other agents.

In order to prevent conflicts that might result from incompatible constraints imposed by these actors, coordination mechanisms have to be provided. After a general overview of coordination mechanisms and their properties, we discuss a coordination mechanism that ensures a conflict-free joint schedule and allows each actor to  schedule its part of the task independently from the others.

This mechanism ensures autonomous scheduling even when the original job specifies temporal dependencies between tasks allocated to different agents and can be used if communication between the agents during scheduling is impossible or unwanted.

We introduce this method  by first discussing the main features of temporal constraint networks such as Simple Temporal Networks to specify (distributed) tasks scheduling problems. Then we discuss temporal decoupling techniques in detail and discuss some quality measures for them, like the price of autonomy and the price of flexibility.

Finally, we discuss an application of this technique to the scheduling of ground handling service providers at airports.

For designing or analyzing agent societies, modeling interactions between agents is essential. The agents may be in a conflicting or in a cooperative context. In both cases, we can model the interaction in the form of a game: we can abstract the interaction using a set of actions, some rules and a description of the outcomes of the game. The field of game theory studies such games. The field describes a wide variety of game types and corresponding solution concepts to "solve" them. The goal of this tutorial is to introduce two important kinds of games: the strategic (also called non-cooperative) games that model situations of conflicts, and the coalitional (also called cooperative) games that model situations of cooperation. This introductory course is aimed at students who have no previous acquaintance with game theory. As such, only some elementary mathematical training is assumed. The main goal of the course is to introduce the most fundamental concepts and results. We will start with introducing the basics of strategic games. Then, we will introduce coalitional games and survey some issues addressed by some potential applications, and how they can be addressed by multiagent systems.

The tutorial begins with an introduction of the general motivations of trust in multiagent systems. The typical problems tackled by trust and reputation models are presented. We show that they are different problems that the ones tackled by security techniques and that security and trust must be considered as complementary approaches. The foundations of trust models are then explained. Starting from sociological studies, we identify the main concepts involved in trust models. We describe the two main approaches for trust models: game-theorical approach and socio-cognitive approach. In order to illustrate the functioning of the models in each approach, we go deeper in the details of fuzzy models, the works of Josang on the one hand and of the theory of Castelfranchi & Falcone and the computational models it has inspired on the other hand. Reputation models are then studied. Several prototypical models of reputation are presented in order to give a broad view of the different approaches in these kind of models putting special emphasis in the cognitive perspective. We will present also some advanced aspects of cognitive reputation models like for instance how a reputation model can be integrated in a BDI agent or how reputation can make use of argumentation. At last, a survey of the problems that arise when we try to evaluate reputation models is presented, mainly:

• Lack of integration on real applications.
• Lack of real and realistic data. Problems to generate simulated data.
• Lack of criteria on which and how the very different trust decisions should be considered.
• Lack of evaluation criteria from the distributed (agent-based) view.

And a general overview of how different authors tackle with these issues.

This tutorial is about organizational modelling and evaluating some of the tools that have been developed for the task.  Specifically, the tutorial will:

1. Develop an awareness of the contribution that organizational models can make to open software system and to MAS in particular.
2. Present several organizational modelling approaches and their tools, namely EIDE (https://e-institutions.iiia.csic.es/), OperettA (https://www.cs.uu.nl/research/projects/opera/), MOISE+ (https://moise.sourceforge.net/) and InstSuite (https://agents.cs.bath.ac.uk/InstSuite/).
3. Demonstrate their application in a common scenario - a preliminary implementation for each tool will be provided as a starting point: the task in the tutorial will be to extend it.
4. Evaluate each solution and each approach with the help of a common scenario, a group of beginning users and a group of experienced researchers.

The tutorial does not assume prior knowledge of organizations, but does expect participants to be familiar with MAS concepts, be competent programmers and have a basic understanding of logic (as taught in any conventional undergraduate CS degree).  A significant period of this tutorial will be spent working "hands-on" in groups on model development.

In this tutorial we introduce some well-known logics for specifying temporal properties (CTL and LTL)  and abilities of agents (ATL and its variants). For the latter we discuss the settings of perfect/imperfect recall and perfect/imperfect information.

In the second part of this tutorial we turn to the model checking problems of these logics. Model checking is an important method for the verification of multi-agent systems and is the question whether a given property (specified in a logical language)  holds in a given model (which can be seen as the abstraction of some problem). In order to establish some of these results we follow an automata-theoretic approach allowing for a uniform and elegant framework.

To cope with the inherent dynamism in today's application requirements and environments, systems need to autonomously change their structure and functionality on run-time. Dynamic behavioural changes are referred to with the term self-organisation, while new behaviours resulting from these changes are termed emergent.

The emphasis of this tutorial is three-fold. Firstly, it will provide an introduction to basic important concepts related to self-organisation and emergence and to provide a survey on the different main self-organizing systems. Secondly, it will focus on Adaptive Multi-Agent Systems which enable self-organising system design.  The presentation of tools associated with this approach will be detailed. Finally, this tutorial will present a number of representative real-world applications.

The first part of the course introduces the basics of self-organisation and emergence in natural and artificial systems: examples, definition of self-organisation and properties of self-organising systems, definition of the emergence and its properties. The second part presents several mechanisms (bio-inspired, socially-inspired or fully artificial) such as stigmergy, reinforcement, flocking, cooperation, reputation and gossip.
The third part focuses on a particular self-organising approach for multi-agent systems: the AMAS theory. This approach is based on cooperation between agents and self-organisation based on cooperation analysis. This framework is supported by a methodology (ADELFE) and by some tools (MAY). This part present existing methodologies associated to the AMAS approach, infrastructures, and tools to develop, deploy and study self-organizing multi-agent systems, such as ADELFE, MAY, etc.
Finally, the course presents several successful applications of self-organisation in MAS, such as aeronautical mechanical design and collective robotics.

Argumentation provides a powerful deliberative and dialectical model for interacting, decision-making agents to assess the validity of received information and to resolve conflicts and differences of opinion. It is an essential ingredient of decision-making, inter-agent communication and negotiation. Since they were introduced the computational models of argumentation are considered as suitable for representing and handling the conflicts in MAS. The aim of the course is to introduce the Dung's calculus of opposition and it recent extensions where agents have different preferences or hierarchies of values. Then, the course reviews assumption-based argumentation frameworks which are concrete frameworks built upon deductive systems. Finally, the course demonstrates some argumentation technologies as CaSAPI or MARGO.

Multiagent simulation forms an important application area of agent technology with a set of particular issues to be solved. Multiagent simulation is not just studying systems consisting of autonomous actors in rich environments, but can also be used as a step in agent-based software engineering for testing agent-based software designs.

This course will provide an overview to multiagent simulation from a computer science point of view. It introduces the basic concepts, categories of multi-agent models, respectively specialties in contrast to multiagent systems, as well as compared to other forms of modeling and simulation. We will deal with approaches to different phases of model development ranging from design and implementation to validation of multi-agent simulation models. A special focus lies on methodological issues. A discussion of applications from different domains forms the last part of the course.

Applications of Information Technology (IT) more and more show the interweaving of both human and technological communities, in which software entities act on behalf of users and cooperate with infohabitants, taking  into account issues such as trust, security, flexibility, adaptation, and openness. In this global context, multi-agent technologies provide concepts and tools that propose possible answers to these issues. Software entities modelled as autonomous agents are able to cooperate in a shared environment. Current applications have led to an increase in number of agents, in the duration and repetitiveness of their activities, with decision and action scopes still growing. Moreover, the number of agent designers is also increasing, leading to a huge spectrum of heterogeneity in these systems. Most designers have doubts about how to put these concepts in practice, i.e., how to program them, while both addressing the openness and scalability issues and keeping agents’ autonomy and decentralisation which are essential features of multi-agent systems (MAS). There is still a lack of a comprehensive view of the diverse concepts, models and approaches related to the programming of multi-agent systems.

In this course, we propose a practical tutorial where we will cover agent-oriented programming, organisation-oriented programming, and environment-oriented programming. The tutorial will combine state-of-the-art technologies and platforms for each of these levels of multi-agent programming, focusing on their integration. In particular, Jason, Moise, and Cartago will be used as examples of platforms for each of those levels, and the integration of all those tools will be used in a practical lab session. The course will give a brief overview of the related areas, introduce the relevant techniques, and then provide a lab session for students to have hands-on experience of fully-fledged multi-agent systems programming.

The basic principles and lessons of software, knowledge, and development process engineering, as well as the same scientific rigour pervading these research areas, have to be applied to the development and deployment of multi-agent systems. At present, the majority of existing agent applications are developed in an ad-hoc fashion: little or no rigorous design methodology and process, limited specification of the requirements, ad-hoc design of agents and of multi-agent system as a whole, and little attention to non-functional requirements such as mobility, scalability, performance issues, security, standards. This is indeed a limitation for the widespread appliance of any new software technology. In fact, a good quality software product calls for a clear and formal defined development process. However in the software engineering field it is widely recognised the concept that an ideal general-purpose agent-oriented (AO) methodology and an ideal general-purpose (AO) process do not exist. Most of AO methodologies proposed in literature in the last years are special purpose methodologies with the aim of engineering specific kinds of complex system. Now there is the need to build new methodologies for new kinds of application domains, but the construction of a new methodology from scratch is a very complex and time-consuming task. The reuse of portions (process fragments) of well-tested and well-known methodologies has become crucial. Moreover, key factors for the success of this technique can often be found in the clear definition of the source methodologies: their scope, the identification of a precise application and development context, the process, the produced artefacts, and so on. So, there is the need of a proper standard documentation for the methodologies description.

In this tutorial we aim to introduce both how to document AO methodologies and processes, and the techniques for the composition of process fragments for creating in a formal and well specify way a new AO design process.