Software Agents

Software systems must be:

• Situated: responsive to and influential upon their environment
• Open: entities will enter & leave the environments continually
• Autonomous: entities and systems will be goal-directed and exhibit autonomous behaviours Systems and sub-systems will have multiple threads of control.

Robust systems can deal with changes in their environment, new entities, new relationships between entities, new goals, etc. When designing for system-level properties, engineers need to generate desired system behaviours without designing all the components, & without knowledge of initial states / possible interactions.

• Living systems: systems need to be tested, maintained, and upgraded without removal, or even without downtime.

A software agent is a computational entity with some degree of:

• social awareness
• proactive behaviour towards defined goals
• reactive behaviour in response to its environment
• decision-making autonomy

Slides 6-21 skipped.

Agent Communication Languages (ACLs)

There are two major proposals for ACLs:

• Knowledge Query and Manipulation Language (KQML)
• IEEE Foundation for Intelligent Physical Agents ACL (FIPA ACL)

FIPA ACL

IEEE FIPA ACL has 22 locutions (types of utterances, e.g. inform, query-if, request, agree, refuse) with each having a defined syntax:

(inform
		:sender (agent-identifier:name j)
		:receiver (agent-identifier:name i)
		:content "weather (today, raining)"
		:language Prolog)

It has:

• factual statements (8 locutions)
• expressive statements (1 locution, inform)
• social connection statements (1 locution, inform)
• commissives (5 locutions)
• directives (5 locutions)
• inferences (1 locution)
• argumentation statements (0 locutions)
• control statements (4 locutions)

Issues with FIPA ACL

• Language for knowledge-sharing => semantics impose sincerity Sincerity may not be desired for many applications, e.g. negotiations
• Language for contract negotiations => underlying argumentation theory is simplistic No ability to argue, challenge, or justify statements
• Absence of explicit argumentation theory causes a state-space explosion
• Language does not readily support self-transformation
• Private axiomatic semantics are not verifiable

Semantics

There are different types of semantics:

• Axiomatic semantics articulates the pre-conditions and post-conditions of an utterance: what needs to be true before and what has to become true after. Usually done in a formal language, such as first order logic.

  FIPA ACL has formal, axiomatic semantics using speech act theory, called SL (“semantic language”). SL links utterances to private mental states of participants, incl. beliefs, uncertain beliefs, desires, and intentions.

  

• Operational semantics treats the utterances in an agent interaction as programming commands working on some large, virtual machine (commands act to change state of the virtual machine). We view utterances as functions that cause state transitions.

  

• In denotational semantics, each formula is mapped to some object in a mathematical space. Having a denotational mapping means we can reason about the language by reasoning about the mathematical objects.

  This can be implemented as:

  • Possible Worlds semantics is the standard semantic for modal logic languages. This is a collection of states of the world, at each of which some propositions are true and some are not. Some worlds are connected by accessibility relationships to show it is possible to move from one world-state to another.

    

  • In Game Theoretic Semantics, each well-formed statement in the language corresponds to a game $G$, usually between two fictional players, $P$ and $A$. Usually, we say that the goals of the players are that $P$ aims to win the game $G$ and $A$ aims to prevent $P$ from winning the game $G$. The statement is true (or valid) iff $P$ always has a winning strategy for the game.

Dialog Game Protocols

Dialogue Game Protocols are games between two or more participants where each ‘moves’ by making utterances, subject to some rules.

A DG Protocol is defined in terms of a language of statements (the topics of dialog), a set of utterances instantiated with the statements (e.g. assert(p), accept(p), contest(p)), combination rules defining circumstances in which each utterance may be uttered, termination rules defining in which dialogs terminate, and rules for creating and combining commitments. (commitment stores are publicly-accessible sets of statements, holding the commitments incurred by participants)

FIPA ACL’s lack of structure causes a state-space explosion, we could solve it by using:

• Conversation Policies (CPs) are sequences of utterance-patterns for a small number of utterances, e.g. a question must be followed by a response and a request for proposals must only be followed by a proposal or proposals.
• Formal Dialog Games (DGs)

Simple protocol example

Example Applications

The Border Gateway Protocol (BGP) is an Internet Protocol at Layer 3 which allows for negotiation between neighbouring autonomous domains over routing and reachability of internet addresses.

The Fatio Argumentation Protocol is an extension FIPA ACL to allow intelligent agents to argue with one another, allows for claims to be questioned, challenged, and justified. Fatio has been used to support automated identification and resolution of conflicts between hosts using the BGP.