Tobias Ahlbrecht

A Scalable Runtime Platform for Multiagent-Based Simulation

Using purely agent-based platforms for any kind of simulation requires to address the following challenges: (1) scalability (efficient scheduling of agent cycles is difficult), (2) efficient memory management (when and which data should be fetched, cached, or written to/from disk), and (3) modelling (no generally accepted meta-models exist: what are essential concepts, what just implementation details?). While dedicated professional simulation tools usually provide rich domain libraries and advanced visualisation techniques, and support the simulation of large scenarios, they do not allow for “agentization” of single components. We are trying to bridge this gap by developing a distributed, scalable runtime platform for multiagent simulation, MASeRaTi, addressing the three problems mentioned above. It allows to plug-in both dedicated simulation tools (for the macro view) as well as the agentization of certain components of the system (to allow a micro view). If no agent-related features are used, its performance should be as close as possible to the legacy system used.

Multi-Agent Programming Contest 2013

This is about the ninth edition of the Multi-Agent Programming Contest, an annual, community-serving competition that attracts groups from all over the world. Our contest enables head-to-head comparison of multi-agent systems and supports educational efforts in the design and implementation of such systems. This year we have generated a multitude of statistical data for each match and give a detailed interpretation of them.

Agent-Based Simulation for Software Development Processes

Software development is a costly process and requires serious quality control on the management level: Managing a project with more than 10 programmers over several years is a highly nontrivial task. We are building tools for helping the manager to predict the future development of the project based on certain adjustable parameters.

From Testing Agent Systems to a Scalable Simulation Platform

Since 10 years our group in Clausthal is organizing the Multi-Agent Programming Contest, an international contest providing a flexible testbed for evaluating prototypical implementations of agent systems. We describe in this paper how the scenarios developed over time, which lessons we learned, and how this endeavour finally led to the idea of a scalable multiagent simulation platform. The important conclusion we draw is the need to move from academic prototypes to more seriously engineered software systems in order to support the uptake of academic research in industry.

Multi-Agent Programming Contest 2013: The Teams and the Design of Their Systems

Five teams participated in the Multi-Agent Programming Contest in 2013: All of them gained experience in 2012 already. In order to better understand which paradigms they used, which techniques they considered important and how much work they invested, the organisers of the contest compiled together a detailed list of questions (circa 50). This paper collects all answers to these questions as given by the teams.

Scalable Multi-agent Simulation Based on MapReduce

Jason is perhaps the most advanced multi-agent programming language based on AgentSpeak. Unfortunately, its current Java-based implementation does not scale up and is seriously limited for simulating systems of hundreds of thousands of agents.

Multi-agent programming contest 2017: The twelfth edition of the MAPC

We present the twelfth edition of the Multi-Agent Programming Contest (https://multiagentcontest.org), an annual, community-serving competition that attracts groups from all over the world. Our contest facilitates comparison of multi-agent systems and provides a concrete problem that is interesting in itself and well-suited to be tackled in educational environments. This time, seven teams competed using strictly agent-based as well as traditional programming approaches.

Simulating Software Refactorings Based on Graph Transformations

We aim to simulate software processes in order to predict the structural evolution of software graphs and assure higher software quality. To make our simulation and therefore the results more accurate, we need to model real world practices. In this paper, we consider the specific problem of including software refactorings in our simulation. We describe these refactorings as graph transformations and apply parameters we collected from open source projects.