Agent Theories, Architectures, and Languages: A Survey <s> Shoham -agent-oriented programming <s> Researchers using epistemic logic as a formal framework for studying knowledge properties of AI systems often interpret the knowledge formula K(x, φ) to mean that machine x encodes φ in its state as a syntactic formula or can derive it inferentially. By defining K(x, φ), instead, in terms of the correlation between the state of the machine and that of its environment, the formal properties of modal system S5 can be satisfied without having to store representations of formulas as data structures. In this paper, we apply the correlational definition of knowledge to machines with composite structure. In particular, we describe how epistemic properties of synchronous digital machines can be analyzed, starting at the level of gates and delays, by modeling the machine's components as agents in a multi-agent system and reasoning about the flow of information among them. We also introduce Rex, a language for recursively computing machine descriptions, and illustrate how it can be used to construct machines with provable knowledge properties. <s> BIB001 </s> Agent Theories, Architectures, and Languages: A Survey <s> Shoham -agent-oriented programming <s> As part of our work on agent-oriented programming,1 we are developing an agent description language. We describe an agent's “mental state” in terms of its knowledge, beliefs, desires, commitments, and abilities. Our goal is not to specify human knowledge, beliefs, etc., but rather to devise a more limited, precise language to facilitate programming agents and interagent communication. We believe that borrowing from our intuition about these commonsense terms will simplify the human designer's job. This article describes a preliminary version of our language. We define a temporal language with modal operators representing knowledge, belief, desire, commitment, and ability. This is a propositional language with quantification over time points and agents only. <s> BIB002 </s> Agent Theories, Architectures, and Languages: A Survey <s> Shoham -agent-oriented programming <s> Abstract A new computational framework is presented, called agent-oriented programming (AOP), which can be viewed as a specialization of object-oriented programming . The state of an agent consists of components such as beliefs, decisions, capabilities, and obligations; for this reason the state of an agent is called its mental state . The mental state of agents is described formally in an extension of standard epistemic logics: beside temporalizing the knowledge and belief operators, AOP introduces operators for obligation, decision, and capability. Agents are controlled by agent programs , which include primitives for communicating with other agents. In the spirit of speech act theory , each communication primitive is of a certain type: informing, requesting, offering, and so on. This article presents the concept of AOP, discusses the concept of mental state and its formal underpinning, defines a class of agent interpreters, and then describes in detail a specific interpreter that has been implemented. <s> BIB003 </s> Agent Theories, Architectures, and Languages: A Survey <s> Shoham -agent-oriented programming <s> When multiple "agents" (robots, intelligent processes, people) share an environment they very often share resources; this requires coordination. Centralized coordination introduces a bottleneck into the system, so distributed coordination is often preferable. If agents can adopt new tasks dynamically then maximum flexibility is obtained when this coordination is done dynamically as well. This requires that agents be able to communicate with each other, and further that they be able to decide dynamically when and what to communicate. Shoham has proposed "agent oriented programming" as a method for programming intelligent, autonomous processes which interact in a shared environment. "Agents" are entities that may be modeled in terms of their "mental states", consisting of such components as beliefs, abilities, desires, and intentions. An agent's program gives its initial mental state and a set of rules which specify a transition function: given an agent's current state and input, these rules specify the agent's new mental state and output. Agents communicate by sending messages; these messages come in several types, where the types are drawn from speech act theory (requests, promises, etc.). ::: In this dissertation we present and discuss a new agent-oriented programming language, PLACA (which stands for PLAnning Communicating Agents). PLACA is a descendant of AGENT0, the first agent-oriented programming language; it addresses a particular shortcoming of AGENT0. Specifically, PLACA capitalizes on the planning abilities of agents. Assuming that all agents in a particular environment have at least elementary planning abilities, PLACA agents can make high-level requests of each other without worrying about the details of how a particular task will be carried out. In order to achieve this, agents' mental states have been expanded to include plans and intentions in addition to the beliefs and capabilities present in AGENT0 (obligations and decisions were dropped). The kinds of changes to the mental state which may be specified in an agent program have also been expanded. ::: We present a logic in which to represent the components of an agent's mental state, the programming language PLACA, and a description and discussion of a simple implemented PLACA interpreter. <s> BIB004
Yoav Shoham has proposed a 'new programming paradigm, based on a societal view of computation' [121, p4] , BIB003 . The key idea which informs this agent-oriented programming (AOP) paradigm is that of directly programming agents in terms of the mentalistic, intentional notions that agent theorists have developed to represent the properties of agents. The motivation behind such a proposal is that, as we observed in section 2, humans use the intentional stance as an abstraction mechanism for representing the properties of complex systems. In the same way that we use the intentional stance to describe humans, it might be useful to use the intentional stance to program machines. Shoham proposes that a fully developed AOP system will have three components: • a logical system for defining the mental state of agents; • an interpreted programming language for programming agents; • an 'agentification' process, for compiling agent programs into low-level executable systems. At the time of writing, Shoham has only published results on the first two components. (In [121, p12] he wrote that 'the third is still somewhat mysterious to me', though later in the paper he indicated that he was thinking of something along the lines of Rosenschein & Kaelbling's situated automata paradigm BIB001 .) Shoham's first attempt at an AOP language was the AGENT0 system. The logical component of this system is a quantified multi-modal logic, allowing direct reference to time. No semantics are given, but the logic appears to be based on BIB002 . The logic contains three modalities: belief, commitment and ability. The following is an acceptable formula of the logic, illustrating it's key properties: This formula is read: 'if at time 5 agent a can ensure that the door is open at time 8, then at time 5 agent b believes that at time 5 agent a can ensure that the door is open at time 8'. Corresponding to the logic is the AGENT0 programming language. In this language, an agent is specified in terms of a set of capabilities (things the agent can do), a set of initial beliefs and commitments, and a set of commitment rules. The key component, which determines how the agent acts, is the commitment rule set. Each commitment rule contains a message condition, a mental condition, and an action. In order to determine whether such a rule fires, the message condition is matched against the messages the agent has received; the mental condition is matched against the beliefs of the agent. If the rule fires, then the agent becomes committed to the action. Actions may be private, corresponding to an internally executed subroutine, or communicative, i.e., sending messages. Messages are constrained to be one of three types: 'requests' or 'unrequests' to perform or refrain from actions, and 'inform' messages, which pass on information -Shoham indicates that he took his inspiration for these message types from speech act theory   . Request and unrequest messages typically result in the agent's commitments being modified; inform messages result in a change to the agent's beliefs. AGENT0 was only ever intended as a prototype, to illustrate the principles of AOP. A more refined implementation was developed by Thomas, for her 1993 doctoral thesis BIB004 . Her Planning Communicating Agents (PLACA) language was intended to address one severe drawback to AGENT0: the inability of agents to plan, and communicate requests for action via high-level goals. Agents in PLACA are programmed in much the same way as in AGENT0, in terms of mental change rules. The logical component of PLACA is similar to AGENT0's, but includes operators for planning to do actions and achieve goals. The semantics of the logic and its properties are examined in detail. However, PLACA is not at the 'production' stage; it is an experimental language.