Search

There are many benefits of using argumentation-based techniques in multi-agent systems, as clearly shown in the literature. Such benefits come not only from the expressiveness that argumentation-based techniques bring to agent communication but also from the reasoning and decision-making capabilities under conditions of conflicting and uncertain information that argumentation enables for autonomous agents. When developing multi-agent applications in which argumentation will be used to improve agent communication and reasoning, argumentation schemes (reasoning patterns for argumentation) are useful in addressing the requirements of the application domain in regards to argumentation (e.g., defining the scope in which argumentation will be used by agents in that particular application). In this work, we propose an argumentation framework that takes into account the particular structure of argumentation schemes at its core. This paper formally defines such a framework and experimentally evaluates its implementation for both argumentation-based reasoning and dialogues.

Ambient intelligence (AmI) emerged in Europe with the idea that the computational support available in a living environment can help people’s lives. AmI introduces new challenges and critical issue...

The theory of argumentation pervades several fields of knowledge, and it has gained significant space in multiagent systems because it provides a way for modeling reasoning over conflicting information in intelligent agents. This work proposes the development of an argumentation-based inference mechanism for BDI agents based on Toulmin's model of argumentation. The philosopher Stephen Toulmin claimed that arguments typically consist of six parts: data, warrant, claim, backing, qualifier, and rebuttal. This argumentation structure allows arguments to be described through separated components, making it easier to define and to evaluate the inference process. By presenting and discussing some case studies, this paper shows how this mechanism supports the inference of new beliefs based on available evidence within BDI agents programmed in an agent-oriented programming language.

We conducted a mapping study to investigate how the scientific community uses Ambient intelligence technologies to assist visually impaired people. Our initial search identified a total of 807 publications; after applying our selection criteria, we accepted 65 publications. We seek to show which technologies, methodologies, techniques, architectures, features, and evaluations are most used. Results indicated that only 15.53% have a specific focus on people who are visually impaired. Most of the results were published in 2015. Most authors used their own architectures. Many results used techniques such as Detection and recognition, Artificial Intelligence, Networking, and others.

Bed allocation in hospitals is a critical and important problem, and it has become even more important since last year because of the COVID-19 pandemic. In this paper, we present an approach based on intelligent-agent technologies to assist hospital staff in charge of bed allocation. As part of this work, we developed a web-based simulation of hospital bed allocation system integrated with a chatbot for interaction with the user. As a core component in our approach, an intelligent agent uses the feedback of a plan validator to check if there are any flaws in a user-made allocation, communicating any detected problems to the user using natural language through the chatbot. Thus, our resulting application not only validates bed allocation plans but also interacts with hospital professionals using natural language communication, including giving explainable suggestions of better alternative allocations. We evaluated our approach with professionals responsible for bed allocation in two local hospitals and a doctor who provides consultancy to another local hospital. The version of the system reported in this paper addresses all the suggestions made by the specialists who evaluated its previous version.

This work investigates and apply the use of a multi-agent system to assist in the coordination of group tasks, specifically in educational environments, in which the interaction occurs indirectly, that is, asynchronously. The system has a web interface integrated with a chatbot for more natural interaction. The chatbot communicates with the multi-agent system that is responsible for the organization of the group, that is, it contains information about the tasks and members of the groups, in addition to restrictions that can be imposed according to the organization of the group, and it is also able to return the requested information in natural language through the chatbot. This approach was validated in a practical undergraduate course of software engineering. The students assessed the functionalities and usability of the system while working in groups in order to develop software collaboratively. Our system was used to assist students in a real project. With this assessment, it was found that the system was able to support the development of the group tasks, ensuring quick and consistent responses to the student’s request.

Multi-agent techniques have become mature technologies with many tools, programming languages, and methodologies currently available. As a result, it is a practical approach for the development of complex AI systems. However, there are still challenges in developing an interface that enables a more natural communication interface between software agents and human agents, for example, using natural language. We believe chatbot technologies can provide the support needed to face this challenge. In this paper, we propose an approach to the integration of multi-agent systems and chatbot technologies named Dial4JaCa. The resulting integration makes it possible to apply both those technologies together to a variety of domains. In this particular work, we use JaCaMo as a multi-agent programming platform and Dialogflow as a chatbot platform. We evaluate the Dial4JaCa integration using two different multi-agent applications.

