In open societies of agents, where agents are autonomous and heterogeneous, it is not realistic to assume that agents will always act so as to comply to interaction protocols. Thus, the need arises for a formalism to specify constraints on agent interaction, and for a tool able to observe and check for agent compliance to interaction protocols. In this paper we present a Java-Prolog software component which can be used to verify compliance of agent interaction to protocols written in a logicbased formalism (Social Integrity Constraints). 1

We introduce a new proof procedure for abductive logic programming and present two soundness results. Our procedure extends that of Fung and Kowalski by integrating abductive reasoning with constraint solving and by relaxing the restrictions on allowed inputs for which the procedure can operate correctly. An implementation of our proof procedure is available and has been applied successfully in the context of multiagent systems.

Abstract. In this work, we extend the architecture of agents (and robots) based upon fixed, one-size-fits-all cycles of operation, by providing a framework of declarative specification of agent control. Control is given in terms of cycle theories, which define in a declarative way the possible alternative behaviours of agents, depending on the particular circumstances of the (perceived) external environment in which they are situated, on the internal state of the agents at the time of operation, and on the agents ’ behavioural profile. This form of control is adopted by the KGP model of agency and has been successfully implemented in the PROSOCS platform. We also show how, via cycle theories, we can formally verify properties of agents ’ behaviour, focusing on the concrete property of agents ’ interruptibility. Finally, we give some examples to show how different cycle theories give rise to different, heterogeneous agents ’ behaviours. 1

Abstract. We describe a system implementing a novel extension of Fung and Kowalski’s IFF abductive proof procedure which we call CIFF, and its application to realise intelligent agents that can construct (partial or complete) plans and react to changes in the environment. CIFF extends the original IFF procedure in two ways: by dealing with constraint predicates and by dealing with non-allowed abductive logic programs. 1

prosocs agents are software agents that are built according to the kgp model of agency. kgp is used as a model for the mind of the agent, so that the agent can act autonomously using a collection of logic theories, providing the mind’s reasoning functionalities. The behaviour of the agent is controlled by a cycle theory that specifies the agent’s preferred patterns of operation. The implementation of the mind’s generic functionality in prosocs is worked out in such a way so it can be instantiated by the platform for different agents across applications. In this context, the development of a concrete example illustrates how an agent developer might program the generic functionality of the mind for a simple application. 1

Abstract. In recent years, within the planning literature there has been a departure from approaches computing total plans for given goals, in favour of approaches computing partial plans. Total plans can be seen as (partially ordered) sets of actions which, if executed successfully, would lead to the achievement of the goals. Partial plans, instead, can be seen as (partially ordered) sets of actions which, if executed successfully, would contribute to the achievement of the goals, subject to the achievement of further sub-goals. Planning partially (namely computing partial plans for goals) is useful (or even necessary) for a number of reasons: (i) because the planning agent is resource-bounded, (ii) because the agent has incomplete and possibly incorrect knowledge of the environment in which it is situated, (iii) because this environment is highly dynamic. In this paper, we propose a framework to design situated agents capable of planning partially. The framework is based upon the specification of planning problems via an abductive variant of the event calculus. 1

Abstract. In this paper, we present a model of agents which use argumentation to select and compose services in open and distributed environments. For this purpose, we propose a modular agent architecture using three main modules, dedicated, respectively, to decision making, communication, and negotiation. We deploy a simple “virtual ” travel agent example to illustrate how our agents select and compose services, focusing on the functionalities of the modules within the agents. 1

Introduction Abduction has long been recognised as a powerful mechanism for hypothetical reasoning in the presence of incomplete knowledge. Here, we discuss the implementation of a novel abductive proof procedure, which we call CIFF, as it extends the IFF proof procedure [7] by dealing with Constraints, as in constraint logic programming. The procedure also relaxes the strong allowedness restrictions on abductive logic programs imposed by IFF. The procedure is described in detail in [6]. It is currently employed to realise a number of reasoning tasks of KGP agents [8] within the platform for developing agents and agent applications PROSOCS [12]. These tasks include (partial) planning in a dynamic environment [9, 5], reactivity to changes in the environment [5], temporal reasoning in the absence of complete information about the environment [2, 1], communication and negotiation [11], and trust-mediated interaction [10]. Some details on an earlier version of the system and the planning

Abstract. We present the computational counterpart of the KGP (Knowledge, Goals, Plan) declarative model of agency for Global Computing. In this context, a computational entity is seen as an agent developed using Computational Logic tools and techniques. We model a KGP agent by relying upon a collection of capabilities, which are then used to define a collection of transitions, to be used within logically specified, context sensitive control theories, which we call cycle theories. In close relationship to the declarative model, the computational model mirrors the logical architecture by specifying appropriate computational counterparts for the capabilities and using these to give the computational models of the transitions. These computational models and the one specified for the cycle theories are all based on, and are significant extensions of, existing proof procedures for abductive logic programming and logic programming with priorities. We also discuss a prototype implementation of the overall computational model for KGP. 1

We introduce a new proof procedure for abductive logic programming and prove two soundness results. Our procedure extends that of Fung and Kowalski by integrating abductive reasoning with constraint solving and by relaxing the restrictions on allowed inputs for which the procedure can operate correctly. An implementation of our proof procedure is available and has been applied successfully in the context of multiagent systems.