Rafael H. Bordini

Developing a knowledge management multi-agent system using JaCaMo

Recent research on social and organisational aspects of multi-agent systems has led to practical organisational models and the idea of organisation-oriented programming. These organisational models help agents to achieve shared (global) goals of the multi-agent system. Having an organisational model is an important advance, but this model needs to be integrated to an environment infrastructure and agent-oriented programming platforms. JaCaMo is the first fully operational programming platform that integrates three levels of multi-agent abstractions: an agent programming language, an organisational model, and an environment infrastructure. For better showcasing the advantages of a fully-fledged multi-agent platform, this paper presents a concrete agent-based architecture to proactively supply knowledge to knowledge-intensive workflows which has been designed using JaCaMo.

Integrating Ontologies with Multi-Agent Systems through CArtAgO Artifacts

Several advantages can be obtained by allowing multi-agent systems to easily access ontologies, for example, in scenarios where agents make their decisions based on the knowledge provided by ontologies. Thus, this paper presents an infrastructure to allow the use of web ontologies in different agent-oriented platforms. The agents use this infrastructure layer as a tool for storing, accessing and querying domain-specific OWL ontologies. As a result, this layer allows an integration of agent platforms with semantic web data and ontologies. We exemplify in practice how agents, coded in one such platform, can use the proposed access layer to ontological reasoning engines, as well as which features can be obtained from it. The performance of this semantic infrastructure is evaluated and compared against usual knowledge representation in agent programming.

Towards Practical Argumentation-Based Dialogues in Multi-agent Systems

Although argumentation has been a prominent topic of research in artificial intelligence and in particular agent communication, there has been little work on practical (but provably sound) argumentation approaches integrated with agent programming languages. In this paper, we develop a formally-grounded mechanism for practical argumentation-based dialogues in an agent platform based on a multi-agent programming language. We formalise a protocol to govern such dialogues, where agents use an argumentation-based reasoning mechanism that has been implemented. We prove that dialogues following our protocol always terminate and that ideal solutions are reached under certain conditions. The protocol is simple but was shown to be useful in a multi-agent system application that supports teams of cooperating humans.

Semantic Representations of Agent Plans and Planning Problem Domains

Integrating knowledge representation approaches with agent programming and automated planning is still an open research challenge. To explore the combination of those techniques, we present a semantic model of planning domains that can be converted to both agent programming plans as well as planning problem definitions. Our approach allows the representation of agent plans using ontologies, enabling the integration of different formalisms since the knowledge in the ontology can be reused by several systems and applications. Ontologies enable the use of semantic reasoning in planning and agent systems, and such semantic web technologies are significant current research trends. This paper presents our planning ontology, exemplify its use with an instantiation, and shows how to translate between ontology, agent code, and planning specifications. Algorithms to convert between these formalisms are shown, and we also discuss future directions towards the integration of semantic representation, automated planning, and agent programming.

A Multi-Agent Extension of a Hierarchical Task Network Planning Formalism

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.

Knowledge Representation for Argumentation in Agent-Oriented Programming Languages

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.

Applying ontologies and agent technologies to generate ambient intelligence applications

The specification of agent systems comprises different dimensions normally defined using distinct formalisms. Since this lack of a uniform representation makes harder to express how each level affects the others, we propose an ontology to integrate the formalisms that originally cover a single multi-agent system dimension. In doing this, we align semantic technologies and knowledge representation for agents, environments, and organisations providing agent-oriented designers with a unified approach for developing complex systems. In our approach, we represent the abstractions typical of each multi-agent system dimension as an ontology, and we exemplify both the use of such ontologies to model an eldercare application in the context of ambient intelligence and smart cities, as well as how the ontology concepts support coding in agent platforms. We discuss the implications of such integrated view for designing agents, and highlight its advantages for agent-based software development.

Towards benchmarking actor- and agent-based programming languages

Over the past few years there have been several advances in distributed systems, and more recently multi-core processors. Consequently, a natural need for concurrent and parallel programming languages arises. In this paper, we compare some aspects of two concurrency models, Actors and Agents, using benchmarks to evaluate: (i) the communication performance on a concurrency-heavy scenario; (ii) the performance in a scenario with the presence of bottleneck and synchronization problems; and (iii) the reactivity and fairness of the models. We chose Jason, 2APL, and GOAL as the agent-oriented programming languages and Erlang, Akka, and ActorFoundry as the actor-oriented programming languages. Overall, Erlang displayed the best performance of all languages used in this comparison, followed by ActorFoundry, Akka, Jason, 2APL, and GOAL, in this particular order.

A Namespace Approach for Modularity in BDI Programming Languages

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.

Towards Integrating Ontologies in Multi-agent Programming Platforms

A growing number of agent technologies are receiving significant attention from both researchers and practitioners. Jason, Moise, and CArtAgO are examples of technologies that support the development of multi-agent systems. On the other hand, semantic technologies, such as ontologies, are becoming established as knowledge representation techniques for large web-based applications. Their development is accompanied by the development of semantic reasoners (e.g., Pellet), and query languages (e.g., SQWRL). This work investigates approaches that align semantic technologies and agent-oriented systems: AgentSpeak-DL, Argonaut, JASDL, and Semantic Moise, highlighting their advantages and limitations.