Multi-Agent Systems (MAS) have become a powerful approach to the development of complex AI systems. However, the community faces the challenge of developing communication interfaces between software agents and humans, for instance, using natural language. In this paper, we demonstrate an approach to the integration of MAS and chatbot technologies named Dial4JaCa. Dial4JaCa enables the implementation of MAS integrated with chatbots, which can be applied to a variety of domains. In this particular work, we demonstrate how it is possible to integrate a JaCaMo application (agent system) with Dialogflow (a chatbot platform) using Dial4JaCa.

There are many benefits of using argumentation-based techniques in multi-agent systems, as clearly shown in literature. Such benefits come not only from the expressiveness that such approaches bring to agent communication but also from the reasoning and decision-making capabilities under conditions of conflicting and uncertain information that argumentation brings to autonomous agents. When developing multi-agent applications in which argumentation will be used to improve agent communication and reasoning, argumentation schemes (i.e., reasoning patterns for argumentation) are useful in addressing the requirements of the application domain in regards to argumentation (e.g., defining the scope in which argumentation will be used by agents in that particular application). In this work, we propose a general argumentation framework that takes into account the particular structure of argumentation schemes at its core. This paper formally defines that framework and experimentally evaluates its implementation.

The Multi-Agent Programming Contest in 2017 expanded upon the Agents in the City scenario used in the 2016 edition of the contest. In the Agents in the City contest, two teams compete to accomplish logistic tasks in simulations using realistic city maps from OpenStreetMap. The new version of the scenario shifted emphasis to include jobs that require assembled items, new types of facilities, and larger teams, resulting in a significantly more complex scenario than before. In this paper, we describe the strategies used by our team, highlighting our adaptations and any new additions from our participation in the previous year. One such new addition, is that now we have fully explored the use of all three programming dimensions (agent, environment, and organization) found in JaCaMo, the multi-agent system development platform that we used to implement our team. We also provide some discussion and analysis on what we believe were some of our most influential matches.

Managing risks in real-world software projects is of paramount importance. A significant class of such risks is related to the engineering of requirements, commonly involving the presentation and analysis of risk management arguments from both software engineers and clients involved in collaborative debates. In this work, drawing inspiration from argumentation theory in Artificial Intelligence, we introduce a number of “argumentation schemes” and associated “critical questions” to support such discussions. In doing so, we propose schemes related to risks due to excessive numbers of requirements; inadequate client representatives and poor understanding of client needs; incorrect, incomplete and conflicting requirements; complex and non-traceable requirements; non-stable requirements; and low quality requirements. We also discuss a case study and two experiments where the developed schemes supported the discussion of requirement risks in software projects. The overall results of these experiments indicate that our schemes are useful in the identification, proposition and analysis of requirement risks, adequately supporting debates on requirement risks.

In this work we compile our research regarding meta-information in multi-agent systems. In particular, we describe some agents profiles represent- ing different attitudes which describe how agents consider meta-information in their decisions-making and reasoning processes. Furthermore, we describe how we have combined different meta-information available in multi-agent systems with an argumentation-based reasoning mechanism. In our approach, agents are able to decide more conflicts between information/arguments, given that they are able to use different meta-information (often combined) to decide between such conflicting information. Our framework for meta-information in multi- agent systems was implemented based on a modular architecture, thus other meta-information can be added, as well as different meta-information can be combined in order to create new agents profiles. Therefore, in our approach, different agents profiles can be instantiated for different application domains, allowing flexibility in the choice of how agents will deal with conflicting infor- mation in those particular domains.

Model-driven engineering provides abstractions and notations for improving the understanding and for supporting the modelling, coding, and verification of applications for specific domains. Ontologies, on the other hand, provide formal and explicit definitions of shared conceptualisations and enable the use of semantic reasoning. Although these areas have been developed by different communities, important synergies can be achieved when both are combined. These advantages can be explored in the development of multi-agent systems, given their complexity and the need for integrating several components that are often addressed from different angles. This work investigates how to apply ontologies for agentoriented software engineering. Initially, we present a new modelling approach where multiagent systems are designed using the proposed OntoMAS ontology. Then, we describe techniques, implemented in a tool, to help programmers bring their concepts into code and also generate code automatically from instantiated ontology models. Several advantages can be obtained from these new approaches to model and code multi-agent systems, such as semantic reasoning to carry out inferences and verification mechanisms. But the main advantage is the unified high (knowledge) level specification language that allows modelling the three dimensions that are united in the JaCaMo framework so that systems specifications can be better communicated across developing teams. The evaluations of these proposals indicate that they contribute with the different aspects of agent-oriented software engineering, such as the specification, verification, and programming of these systems.

Describing planning domains using a common formalism promotes greater reuse of research, allowing a fairer comparison between different planners and approaches. Common planning formalisms for single-agent planning are already well established (e.g., PDDL, STRIPS, and HTN), but currently there is a shortage of multi-agent planning formalisms with clear semantics. In this paper, we propose a multi-agent extension of the Hierarchical Task Network (HTN) planning formalism for multi-agent planning problems. Our formalism, the Multi-Agent Hierarchical Task Network (MA-HTN), can be used to specify and represent multi-agent planning domains and problems. We provide a grammar with semantics for the domain and problem representation, and describe two case studies with the translation from multi-agent systems developed in JaCaMo to our MA-HTN formalism.

An agent can attempt to achieve multiple goals and each goal can be achieved by applying various different plans. Anticipating failures in agent plan execution is important to enable an agent to develop strategies to avoid or circumvent such failures, allowing the agent to achieve its goal. Plan recognition can be used to infer which plans are being executed from observations of sequences of activities being performed by an agent. Symbolic Plan Recognition is an algorithm that represents knowledge about the agents under observation in the form of a plan library. In this work, we use this symbolic algorithm to find out which plan the agent is performing and we develop a failure prediction system, based on information available in the plan library and in a simplified calendar which manages the goals the agent has to achieve. This failure predictor is able to monitor the sequence of agent actions and detects if an action is taking too long or does not match the plan that the agent was expected to be performing. We have successfully employed this approach in a health-care prototype system.

Simulation can be an important conceptual and practical tool to support the engineering of multi-agent systems (MAS), in different ways. In this paper we consider the case in which simulation is applied and exploited directly upon a MAS developed using an existing agent/MAS programming platform. That is: without requiring to model and simulate agents and their environment using a different platform, e.g. an agent-based simulation one. In particular, we describe the design of JaCaMo-sim, an extension of the JaCaMo platform that makes it possible to both run and simulate the execution of MAS programs based on BDI agents written in Jason, situated in artifact-based environments developed in CArtAgO. The tool can be useful for different aspects that concern MAS engineering, from MAS testing/debugging at development time to agent decision making support at runtime.

Typically, an agent society is composed of at least three main components, namely, the set of its individual agents, the set of multi-agent organisations that help coordinate the actions of those agents, and the environment that those agents share. However, other levels have also been pointed out in the agent society literature, for example, the internal normative systems that regulate the structure and operation of the organisations themselves and, more generally, the overarching cultural system of the society. Many types of formal semantics for such systems, such as for example operational semantics, are not immediately suitable for systems that have ongoing operations at several architectural levels and requiring that those levels synchronise when particular events occur. This paper addresses this problem by proposing an approach to giving formal semantics to multi-level agent societies. The approach allows for the reuse of existing semantics for the separate levels, improves readability, and reduces the number of inference rules to be written.

We introduce a novel two-dimensional simulator for disaster response on maps of real cities dealing with logistics and coordination problems. Our simulator allows to plug-in almost any approach developed for simulated environments and offers functionalities for further developing and benchmarking. It provides metrics that help the analysis of the performance of a team of agents during the disaster. Our experiments were conducted for a mud disaster episode and show how to evaluate different techniques.

We introduce a novel two-dimensional simulator for disaster response on maps of real cities. Our simulator deals with logistics and coordination problems and allows to plug-in almost any approach developed for simulated environments. In addition, it (1) offers functionalities for further developing and benchmarking, and (2) provides metrics that help the analysis of the performance of a team of agents during the disaster. Our simulator is based on software made available by the multi-agent programming contest, which over the years has provided challenging problems to be solved by intelligent agents. We evaluate the performance of our simulator in terms of processing time and memory usage, message exchange, and response time. We apply this analysis to two different approaches for dealing with the mining dam disaster that occurred in Brazil in 2019. Our results show that our simulator is robust and can work with a reasonable number of agents.

This work presents GoDonnie a programming language to command a robot to improve orientation and mobility(O&M) skills in people who are visually impaired (PVI). The GoDonnie programming language is based on the Logo language. GoDonnie runs in a programming environment called Donnie. This environment has a 2D graphic simulator with a virtual robot, in which one can visualise and receive sound feedback from the execution of the language commands for moving the virtual robot in the environment. GoDonnie has been evaluated with PVI to verify its usability and support to O&M. The results indicate that GoDonnie has good usability, supports the development of O&M in PVI and meets the expectations regarding the programming environment. A video of GoDonnie execution is available in https://youtu.be/HE__sAgfNBo

Research on Multi-Agent Systems (MAS) has led to the development of several models, languages, and technologies for programming not only agents, but also their interaction, the application environment where they are situated, as well as the organization in which they participate. Research on those topics moved from agent-oriented programming towards multi-agent-oriented programming (MAOP). A MAS program is then designed and developed using a structured set of concepts and associated first-class design and programming abstractions that go beyond the concepts normally associated with agents. They include those related to environment, interaction, and organization. JaCaMo is a platform for MAOP built on top of three seamlessly integrated dimensions (i.e. structured sets of concepts and associated execution platforms): for programming belief desire intention (BDI) agents, their artefact-based environments, and their normative organizations. The key purpose of our work on JaCaMo is to support programmers in exploring the synergy between these dimensions, providing a comprehensive programming model, as well as a corresponding platform for developing and running MAS. This paper provides a practical overview of MAOP using JaCaMo. We show how emphasizing one particular dimension leads to different solutions to the same problem, and discuss the issues of each of those solutions.

The Multi-Agent Programming Contest in 2018 expanded upon the Agents in the City scenario used in the 2016 and 2017 editions of the contest. In this scenario two teams compete to score points by building and attacking wells using realistic city maps from OpenStreetMap. Wells are the main addition to the new version of the scenario; they cost money to build and generate score overtime but can be dismantled by agents from the other team. This, along with other additions, made it a significantly more complex scenario than before. In this paper, we describe the strategies used by our team, highlighting our adaptations and new additions from our participation in the previous years. We have fully explored the use of all three programming dimensions (agent, environment, and organisation) available in JaCaMo, the multi-agent system development platform that we used to implement our team. Our agents were able to dynamically switch between organisational roles, allowing them to promptly respond to changes in the environment and different opponent strategies. We were the highest-scoring team in the contest and our multi-agent system turned out to be stable and robust in solving the difficult problems posed by the contest scenario.

In this chapter, we introduce AgentSpeak(ER), an extension of the AgentSpeak(L) language tailored to support encapsulation. The AgentSpeak(ER) extension allows for significantly improving the style of BDI agent programming along relevant aspects, including program modularity and readability, failure handling, and reactive as well as goal-based reasoning. The chapter introduces the novel language based on AgentSpeak, illustrates the features of the language through examples, and discuss results of a case study based on the implementation of the proposed language.

The increasing diffusion of team building as a means to enhance social relations and define roles within teams, and the cost of setting up a real team building event, raises the pressing need of simulating team building activities in order to assess the effectiveness of different formats, run in different contexts and under different conditions, before one is selected for a particular scenario.

This chapter presents our proposal for the development of multi-agent systems designed as ontology models supporting code generation and reasoning. The foundation of such work takes into consideration ontologies for agent-oriented software engineering aligned with the JaCaMo framework. These techniques are implemented in a tool that supports multi-agent systems core code generation for JaCaMo. The underlying ontology also allows for reasoning about the multi-agent systems models under development. Such comprehensive approach, therefore, spans through the modelling, programming, and verification of agent-oriented software.

This work focuses on coalition formation among heterogeneous agents for the 2017 multiagent programming contest. An agent is a computer system that is capable of independent action to achieve its goals. In order to increase the effectiveness of the agents, we can organise them into coalitions, in which the agents collaborate with each other to achieve individual or common goals. We investigate and apply coalition structure generation (the first activity of the coalition formation process) in simulated scenarios, specifically the 2017 contest scenario, where the agents forming a competing team cooperate to solve logistic problems simulated on the map of a real city. In order to achieve our goal, we integrate coalition formation algorithms into the JaCaMo platform by means of a CArtAgO artefact, named CFArtefact. We use the implementation of the SMART JaCaMo team for experimenting with the coalition formation approach in the contest scenario. We experiment on three approaches in the contest domain with different configurations. In the first, we use only a taskallocation mechanism, while the other approaches use an optimal coalition formation algorithm and a heuristic coalition formation algorithm. We conducted several experiments to compare the advantages of each approach. Our results show that coalition formation algorithms can improve the performance of a participating team when dealing with low job rates (i.e., how quickly new jobs are created by the simulation). However, as we increase the job rate, the approach using only task allocation has better performance. Even a heuristic coalition formation approach has close performance to the optimal one in that case. Coalition formation can play an important role when we aim to balance each group of agents to accomplish some particular goal given a larger team of cooperating agents.

Agreement, cooperation and trust would be straightforward if deception did not ever occur in communicative interactions. Humans have deceived one another since the species began. Do machines deceive one another or indeed humans? If they do, how may we detect this? To detect machine deception, arguably requires a model of how machines may deceive, and how such deception may be identified. Theory of Mind (ToM) provides the opportunity to create intelligent machines that are able to model the minds of other agents. The future implications of a machine that has the capability to understand other minds (human or artificial) and that also has the reasons and intentions to deceive others are dark from an ethical perspective. Being able to understand the dishonest and unethical behaviour of such machines is crucial to current research in AI. In this paper, we present a high-level approach for modelling machine deception using ToM under factors of uncertainty and we propose an implementation of this model in an Agent-Oriented Programming Language (AOPL). We show that the Multi-Agent Systems (MAS) paradigm can be used to integrate concepts from two major theories of deception, namely Information Manipulation Theory 2 (IMT2) and Interpersonal Deception Theory (IDT), and how to apply these concepts in order to build a model of computational deception that takes into account ToM. To show how agents use ToM in order to deceive, we define an epistemic agent mechanism using BDI-like architectures to analyse deceptive interactions between deceivers and their potential targets and we also explain the steps in which the model can be implemented in an AOPL. To the best of our knowledge, this work is one of the first attempts in AI that (i) uses ToM along with components of IMT2 and IDT in order to analyse deceptive interactions and (ii) implements such a model.

Production and characterization of polymeric nanoparticles, as colloidal dispersions, are processes that require time and technical skills to make the results accurate. Computational simulations in nanoscience have been used to help in these processes and provide agility and support to reach results: stability and quality in dispersions. Multi-Agent System for Polymeric Nanoparticles (MASPN) is an innovative and original simulation environment with features to demonstrate interactions of particles from physical-chemical parameters, ensuring Brownian motion of particles and attractive and repulsive behaviour. The MASPN environment has been designed and has been built according to the feature-driven development (FDD), as software methodology, and a multi-agent systems approach. In addition, we have used the event-driven simulation package algs4, the JASON agent building environment, all integrated by Java language. This paper aims to present the relation of the algs4 package and the JASON tool, both integrated into the MASPN environment to generate Brownian motion with elastic and inelastic collisions. The MASPN environment as a simulation tool emerges as a result, including the following features: graphical interface; integrated physical-chemical parameters; Brownian motion; JASON and algs4 integration; and distribution charts (size, zeta potential, and pH).

The theory of argumentation spans several fields of knowledge, gaining significant space in the community of multiagent systems because it gives support for agents to reason about uncertain beliefs. This work describes the development of an argumentation-based inference architecture for BDI agents, which was developed based on Toulmin's model of argumentation. The philosopher Stephen Toulmin claimed that arguments typically consist of six parts: data, warrants, claim, backing, qualifiers, and rebuttals. Using the proposed architecture, an agent is able to create new beliefs based on available evidence and to justify such beliefs.

Argumentation schemes are common patterns of arguments used in everyday discourse, as well as in contexts such as legal and scientific argumentation. The use of argumentation schemes may depend on the (social) context of the participating actors, the roles that they play in society, and so on. Based on this idea, this work proposes a conceptual and practical framework that combines argumentation schemes and social organisations in multi-agent systems. In our framework, the agents’ social context constrains the usage of argumentation schemes and their associated critical questions. The framework has been developed on top of an existing multi-agent systems development platform, and we argue that our approach has advantages over traditional uses of argumentation schemes such as requiring less communication in multi-agent systems.

One of the challenges in developing multi-robot systems is the design of appropriate coordination strategies in such a way that robots perform their operations efficiently. In particular, efficient coordination requires judicious task allocation. Without appropriate task allocation, the use of multi-robot systems in complex scenarios becomes limited or even unfeasible. Real-world scenarios usually require the use of heterogeneous robots and task fulfillment with different structures, constraints, and degrees of complexity. In such scenarios, decentralised solutions seem to be appropriate for task allocation, since centralised solutions represent a single point of failure for the system. During the allocation process, in decentralised approaches, there are often communication requirements, as participants need to share information. Maintaining data integrity, resilience, and security in data access are some of the important features for this type of solution. In that direction, we propose an architecture for dynamic and decentralised allocation of tasks built on the idea of having communication and coordination in a multi-agent system through a private blockchain.

The BDI architecture is one of the best known approaches for the development of agents situated in complex dynamic environments. Founded on the symbolic approach to AI, it is a consolidated model that builds upon substantial theoretical and practical contributions. However, there are aspects of the cognitive phenomena that require the representation of concepts to classify perceptual information in ways that have not been sufficiently explored in the BDI architecture. Taking into consideration that conceptual representations can, for example, improve object recognition processes, this paper addresses that problem, drawing from the theory of Conceptual Spaces. The paper also illustrates the viability of the proposed approach through the development of an application that aims to support visually impaired people. This application was developed using the Jason agent platform and the CSML language.

Task allocation is an important aspect in dealing with coordination problems. However, there are challenges in developing appropriate strategies for multi-robot teams in such a way that robots perform their operations efficiently. Real-world scenarios usually require the use of heterogeneous robots and execution of tasks with different structures and constraints. In this paper we propose a dynamic, decentralised task allocation mechanism considering different types of tasks for heterogeneous robot teams playing different roles and carrying out tasks according to their own capabilities. We have run several simulations in order to evaluate the proposed mechanism. The results indicate that the proposed mechanism scales well and provides near-optimal allocations.

In this paper we present CooL-AgentSpeak, an extension of AgentSpeak-DL with plan exchange and ontology services. In CooL-AgentSpeak, the search for an ontologically relevant plan is no longer limited to the agent's local plan library but is carried out in the other agents' libraries too, according to a cooperation strategy, and it is not based solely on unification and on the subsumption relation between concepts, but also on ontology matching. Belief querying and updating also take advantage of ontological reasoning and matching.

Argumentation in multi-agent systems provides both a mechanism for agent reasoning under uncertainty and conflicting information as well as for communication in a more elaborate way, allowing agents to understand each other through the exchange of additional information when compared to other forms of agent communication. Even though argumentation techniques can play an important role in multi-agent systems, little research has been carried out on the issues in integrating argumentation techniques and agent-oriented programming languages, which would allow the development of practical applications taking advantage of such combined techniques. In this work, we present an argumentation framework developed on the basis of an agent-oriented programming language. We cover mainly the practical aspects of such integration, focusing on the knowledge representation expressivity resulting from it. Our approach allows the development of multi-agent applications where agents are able to use arguments in their decision-making processes as well as for communication. The framework has been successfully used as part of the development of a healthcare multi-agent prototype application.

Most approaches to plan recognition are based on manually constructed rules, where the knowledge base is represented as a plan library for recognising plans. For non-trivial domains, such plan libraries have complex structures representing possible agent behaviour to achieve a plan. Existing plan recognition approaches are seldom tested at their limits, and, though they use conceptually similar plan library representations, they rarely use the exact same domain in order to directly compare their performance, leading to the need for a principled approach to evaluating them. Thus, we develop a mechanism to automatically generate arbitrarily complex plan libraries which can be directed through a number of parameters, in order to create plan libraries representing different domains and so allowing systematic experimentation and comparison among the several plan recognition algorithms. We validate our mechanism by carrying out an experiment to evaluate the performance of a known plan recognition algorithm.

Centralised planning systems generally assign goals to agents during the search for a solution to a planning problem. In a distributed multi-agent setting, this would constrain the autonomy of the agents, and violate their privacy. Thus, by using task allocation protocols, the agents themselves can compete to decide who will take each goal, then later plan individually provided coordination mechanisms are in place, giving a higher degree of autonomy and privacy during the planning process. In this paper, we propose the use of a contract net protocol mechanism to allocate social goals in multi-agent planning. Our contributions are an algorithm for determining a bid, and several bid evaluation criteria. We also define some heuristics that can be used as bids. In our algorithm, agents expand social goals using their plan library in order to collect information and formulate their bid. We also show the results of experiments in a multi-agent planning domain in order to evaluate our heuristics.

Argumentation-based reasoning plays an important role in agent reasoning and communication, yet little research has been carried out on the issues in integrating argumentation techniques into practical multi-agent platforms and the various sources of information in such systems. In this work, we extend an argumentation-based reasoning mechanism to take into account preferences over arguments supporting contrary conclusions, which in practice means the agent will be able to act more informedly, being able to decide on beliefs about which it would be otherwise ambivalent. Such preferences come from elements that are present or can be more easily obtained in the context of practical multi-agent programming platforms, such as multiple sources from which the information (used to construct the arguments) was acquired, as well as varying degrees of trust on them. Further, we introduce different agent profiles by varying the way certain operators are applied over the various information sources leading to the preferences over competing arguments in our approach. Unlike previous approaches, our approach accounts for multiple sources for a single piece of information and is based on an argumentation-based reasoning mechanism implemented on a multi-agent platform so arguably more computationally grounded than those approaches.

In this paper we describe a verification system for multi-agent programs. This is the first comprehensive approach to the verification of programs developed using programming languages based on the BDI (belief-desire-intention) model of agency. In particular, we have developed a specific layer of abstraction, sitting between the underlying verification system and the agent programming language, that maps the semantics of agent programs into the relevant model-checking framework. Crucially, this abstraction layer is both flexible and extensible; not only can a variety of different agent programming languages be implemented and verified, but even heterogeneous multi-agent programs can be captured semantically. In addition to describing this layer, and the semantic mapping inherent within it, we describe how the underlying model-checker is driven and how agent properties are checked. We also present several examples showing how the system can be used. As this is the first system of its kind, it is relatively slow, so we also indicate further work that needs to be tackled to improve performance.

The multi-agent programming contest uses a cow-herding scenario where two teams of cooperative agents compete for resources against each other. We developed such a team of agents using two well-known platforms, one based on a logic-based agent-oriented programming language, called Jason, and the other based on an organisational model, called $\mathcal{M}$ oise. While there is significant research on both agent programming and agent organisations, this was one of the first applications of a combined approach where we can program deliberative agents and organise them using a sophisticated organisational model. In this paper, we describe and discuss our contribution to the multi-agent contest using this combination of agent and organisation programming.

Programming languages designed specifically for multi-agent systems represent a new programming paradigm that has gained popularity over recent years, with some multi-agent programming languages being used in increasingly sophisticated applications, often in critical areas. To support this, we have developed a set of tools to allow the use of model-checking techniques in the verification of systems directly implemented in one particular language called AgentSpeak. The success of model checking as a verification technique for large software systems is dependent partly on its use in combination with various state-space reduction techniques, an important example of which is property-based slicing. This article introduces an algorithm for property-based slicing of AgentSpeak multi-agent systems. The algorithm uses literal dependence graphs, as developed for slicing logic programs, and generates a program slice whose state space is stuttering-equivalent to that of the original program; the slicing criterion is a property in a logic with LTL operators and (shallow) BDI modalities. In addition to showing correctness and characterizing the complexity of the slicing algorithm, we apply it to an AgentSpeak program based on autonomous planetary exploration rovers, and we discuss how slicing reduces the model-checking state space. The experiment results show a significant reduction in the state space required for model checking that agent, thus indicating that this approach can have an important impact on the future practicality of agent verification.

In this paper we propose a model for designing Belief-Desire-Intention (BDI) agents under the principles of modularity. We aim to encapsulate agent functionalities expressed as BDI abstractions into independent, reusable and easier to maintain units of code, which agents can dynamically load. The general idea of our approach is to exploit the notion of namespace to organize components such as beliefs, plans and goals. This approach allowed us to address the name-collision problem, providing interface and information hiding features for modules. Although the proposal is suitable for agent-oriented programming languages in general, we present concrete examples in Jason.

The BDI (Beliefs, Desires, Intentions) architecture is commonly used for the development of systems of agents situated in complex and dynamic environments. The BDI architecture represents a consolidated model that counts upon substantial theoretical and practical contributions. However, despite the strengths of symbolic models, there are some aspects of the cognitive phenomena that give rise to the need of a conceptual model that has to establish itself between the perceptual and symbolic levels. Taking into account that the use of conceptual representations can improve the recognition of objects as well as the agent communication process, the work presented here comprises the design and implementation of an integration of a conceptual-space level into the BDI agent architecture. Such integration is developed on top of the resources of the Jason platform and the CSML API. The evaluation of the implications of such a conceptual inference model for BDI agents includes the development of an application directed to the aid of users who are blind or visually impaired, as briefly discussed in this paper.